Comment puis-je inverser un tableau en JavaScript sans utiliser de bibliothèques?
Je sauvegarde certaines données dans l'ordre en utilisant arrays et je souhaite ajouter une fonction permettant à l'utilisateur d'inverser la liste. Je ne vois pas de méthode possible, alors si quelqu'un sait comment, aidez-moi s'il vous plaît.
Javascript a une méthode reverse() que vous pouvez appeler dans un tableau
var a = [3,5,7,8];
a.reverse(); // 8 7 5 3
Je ne sais pas si c'est ce que vous entendez par «des bibliothèques que vous ne pouvez pas utiliser», je suppose que quelque chose à faire avec la pratique Si tel est le cas, vous pouvez implémenter votre propre version de .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);
Notez que la méthode .reverse() intégrée opère sur le tableau d'origine. Vous n'avez donc pas besoin de réaffecter a.
Array.prototype.reverse()est tout ce dont vous avez besoin pour effectuer ce travail. Voir tableau de compatibilité .
var arr = [20, 40, 80, 100];
console.log(arr.reverse());
// [100, 80, 40, 20]Voici une façon fonctionnelle de le faire.
const array = [1,2,3,4,5,6,"taco"];
function reverse(array){
return array.map((item,idx) => array[array.length-1-idx])
}
20 octets
let reverse=a=>[...a].map(a.pop,a)
Voici une version qui ne nécessite pas de tableau temporaire.
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]
> var arr = [1,2,3,4,5,6];
> arr.reverse();
[6, 5, 4, 3, 2, 1]
array.reverse()
Ci-dessus inversera votre tableau, mais en modifiant l'original . Si vous ne voulez pas modifier le tableau d'origine, vous pouvez le faire:
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)
La méthode inverse la plus courte que j'ai vue est celle-ci:
let reverse = a=>a.sort(a=>1)
J'ai testé des solutions qui non seulement inversent un tableau, mais en font une copie. Voici le code de test. La méthode reverse2 est la plus rapide de Chrome, mais dans Firefox, la méthode reverse est la plus rapide.
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
Inverser en utilisant la méthode de tri
- C'est une méthode beaucoup plus succincte.
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>53 octets
function reverse(a){
for(i=0,j=a.length-1;i<j;)a[i]=a[j]+(a[j--]=a[i++],0)
}
Juste pour le plaisir, voici une implémentation alternative plus rapide que la méthode native .reverse.
Comme d'autres l'ont mentionné, vous pouvez utiliser .reverse() sur l'objet tableau.
Cependant, si vous vous souciez de en préservant l'objet d'origine , vous pouvez utiliser 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'];
JavaScript a déjà la méthode reverse () sur Array, vous n'avez donc pas besoin de faire beaucoup!
Imaginez que vous ayez le tableau ci-dessous:
var arr = [1, 2, 3, 4, 5];
Maintenant, faites simplement ceci:
arr.reverse();
et vous obtenez ceci comme résultat:
[5, 4, 3, 2, 1];
Mais ceci change fondamentalement le tableau d'origine, vous pouvez écrire une fonction et l'utiliser pour renvoyer un nouveau tableau, quelque chose comme ceci:
function reverse(arr) {
var i = arr.length, reversed = [];
while(i) {
i--;
reversed.Push(arr[i]);
}
return reversed;
}
Ou simplement modifier les méthodes JavaScript intégrées pour Array comme ceci:
function reverse(arr) {
return arr.slice().reverse();
}
et vous pouvez l'appeler comme ça:
reverse(arr); //return [5, 4, 3, 2, 1];
Juste comme mentionné, la différence principale est dans la deuxième manière, vous ne touchez pas le tableau original ...
Fonctions pures pour inverser un tableau à l'aide d'une programmation fonctionnelle:
var a = [3,5,7,8];
// ES2015
function immutableReverse(arr) {
return [ ...a ].reverse();
}
// ES5
function immutableReverse(arr) {
return a.concat().reverse()
}
Que dis-tu de ça?:
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]));
Tu peux faire
var yourArray = ["first", "second", "third", "...", "etc"]
var reverseArray = yourArray.slice().reverse()
console.log(reverseArray)
Tu auras
["etc", "...", "third", "second", "first"]
Utilisation de l’opérateur de repos ES6 et de la fonction de flèche.
const reverse = ([x, ...s]) => x ? [...reverse(s), x] : [];
reverse([1,2,3,4,5]) //[5, 4, 3, 2, 1]
Qu'en est-il sans utiliser Push ()!
Solution utilisant 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));
function reverseArray(arr) {
let reversed = [];
for (i = 0; i < arr.length; i++) {
reversed.Push((arr[arr.length-1-i]))
}
return reversed;
}