JavaScript中对反转数组调用.map方法的高效实现方案

一、更高效的逆序Map实现 #

你的现有方案需要先复制数组（slice(0)）再反转（reverse()），这两步都是O(n)操作且会产生额外中间数组。如果仅需逆序读取原数组元素生成新数组，直接逆序遍历原数组即可省去复制和反转的开销：

方式1：for循环直接生成（性能最优） #

let arr = [1, 2, 3, 4, 5];
let rev_wrapped = [];
// 从最后一个元素遍历至第一个
for (let i = arr.length - 1; i >= 0; i--) {
  rev_wrapped.push(`wrapped: ${arr[i]}`);
}

执行结果和原方案完全一致，但仅需一次遍历，无多余数组复制和反转操作，多次执行时性能提升明显。

方式2：Array.from简洁实现 #

若偏好简洁写法，可用Array.from直接生成结果数组，同样逆序访问原数组：

let arr = [1, 2, 3, 4, 5];
let rev_wrapped = Array.from({ length: arr.length }, (_, index) => {
  const reversedIndex = arr.length - 1 - index;
  return `wrapped: ${arr[reversedIndex]}`;
});

二、低成本头部插入的数据结构 #

原生数组的unshift或splice(0, 0, ...)均为O(n)操作，每次插入会移动所有现有元素，频繁执行成本极高。以下两种方案可解决该问题：

方案1：反转存储的数组（最简单） #

无需额外数据结构，用数组模拟“头部插入”：实际往数组末尾push元素（O(1)操作），需要逆序读取时从后往前遍历即可：

class ReverseStorageArray {
  constructor() {
    this._data = [];
  }

  // 逻辑上的头部插入，实际往数组末尾添加
  addToHead(value) {
    this._data.push(value);
  }

  // 逆序遍历并执行map操作
  reverseMap(callback) {
    const result = [];
    for (let i = this._data.length - 1; i >= 0; i--) {
      result.push(callback(this._data[i]));
    }
    return result;
  }
}

// 使用示例
const storage = new ReverseStorageArray();
storage.addToHead(1);
storage.addToHead(2);
storage.addToHead(3);

const rev_wrapped = storage.reverseMap(item => `wrapped: ${item}`);
// 输出: ['wrapped: 1', 'wrapped: 2', 'wrapped: 3']

方案2：双向链表（灵活度更高） #

若需支持更多操作（如任意位置插入/删除），可实现双向链表，头部插入和逆序遍历分别为O(1)和O(n)操作：

class LinkedListNode {
  constructor(value) {
    this.value = value;
    this.next = null;
    this.prev = null;
  }
}

class DoublyLinkedList {
  constructor() {
    this.head = null;
    this.tail = null;
    this.length = 0;
  }

  // 头部插入：O(1)操作
  addToHead(value) {
    const newNode = new LinkedListNode(value);
    if (!this.head) {
      this.head = newNode;
      this.tail = newNode;
    } else {
      newNode.next = this.head;
      this.head.prev = newNode;
      this.head = newNode;
    }
    this.length++;
  }

  // 从尾部开始逆序遍历并执行map
  reverseMap(callback) {
    const result = [];
    let currentNode = this.tail;
    while (currentNode) {
      result.push(callback(currentNode.value));
      currentNode = currentNode.prev;
    }
    return result;
  }
}

// 使用示例
const list = new DoublyLinkedList();
list.addToHead(1);
list.addToHead(2);
list.addToHead(3);

const rev_wrapped = list.reverseMap(item => `wrapped: ${item}`);
// 输出: ['wrapped: 1', 'wrapped: 2', 'wrapped: 3']

内容的提问来源于stack exchange，提问作者master_roby3