Вопрос по javascript, arrays – Как я могу обратить массив в JavaScript без использования библиотек?

28

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

developer.mozilla.org/en/JavaScript/Reference/Global_Objects/… попробуйте Google в следующий раз? jbabey

Ваш Ответ

21   ответ
12

20 bytes

@trincot Почему мы должны выполнитьpop сa какthis? Не могли бы вы объяснить немного дальше?
Может ли кто-нибудь объяснить это мне?
@ user169320[...a] клонирует массив,.map(a.pop, a) выталкивает массив (возвращает последний элемент массива) и помещает его в новый массив, что приводит к обращенному массиву. Derek 朕會功夫
... и второй аргументmap удостоверяется, чтоpop выполняется сa какthisкак если бы вы сделалиa.pop()
Интересное решение! Derek 朕會功夫
3

> var arr = [1,2,3,4,5,6];
> arr.reverse();
  [6, 5, 4, 3, 2, 1]
0

What about without using push() !

Solution using XOR !

var myARray = [1,2,3,4,5,6,7,8];

function rver(x){
    var l = x.length;
    for(var i=0; i<Math.floor(l/2); i++){

        var a = x[i];
        var b = x[l-1-i];

        a = a^b;
        b = b^a;
        a = a^b;

        x[i] = a;
        x[l-1-i] = b;
    }

    return x;

}

console.log(rver(myARray));
Использование временных переменных как бы побеждает точку обмена XOR.
Что делает это^ символ сделать вa^b?
24

Array.prototype.reverse() is all you need to do this work. See compatibility table.

var arr = [20, 40, 80, 100];

console.log(arr.reverse());
// [100, 80, 40, 20]

хороший, неразрушающий
Да, спасибо за ваш ответ на этот старый вопрос. Derek 朕會功夫
Следует отметить, чтоconcat копирует ссылки на объекты в новый массив. И оригинальный, и новый массив ссылаются на один и тот же объект ...
2

которые не только обращаются к массиву, но и делают его копию. Вот тестовый код.reverse2 метод самый быстрый в Chrome, но в Firefoxreverse Метод самый быстрый.

var array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

var reverse1 = function() {
  var reversed = array.slice().reverse();
};

var reverse2 = function() {
  var reversed = [];
  for (var i = array.length - 1; i >= 0; i--) {
    reversed.push(array[i]);
  }
};

var reverse3 = function() {
  var reversed = [];
  array.forEach(function(v) {
    reversed.unshift(v);
  });
};

console.time('reverse1');
for (var x = 0; x < 1000000; x++) {
  reverse1();
}
console.timeEnd('reverse1'); // Around 184ms on my computer in Chrome

console.time('reverse2');
for (var x = 0; x < 1000000; x++) {
  reverse2();
}
console.timeEnd('reverse2'); // Around 78ms on my computer in Chrome

console.time('reverse3');
for (var x = 0; x < 1000000; x++) {
  reverse3();
}
console.timeEnd('reverse3'); // Around 1114ms on my computer in Chrome
0

  function reverse(arr) {
    function doReverse(a, left, right) {
      if (left >= right) {
        return a;
      }
      const temp = a[left];
      a[left] = a[right];
      a[right] = temp;
      left++;
      right--;
      return doReverse(a, left, right);
    }

    return doReverse(arr, 0, arr.length - 1);
  }

  console.log(reverse([1,2,3,4]));

https://jsfiddle.net/ygpnt593/8/

2

Reverse by using the sort method This is a much more succinct method.

const resultL = document.querySelector('.resultL');

const dataNum = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
const dataLetters = ['a', 'b', 'c', 'd', 'e'];

const revBySort = (array) => array.sort((a, b) => a < b);

resultN.innerHTML = revBySort(dataNum);
resultL.innerHTML = revBySort(dataLetters);
<div class="resultN"></div>
<div class="resultL"></div>

Это обратное изменение на месте неэффективно, а метод сортировки неверен (непоследовательная функция сравнения имеет поведение, определяемое реализацией).
0

function reverseArray(arr) {
    let reversed = [];
    for (i = 0; i < arr.length; i++) { 
    reversed.push((arr[arr.length-1-i]))
    }
  return reversed;
}
Пояснение с кодом завершает ответ
3

function inplaceReverse(arr) {
  var i = 0;
  while (i < arr.length - 1) {
    arr.splice(i, 0, arr.pop());
    i++;
  }
  return arr;
}

