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

Ответы

Ответ 1

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.prototype.reverse() - это все, что вам нужно для этой работы. Смотрите таблицу совместимости.

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

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

Ответ 3

Это функциональный способ сделать это.

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

function reverse(array){
  return array.map((item,idx) => array[array.length-1-idx])
}

Ответ 4

20 байт

let reverse=a=>[...a].map(a.pop,a)

Ответ 5

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

array.reverse();

DEMO

Ответ 6

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

Ответ 7

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)

Ответ 8

Вот версия, которая не требует массива temp.

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]

Ответ 9

Самый короткий обратный метод, который я видел, это:

let reverse = a=>a.sort(a=>1)

Ответ 10

Метод кратчайшего обратного массива без использования обратного метода:

 var a = [0, 1, 4, 1, 3, 9, 3, 7, 8544, 4, 2, 1, 2, 3];

 a.map(a.pop,[...a]); 
// returns [3, 2, 1, 2, 4, 8544, 7, 3, 9, 3, 1, 4, 1, 0]

Метод a.pop снимает последний элемент и выводит его с помощью оператора распространения()

MDN ссылки для справки:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop

Ответ 11

Я сделал несколько тестов решений, которые не только реверсивного массива, но и делают его копию. Вот тестовый код. Метод reverse2 является самым быстрым в Chrome, но в Firefox метод reverse является самым быстрым.

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

Ответ 12

Обратный с помощью метода сортировки

Это гораздо более краткий метод.

const resultN = document.querySelector('.resultN');
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>

Ответ 13

Как уже упоминалось, вы можете использовать .reverse() для объекта массива.

Однако, если вы заботитесь о сохранении исходного объекта, вы можете использовать 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'];

Ответ 14

53 байта

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

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

Ответ 15

Чистые функции для обращения массива с помощью функционального программирования:

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

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

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

Ответ 16

var array = ['C','D','A','Z']

console.log(array.sort(function(el, val){
    return el != val;
}))

Я удивлен, что никто не упомянул sort

Кроме того, вот некоторые подробности о его реализации:

Числовые массивы (или массивы примитивного типа) сортируются с использованием стандартной библиотечной функции С++ std:: qsort, которая реализует некоторые изменения quicksort (обычно introsort).

Смежные массивы нечислового типа строятся и сортируются с использованием mergesort, если они доступны (для получения стабильной сортировки) или qsort, если не существует сортировки слияния.

Для других типов (несмежных массивов и предположительно для ассоциативных массивов) WebKit использует либо сортировку (которая называется "min" ), либо в некоторых случаях она сортируется через дерево AVL. К сожалению, документация здесь довольно расплывчата, поэтому вам нужно проследить пути кода, чтобы действительно увидеть, для каких типов используется метод сортировки.

Источник

Ответ 17

Используя ES6 оператор покоя и функцию стрелки.

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

Ответ 18

Это также может быть достигнуто с помощью метода карты.

[1, 2, 3].map((value, index, arr) => arr[arr.length - index - 1])); // [3, 2, 1]

Или используя уменьшение (немного дольше подход)

[1, 2, 3].reduce((acc, curr, index, arr) => {
    acc[arr.length - index - 1] = curr;
    return acc;
}, []);

Ответ 19

Как насчет без использования push()!

Решение с использованием 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));

Ответ 20

function reverseArray(arr) {
    let reversed = [];
    for (i = 0; i < arr.length; i++) { 
    reversed.push((arr[arr.length-1-i]))
    }
  return reversed;
}

Ответ 21

JavaScript уже имеет метод reverse() на Array, поэтому вам не нужно так много делать!

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

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 для массива:

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

и вы можете называть его следующим образом:

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

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

Ответ 22

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

function reverse(args) {
  console.log(args.length);
  for (var i = args.length - 1; i >= 0; i--) {
    arr.push(a[i]); 
  }
  return arr;
}
console.log(reverse(a));

Ответ 23

Я нашел простой способ сделать это с помощью .slice(). reverse()

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

console.log(reverseArray)

Вы получите

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

Ответ 24

Вы можете сделать

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

console.log(reverseArray)

Вы получите

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

Ответ 25

Для более сжатого подхода и не влияет на исходный массив:

let thisArray = [1, 2, 3, 4];
let thatArray = [...thisArray].reverse();

Это не влияет на thisArray на месте, так как это поведение операции spread. Операция spread копирует перечислимые свойства старого объекта на новый объект (thatArray), имея в виду, что старый объект (thisArray) не изменен (изменен) на месте. В отличие от метода reverse(), который действует вместо объекта, на который он воздействует.

Ответ 26

Как насчет этого?:

  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/

Ответ 27

Эта функция будет работать с массивами, которые могут иметь разрывы между своими индексами.

function reverse( a ) {
    var b = [], c = [] ;
    a.forEach( function( v ) { b.push( v ) } ) ;
    a.forEach( function( v, i ) { c[i] = b.pop() } ) ;
    return c ;
}

var a= [] ; a[1] = 2 ; a[3] = 4 ; a[7] = 6 ; a[9] = 8 ;
a = reverse( a ) ;
var s = '' ;
a.forEach( function( v, i ) { s += 'a[' + i + '] = ' + v + '  ' } ) ;
console.log( s ) ;
// a[1] = 8  a[3] = 6  a[7] = 4  a[9] = 2

Ответ 28

Ниже представлено решение с лучшей пространственно-временной сложностью.

function reverse(arr){
let i = 0;
let j = arr.length-1; 
while(i<j){
arr[j] = arr[j]+arr[i];
arr[i] = arr[j] - arr[i];
arr[j] = arr[j] - arr[i];
i++;
j--;
}
return arr;
}
var arr = [1,2,3,4,5,6,7,8,9]
reverse(arr);

вывод => [9,8,7,6,5,4,3,2,1]

Ответ 29

Использование метода .pop() и цикла while.

var original = [1,2,3,4];
var reverse = [];
while(original.length){
    reverse.push(original.pop());
}

Вывод: [4,3,2,1]

Ответ 30

Я просто переписал реализацию haskell на js.

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, [])

Как можно изменить массив на JavaScript без использования библиотек?