How to quickly clear an array?

const originalArray = [1, 2, 3, 4, 5];
const reference1 = originalArray;
const reference2 = originalArray;
 
// If you simply assign a new array
originalArray = []; // ❌ References reference1 and reference2 still point to the old array
 
console.log(reference1); // [1, 2, 3, 4, 5] — old array!
console.log(reference2); // [1, 2, 3, 4, 5] — old array!

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;
  
  // Test 1: length = 0
  console.time('length = 0');
  let arr1 = new Array(arraySize).fill(1);
  arr1.length = 0;
  console.timeEnd('length = 0');
  
  // Test 2: splice(0)
  console.time('splice(0)');
  let arr2 = new Array(arraySize).fill(1);
  arr2.splice(0);
  console.timeEnd('splice(0)');
  
  // Test 3: new array
  console.time('new array');
  let arr3 = new Array(arraySize).fill(1);
  arr3 = [];
  console.timeEnd('new array');
  
  // Test 4: pop() in loop
  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);
  }
  
  // Fast cart clearing
  clear() {
    this.items.length = 0; // Preserve array reference
  }
  
  // Clearing with getting removed elements
  clearAndGetItems() {
    return this.items.splice(0); // Return removed items
  }
}
 
const cart = new ShoppingCart();
cart.addItem({ name: "Bread", price: 30 });
cart.addItem({ name: "Milk", price: 60 });
 
console.log(cart.items.length); // 2
cart.clear();
console.log(cart.items.length); // 0

class TodoManager {
  constructor() {
    this.tasks = [];
    this.observers = []; // Subscribers to changes
  }
  
  addObserver(callback) {
    this.observers.push(callback);
  }
  
  addTask(task) {
    this.tasks.push(task);
    this.notifyObservers();
  }
  
  // Clearing with notifying subscribers
  clearAllTasks() {
    const removedTasks = this.tasks.splice(0); // Get removed
    this.notifyObservers('cleared', removedTasks);
    return removedTasks;
  }
  
  // Fast clearing without notifications
  fastClear() {
    this.tasks.length = 0;
  }
  
  notifyObservers(action = 'updated', data = null) {
    this.observers.forEach(callback => {
      callback(this.tasks, action, data);
    });
  }
}
 
const todoManager = new TodoManager();
 
// Subscribe to changes
todoManager.addObserver((tasks, action, data) => {
  console.log(`Action: ${action}, tasks: ${tasks.length}`);
  if (data) console.log('Removed:', data);
});
 
todoManager.addTask("Learn arrays");
todoManager.addTask("Write code");
todoManager.clearAllTasks(); // Clear with notification

class DataBuffer {
  constructor(maxSize = 1000) {
    this.buffer = [];
    this.maxSize = maxSize;
  }
  
  add(data) {
    this.buffer.push(data);
    
    // Clear buffer if size exceeded
    if (this.buffer.length > this.maxSize) {
      this.clear();
    }
  }
  
  // Fast buffer clearing
  clear() {
    this.buffer.length = 0;
    console.log('Buffer cleared');
  }
  
  // Clearing with keeping last N elements
  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]; // Return copy
  }
}
 
const buffer = new DataBuffer(5);
buffer.add("data 1");
buffer.add("data 2");
buffer.add("data 3");
buffer.add("data 4");
buffer.add("data 5");
buffer.add("data 6"); // Buffer will clear automatically

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];
 
// Save elements before clearing
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) => {
      // Simulate async clearing
      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(`Removed ${count} elements`);
});

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; // Clear trigger
console.log(smartArray); // []

// 1. Use length = 0 for fast clearing
const fastClear = (arr) => {
  arr.length = 0; // ✅ Fastest method
};
 
// 2. Use splice(0) when you need removed elements
const clearAndBackup = (arr) => {
  return arr.splice(0); // ✅ Returns removed
};
 
// 3. Document method choice
class DataManager {
  clearData() {
    // Use length = 0 to preserve references
    // and maximum performance
    this.data.length = 0;
  }
}
 
// 4. Check if clearing is necessary
const safeClear = (arr) => {
  if (arr && arr.length > 0) {
    arr.length = 0;
  }
};

// ❌ Slow clearing through shift
while (array.length > 0) {
  array.shift(); // Very slow!
}
 
// ❌ Creating new array when you need to preserve references
function clearArray(arr) {
  arr = []; // Doesn't affect original array!
  return arr;
}
 
// ❌ Clearing in forEach loop
array.forEach((item, index) => {
  delete array[index]; // Creates sparse array
});
 
// ❌ Using delete
for (let i = 0; i < array.length; i++) {
  delete array[i]; // Doesn't change length!
}

// ❌ Problem
function clearUserArray(users) {
  users = []; // Doesn't clear original array!
  return users;
}
 
const myUsers = ["Anna", "Boris"];
const cleared = clearUserArray(myUsers);
console.log(myUsers); // ["Anna", "Boris"] — not cleared!
 
// ✅ Solution
function clearUserArray(users) {
  users.length = 0; // Clears original array
  return users;
}

// ❌ Data loss
const importantData = ["important", "data"];
importantData.splice(0); // Removed data is lost!
 
// ✅ Saving data
const importantData2 = ["important", "data"];
const backup = importantData2.splice(0); // Save removed
console.log(backup); // ["important", "data"]

// ❌ Problem
const numbers = [1, 2, 3, 4, 5];
numbers.forEach((num, index) => {
  if (num > 3) {
    numbers.length = 0; // Interrupts iteration!
  }
});
 
// ✅ Solution
const numbers2 = [1, 2, 3, 4, 5];
const shouldClear = numbers2.some(num => num > 3);
if (shouldClear) {
  numbers2.length = 0;
}

// For most cases
array.length = 0;
 
// When you need removed elements
const removed = array.splice(0);
 
// For creating new array
let array = [];