// Useage:
var arr = [1, 2, 3];
console.log(inplaceReverse(arr)); // [3, 2, 1]
Error: User Rate Limit Exceeded
0

const reverse = ([x, ...s]) => x ? [...reverse(s), x] : [];
reverse([1,2,3,4,5]) //[5, 4, 3, 2, 1]
0

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

console.log(reverseArray)

Ты получишь

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

поэтому вам не нужно делать это слишком много!

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

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

Теперь просто сделайте это:

arr.reverse();

и вы получите это в результате:

[5, 4, 3, 2, 1];

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

function reverse(arr) {
  var i = arr.length, reversed = [];
  while(i) {
    i--;
    reversed.push(arr[i]);
  }
  return reversed;
}

Или просто измените встроенные методы JavaScript для Array следующим образом:

function reverse(arr) {
  return arr.slice().reverse();
}

и вы можете назвать это так:

reverse(arr); //return [5, 4, 3, 2, 1];

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

1

.reverse() на объекте массива.

Однако, если вы заботитесь оpreserving the original object, вы можете использоватьreduce вместо:

const original = ['a', 'b', 'c'];
const reversed = original.reduce( (a, b) => [b].concat(a) );
//                                           ^
//                                           |
//                                           +-- prepend b to previous accumulation

// original: ['a', 'b', 'c'];
// reversed: ['c', 'b', 'a'];
2

let reverse = a=>a.sort(a=>1)
Разве это не зависит от того, как осуществляется сортировка? Поскольку функция сравнения не является согласованной (т.е. она всегда возвращает 1), поведение не определено. Derek 朕會功夫
Я не предлагаю это в качестве хорошей практики, просто подумал, что это интересный, нетрадиционный подход к хорошо известной операции.
Проблема в том, что он не может перевернуть массив с другими интерпретаторами. Derek 朕會功夫
На самом деле я был удивлен, увидев, что это работает так, как это было.[1,2,3,4].sort(a=>1) возвращает правильный ответ, например. Идея состоит в том, что он тесно связан с тем, как метод сортировки может использовать алгоритм сортировки, и поскольку он делает это один за другим, он всегда переставляется.
5

Это то, что вы хотите:

array.reverse();
DEMO
Error: User Rate Limit Exceeded Derek 朕會功夫
Error: User Rate Limit Exceeded
78

Javascript имеетreverse() метод, который вы можете вызвать в массиве

var a = [3,5,7,8];
a.reverse(); // 8 7 5 3

Не уверен, что это то, что вы подразумеваете под «библиотеками, которые вы не можете использовать», я предполагаю, что что-то связано с практикой. Если это так, вы можете реализовать свою собственную версию.reverse()

function reverseArr(input) {
    var ret = new Array;
    for(var i = input.length-1; i >= 0; i--) {
        ret.push(input[i]);
    }
    return ret;
}

var a = [3,5,7,8]
var b = reverseArr(a);

Обратите внимание, что встроенный.reverse() Метод работает с исходным массивом, поэтому вам не нужно переназначатьa.

2

array.reverse() 

Если вы не хотите изменять исходный массив, вы можете сделать это:

var arrayOne = [1,2,3,4,5];

var reverse = function(array){
    var arrayOne = array
    var array2 = [];

    for (var i = arrayOne.length-1; i >= 0; i--){
      array2.push(arrayOne[i])
    } 
    return array2
}

reverse(arrayOne)
Error: User Rate Limit Exceeded
Error: User Rate Limit Exceeded
Error: User Rate Limit ExceededarrayTwoError: User Rate Limit ExceededarrayOneError: User Rate Limit Exceeded
0

мирования:

var a = [3,5,7,8];

// ES2015
function immutableReverse(arr) {
  return [ ...a ].reverse();
}

// ES5
function immutableReverse(arr) {
  return a.concat().reverse()
}
1

53 bytes
function reverse(a){
    for(i=0,j=a.length-1;i<j;)a[i]=a[j]+(a[j--]=a[i++],0)
}

вот альтернативная реализация, которая быстрее, чем нативная.reverse метод.

12

const array = [1,2,3,4,5,6,"taco"];

function reverse(array){
  return array.map((item,idx) => array[array.length-1-idx])
}
Потрясающее решение. +1 за функциональность.
-1

const rev = (list, reversed) => {
    if (list.length == 0) return reversed

    reversed.unshift(list[0])
    return rev(list.slice(1), reversed)
}

const reverse = (list) => rev(list, [])
Эта реализация серьезно неэффективна в JS, поскольку массивы не являются связанными списками.

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