Каков наиболее эффективный способ обращения массива в Javascript?

собственные методы всегда быстрее.

так что используйте Array.reverse там, где это возможно. В противном случае реализация, которая выполняется в O(1) будет лучше ;)

в противном случае просто использовать что-то вроде этого

var reverse = function(arr) {
   var result = [],
       ii = arr.length;
   for (var i = ii - 1;i !== 0;i--) {
       result.push(arr[i]);
   }
   return result;
}

эталоном!

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

for(var i = ii - 1; i !== 0;i--) затем быстрее var i = ii - 1;for(;i-- !== 0;)

Я открыл ошибку Firefox о медленной обратной производительности в Firefox. Кто-то из Mozilla посмотрел на бенчмарк, используемый в принятом сообщении, и говорит, что это довольно вводит в заблуждение-в их анализе родной метод лучше в целом для реверсирования массивов. (Как и должно быть!)

простым способом вы можете сделать это с помощью карты.

let list = [10, 20, 30, 60, 90]
let reversedList = list.map((e, i, a)=> a[(a.length -1) -i]) // [90, 60...]

Так как никто не придумал его и завершить список способов реверсирования массива...

array.sort(function() {
    return 1;
})

это в два раза быстрее, чем оба в то время как-подходы, но кроме этого, ужасно медленно.

http://jsperf.com/js-array-reverse-vs-while-loop/53

функции подкачки являются самыми быстрыми. Вот обратная функция, которую я написал, которая только немного похожа на функции подкачки, упомянутые выше, но работает быстрее.

function reverse(array) {
  var first = null;
  var last = null;
  var tmp = null;
  var length = array.length;

  for (first = 0, last = length - 1; first < length / 2; first++, last--) {
    tmp = array[first];
    array[first] = array[last];
    array[last] = tmp;
  }
}

вы можете найти бенчмаркинг здесь http://jsperf.com/js-array-reverse-vs-while-loop/19

вот пример javahttp://www.leepoint.net/notes-java/data/arrays/arrays-ex-reverse.html показывает, как изменить массив. Очень легко конвертировать в javascript.

Я бы предложил использовать что-то, что просто фиксирует время до вызова функции и после вызова функции. Который когда-либо занимает меньше времени / тактов будет самым быстрым.

Если вы хотите скопировать перевернутую версию массива и сохранить оригинал как есть:

a = [0,1,2,3,4,5,6,7,8,9];
b = []
for(i=0;i<a.length;i++){
    b.push(a.slice(a.length-i-1,a.length-i)[0])
}

выход b:

[ 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

вот еще один пример, чтобы изменить массив обращая его элементы:

var theArray = ['a', 'b', 'c', 'd', 'e', 'f'];

function reverseArrayInPlace(array) {
  for (var i = array.length - 1; i >= 0; i -= 1) {
    array.push(array[i]);
  }
  array.splice(0, array.length / 2);
  return array;
};
reverseArrayInPlace(theArray);
console.log(theArray); // -> ["f", "e", "d", "c", "b", "a"]

вот несколько трюков, которые я нашел. Кредит идет на Codemanx для оригинального решения

array.sort(function() {
   return 1;
})

в Typescript это можно упростить до одной строки

array.sort(() => 1)

var numbers = [1,4,9,13,16];

console.log(numbers.sort(() => 1));

так как это будет будущее JavaScript, я думал, что поделюсь этим.

вот еще один трюк, если Ваш массив имеет только 2 элемента

array.push(array.shift());

еще одно предложение, аналогичное приведенному выше, но с использованием соединения вместо этого:

var myArray=["one","two","three","four","five","six"];
console.log(myArray);
for(i=0;i<myArray.length;i++){
myArray.splice(i,0,myArray.pop(myArray[myArray.length-1]));
}
console.log(myArray);

Это наиболее эффективный и чистый способ обращения массива с помощью тернарного оператора.

function reverse(arr) {
  return arr.length < 2 ? arr : [arr.pop()].concat(reverse(arr));
}
console.log(reverse([4, 3, 3, 1]));

Я нашел простой способ сделать это .ломтик.)(обратный()

var yourArray = ["first", "second", "third", "...", "etc"]
var reverseArray = yourArray.slice().reverse()

console.log(reverseArray)

Вы получаете

["etc", "...", "third", "second", "first"]

вы также можете использовать reduceRight, который будет перебирать каждое значение массива (справа-налево)

const myArray = [1, 2, 3, 4, 5]
const reversedArray = myArray.reduceRight((acc, curr) => [...acc, curr], [])
console.log(reversedArray) // [5, 4, 3, 2, 1]