Récupère le dernier élément d'un tableau
Voici mon code JavaScript jusqu'à présent:
var linkElement = document.getElementById("BackButton");
var loc_array = document.location.href.split('/');
var newT = document.createTextNode(unescape(capWords(loc_array[loc_array.length-2])));
linkElement.appendChild(newT);
Actuellement, il faut l'avant-dernier élément du tableau à partir de l'URL. Cependant, je souhaite vérifier que le dernier élément du tableau correspond à "index.html" et, le cas échéant, prenez plutôt le troisième avant dernier élément.
if(loc_array[loc_array.length-1] == 'index.html'){
//do something
}else{
//something else.
}
Si votre serveur gère le même fichier pour "index.html" et "inDEX.htML", vous pouvez également utiliser: .toLowerCase().
Cependant, vous pouvez envisager de faire ce côté serveur si possible: ce sera plus propre et fonctionnera pour les personnes sans JS.
Pas sûr s'il y a un inconvénient, mais cela semble assez concis:
arr.slice(-1)[0]
ou
arr.slice(-1).pop()
Les deux renverront undefined si le tableau est vide.
Utilisez Array.pop :
var lastItem = anArray.pop();
Important: Ceci retourne le dernier élément etsupprime le du tableau
Une version plus courte de ce que @chaiguy a posté:
Array.prototype.last = function() {
return this[this.length - 1];
}
La lecture de l'index -1 renvoie déjà undefined.
MODIFIER:
De nos jours, la préférence semble utiliser des modules et éviter de toucher au prototype ou d’utiliser un espace de noms global.
export function last(array) {
return array[array.length - 1];
}
Deux options sont:
var last = arr[arr.length - 1]
ou
var last = arr.slice(-1)[0]
Le premier est plus rapide, mais le dernier est plus joli
Voici comment l'obtenir sans effet sur l'ARRAY d'origine
a = [1,2,5,6,1,874,98,"abc"];
a.length; //returns 8 elements
Si vous utilisez pop (), cela va modifier votre tableau _
a.pop(); // will return "abc" AND REMOVES IT from the array
a.length; // returns 7
Mais vous pouvez utiliser ceci pour qu'il y ait pas d'effet sur le tableau d'origine:
a.slice(-1).pop(); // will return "abc" won't do modify the array
// because slice creates a new array object
a.length; // returns 8; no modification and you've got you last element
La manière la plus propre d’ES6 (IMO) serait:
const foo = [1,2,3,4];
const bar = [...foo].pop();
Cela évite de muter foo, comme le ferait .pop(), si nous n'utilisions pas l'opérateur spread.
.__ Cela dit, j'aime aussi la solution foo.slice(-1)[0].
Je préfère utiliser array.pop() que les index.
while(loc_array.pop()!= "index.html"){
}
var newT = document.createTextNode(unescape(capWords(loc_array[loc_array.length])));
ainsi, vous obtenez toujours l'élément précédant index.html (à condition que votre tableau ait isolé index.html comme un seul élément). Remarque: Vous perdrez cependant les derniers éléments du tableau.
L'obtention du dernier élément d'un tableau peut être obtenue en utilisant la méthode slice avec des valeurs négatives.
Vous pouvez en lire plus à ce sujet ici en bas.
var fileName = loc_array.slice(-1)[0];
if(fileName.toLowerCase() == "index.html")
{
//your code...
}
Utiliser pop () changera votre tableau, ce qui n’est pas toujours une bonne idée.
Vous pouvez utiliser ce modèle ...
let [last] = arr.slice(-1);
N'oubliez pas qu'il crée un nouveau tableau, ce qui le rend moins efficace que les autres solutions, mais ce ne sera presque jamais le goulot d'étranglement le de votre application.
Si l’on veut obtenir le dernier élément en une fois, il peut utiliser Array#splice() :
lastElement = document.location.href.split('/').splice(-1,1);
Ici, il n'est pas nécessaire de stocker les éléments scindés dans un tableau, puis d'accéder au dernier élément. Si obtenir le dernier élément est le seul objectif, vous devez l’utiliser.
Remarque: Ceci modifie le tableau d'origine en supprimant son dernier élément. Pensez à splice(-1,1) comme une fonction pop() qui affiche le dernier élément.
Je pense que si vous voulez seulement obtenir l’élément sans enlever, c’est plus simple, utilisez ceci:
arr.slice(-1)
à propos ... je n'ai pas vérifié les performances, mais je pense que c'est plus simple et propre à écrire
Pour ceux qui n'ont pas peur de surcharger le prototype Array (et avec masquage d'énumération vous ne devriez pas l'être):
Object.defineProperty( Array.prototype, "getLast", {
enumerable: false,
configurable: false,
writable: false,
value: function() {
return this[ this.length - 1 ];
}
} );
jQuery résout parfaitement ceci:
> $([1,2,3]).get(-1)
3
> $([]).get(-1)
undefined
J'utilise généralement underscorejs , avec cela vous pouvez juste faire
if (_.last(loc_array) === 'index.html'){
etc...
}
Pour moi, c'est plus sémantique que loc_array.slice(-1)[0]
Cette question existe depuis longtemps, donc je suis surpris que personne ne mentionne simplement de replacer le dernier élément après une pop().
arr.pop() est exactement aussi efficace que arr[arr.length-1] et les deux ont la même vitesse que arr.Push().
Par conséquent, vous pouvez vous en tirer avec:
--- MODIFIÉ [vérifiez que thePop n'est pas undefined avant de pousser] ---
let thePop = arr.pop()
thePop && arr.Push(thePop)
--- FIN DE L'EDITION ---
Ce qui peut être réduit à cela (même vitesse [EDIT: mais dangereux!]):
arr.Push(thePop = arr.pop()) //Unsafe if arr empty
C'est deux fois plus lent que arr[arr.length-1], mais vous n'avez pas à chercher avec un index. Cela vaut de l'or tous les jours.
Parmi les solutions que j'ai essayées, et en multiples de l'Unité de temps d'exécution (ETU) de arr[arr.length-1]:
[Méthode] .............. [ETUs 5 elems] ... [ETU 1 million d'elems]
arr[arr.length - 1] ------> 1 -----> 1
let myPop = arr.pop()
arr.Push(myPop) ------> 2 -----> 2
arr.slice(-1).pop() ------> 36 -----> 924
arr.slice(-1)[0] ------> 36 -----> 924
[...arr].pop() ------> 120 -----> ~21,000,000 :)
Les trois dernières options, NOTAMMENT [...arr].pop(), deviennent TRES bien pire avec l’augmentation de la taille du tableau. Sur une machine sans les limites de mémoire de ma machine, [...arr].pop() conserve probablement quelque chose comme son rapport 120: 1. Pourtant, personne n'aime un porc en ressources.
Personnellement, je choisirais la réponse de kuporific/kritzikratzi. La méthode array [array.length-1] devient très laide si vous travaillez avec des tableaux imbriqués.
var array = [[1,2,3], [4,5,6], [7,8,9]]
array.slice(-1)[0]
//instead of
array[array.length-1]
//Much easier to read with nested arrays
array.slice(-1)[0].slice(-1)[0]
//instead of
array[array.length-1][array[array.length-1].length-1]
Vous pouvez ajouter une fonction last() au prototype Array.
Array.prototype.last = function () {
return this[this.length - 1];
};
const lastElement = myArray[myArray.length - 1];
Ce sont les meilleures options du point de vue des performances (environ 1000 fois plus rapide que arr.slice (-1)).
Vous pouvez ajouter un nouveau property getter au prototype de Array afin qu'il soit accessible via toutes les instances de Array.
Les Getters vous permettent d'accéder à la valeur de retour d'une fonction comme s'il s'agissait de la valeur d'une propriété. La valeur de retour de la fonction est bien sûr la dernière valeur du tableau (this[this.length - 1]).
Enfin, vous l’enveloppez dans une condition qui vérifie si la propriété last- est toujours undefined (non définie par un autre script pouvant en dépendre).
if(typeof Array.prototype.last === 'undefined') {
Object.defineProperty(Array.prototype, 'last', {
get : function() {
return this[this.length - 1];
}
});
}
// Now you can access it like
[1, 2, 3].last; // => 3
// or
var test = [50, 1000];
alert(test.last); // Says '1000'
Édité:
Récemment, j'ai proposé une solution supplémentaire qui, à mon avis, convient le mieux à mes besoins:
function w(anArray) {
return {
last() {
return anArray [anArray.length - 1];
};
};
}
Avec la définition ci-dessus en vigueur, je peux maintenant dire:
let last = w ([1,2,3]).last();
console.log(last) ; // -> 3
Le nom "w" signifie "wrapper". Vous pouvez voir comment vous pouvez facilement ajouter plus de méthodes En plus de 'last ()' à cette enveloppe.
Je dis "le mieux pour mes besoins", car cela permetme d’ajouter facilement d’autres "méthodes d’aide" de ce type À tout type JavaScript intégré. Ce qui me vient à l'esprit, ce sont les car () et cdr () de LISP, par exemple.
Je pense que la manière la plus simple et la plus inefficace est:
var array = ['fenerbahce','arsenal','milan'];
var reversed_array = array.reverse(); //inverts array [milan,arsenal,fenerbahce]
console.log(reversed_array[0]) // result is "milan".
Je suggérerai de créer une fonction d'assistance et de la réutiliser à chaque fois, vous en aurez besoin. Permet de rendre la fonction plus générale pour pouvoir obtenir non seulement le dernier élément, mais aussi le deuxième à partir du dernier et ainsi de suite.
function last(arr, i) {
var i = i || 0;
return arr[arr.length - (1 + i)];
}
L'utilisation est simple
var arr = [1,2,3,4,5];
last(arr); //5
last(arr, 1); //4
last(arr, 9); //undefined
Maintenant, permet de résoudre le problème initial
Saisissez l'avant-dernier tableau sous forme d'article. Si le dernier élément du loc_array est "index.html", récupérez le troisième au dernier élément à la place.
La ligne suivante fait le travail
last(loc_array, last(loc_array) === 'index.html' ? 2 : 1);
Donc, vous aurez besoin de réécrire
var newT = document.createTextNode(unescape(capWords(loc_array[loc_array.length-2])));
de cette façon
var newT = document.createTextNode(unescape(capWords(last(loc_array, last(loc_array) === 'index.html' ? 2 : 1))));
ou utiliser une variable supplémentaire pour améliorer la lisibilité
var nodeName = last(loc_array, last(loc_array) === 'index.html' ? 2 : 1);
var newT = document.createTextNode(unescape(capWords(nodeName)));
Le moyen simple d’obtenir le dernier élément du tableau:
var last_item = loc_array.reverse()[0];
Bien sûr, nous devons vérifier que le tableau a au moins un élément en premier.
Dans la proposition ECMAScriptÉtape 1 il est suggéré d'ajouter une propriété de tableau qui renverra le dernier élément: proposal-array-last .
Syntaxe:
arr.lastItem // get last item
arr.lastItem = 'value' // set last item
arr.lastIndex // get last index
Vous pouvez utiliser polyfill .
Auteur de la proposition: Keith Cirkel ( chai autor)
Using lodash _.last (array) Obtient le dernier élément du tableau.
data = [1,2,3]
last = _.last(data)
console.log(last)<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.min.js"></script>En utilisant l'opérateur ES6/ES2015 spread (...), vous pouvez procéder de la manière suivante.
const data = [1, 2, 3, 4]
const [last] = [...data].reverse()
console.log(last)Veuillez noter que l’utilisation de spread opérateur et inverse n’a pas muté le tableau original, c’est un moyen pur d’obtenir un dernier élément du tableau.
Vous pouvez également résoudre ce problème sans extraire un tableau de l’URL.
C'est mon alternative
var hasIndex = (document.location.href.search('index.html') === -1) ? doSomething() : doSomethingElse();
!Salutations
Voici plus d'art Javascript si vous êtes venu chercher ici
Dans l’esprit d’une autre réponse utilisant reduceRight(), mais plus courte:
[3, 2, 1, 5].reduceRight(a => a);
Il repose sur le fait que, si vous ne fournissez pas de valeur initiale, le tout dernier élément est sélectionné comme élément initial (consultez la documentation ici ). Comme le rappel ne cesse de renvoyer la valeur initiale, le dernier élément sera celui renvoyé à la fin.
Attention, cela devrait être considéré Javascript art et ce n’est en aucun cas ce que je recommanderais de faire, principalement parce qu’il tourne dans le temps O(n), mais aussi parce que la lisibilité ne tient pas .
Et maintenant la réponse sérieuse
Le meilleur moyen que je vois (considérant que vous le voulez plus concis que array[array.length - 1]) est le suivant:
const last = a => a[a.length - 1];
Ensuite, utilisez simplement la fonction:
last([3, 2, 1, 5])
La fonction est utile si vous utilisez un tableau anonyme comme [3, 2, 1, 5] utilisé ci-dessus, sinon vous devrez l'instancier deux fois, ce qui serait inefficace et moche:
[3, 2, 1, 5][[3, 2, 1, 5].length - 1]
Pouah.
Par exemple, voici une situation dans laquelle vous avez un tableau anonyme et que vous devez définir une variable, mais vous pouvez utiliser last() à la place:
last("1.2.3".split("."));
Que diriez-vous de quelque chose comme ci-dessous:
if ('index.html' === array[array.length - 1]) {
//do this
} else {
//do that
}
Si vous utilisez Underscore , vous pouvez utiliser _.last(), ainsi:
if ('index.html' === _.last(array)) {
//do this
} else {
//do that
}
C'est propre et efficace:
let list = [ 'a', 'b', 'c' ]
(xs => xs[xs.length - 1])(list)
Si vous installez un opérateur de pipe utilisant Babel, il devient:
list |> (xs => xs[xs.length - 1])
Quoi que vous fassiez, n'utilisez pas reverse() !!!
Quelques réponses mentionnent reverse mais ne mentionnent pas le fait que reverse modifie le tableau d'origine et ne renvoie pas (comme dans un autre langage ou framework) une copie.
var animals = ['dog', 'cat'];
animals.reverse()[0]
"cat"
animals.reverse()[0]
"dog"
animals.reverse()[1]
"dog"
animals.reverse()[1]
"cat"
Cela peut être le pire type de code à déboguer!
Cette méthode ne plaisante pas avec votre prototype. Elle protège également des tableaux de longueur 0, ainsi que des tableaux null/undefined. Vous pouvez même remplacer la valeur par défaut si la valeur par défaut renvoyée peut correspondre à un élément de votre tableau.
const items = [1,2,3]
const noItems = []
/**
* Returns the last item in an array.
* If the array is null, undefined, or empty, the default value is returned.
*/
function arrayLast (arrayOrNull, defVal = undefined) {
if (!arrayOrNull || arrayOrNull.length === 0) {
return defVal
}
return arrayOrNull[arrayOrNull.length - 1]
}
console.log(arrayLast(items))
console.log(arrayLast(noItems))
console.log(arrayLast(null))
console.log(arrayLast(items, 'someDefault'))
console.log(arrayLast(noItems, 'someDefault'))
console.log(arrayLast(null, 'someDefault'))Une autre option ES6 uniquement consisterait à utiliser Array.find(item, index)=> {...}) comme suit:
const arr = [1, 2, 3];
const last = arr.find((item, index) => index === arr.length - 1);
peu de valeur pratique, publiée pour montrer que cet index est également disponible pour votre logique de filtrage.
Il existe également un module npm, qui ajoute last à Array.prototype
npm install array-prototype-last --save
usage
require('array-prototype-last');
[1, 2, 3].last; //=> 3
[].last; //=> undefined
Pour éviter de supprimer le dernier élément du tableau Origin, vous pouvez utiliser
Array.from(myArray).pop()
Principalement pris en charge par tous les navigateurs (ES6)
Array.prototype.slice with -1 peut être utilisé pour créer un nouveau tableau contenant uniquement le dernier élément du tableau d'origine. Vous pouvez ensuite utiliser Destructuring Assignment pour créer une variable à l'aide du premier élément de celui-ci. nouveau tableau.
const lotteryNumbers = [12, 16, 4, 33, 41, 22];
const [lastNumber] = lotteryNumbers.slice(-1);
console.log(lotteryNumbers.slice(-1));
// => [22]
console.log(lastNumber);
// => 22Est-ce que ça va marcher?
if (loc_array.pop() == "index.html"){
var newT = document.createTextNode(unescape(capWords(loc_array[loc_array.length-3])));
}
else{
var newT = document.createTextNode(unescape(capWords(loc_array[loc_array.length-2])));
}
La fonction arrow rend la méthode la plus rapide plus concise, en ne répétant pas le nom du tableau.
var lastItem = (a => a[a.length - 1])(loc_array);
Utiliser reductionRight :
[3,2,1,5].reduceRight((a,v) => a ? a : v);
Voici une extension de prototype propre qui sert de simple implémentation de la réponse de Aaron Harun :
Array.prototype.i = function(val){
if (val < 0) return this[this.length - Math.abs(val)]
return this[val]
}
Après avoir défini le prototype, cela fonctionnera maintenant:
arr = [1, 2, 3, 4, 5]
arr.i(0) // 1
arr.i(-1) // 5
arr.i(-2) // 4