Hier is mijn JavaScript-code tot nu toe:

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);

Momenteel wordt het voorlaatste item in de array uit de URL gehaald. Ik wil echter controleren of het laatste item in de array "index.html"is en zo ja, in plaats daarvan het op twee na laatste item pakken.

Antwoord 1, autoriteit 100%

if (loc_array[loc_array.length - 1] === 'index.html') {
   // do something
} else {
   // something else
}

In het geval dat uw server hetzelfde bestand voor “index.html” en “inDEX.htML” bedient, kunt u ook gebruiken: .toLowerCase().

Maar je zou kunnen overwegen om deze server-side indien mogelijk te doen: het zal schoner zijn en werken voor mensen zonder JS.

Antwoord 2, autoriteit 89%

Ik weet niet zeker of er een nadeel is, maar dit lijkt vrij beknopt:

arr.slice(-1)[0] 

of

arr.slice(-1).pop()

Beide retourneren undefinedals de array leeg is.

Antwoord 3, autoriteit 22%

Gebruik Array.pop:

var lastItem = anArray.pop();

Belangrijk : dit retourneert het laatste element en Verwijdert van de array

4, Autoriteit 12%

een kortere versie van wat @chaiguy heeft geplaatst:

Array.prototype.last = function() {
    return this[this.length - 1];
}

Het lezen van de -1-index retourneert undefinedreeds.

bewerken:

Tegenwoordig lijkt de voorkeur om modules te gebruiken en om te voorkomen dat het prototype wordt aangeraakt of met behulp van een globale naamruimte.

export function last(array) {
    return array[array.length - 1];
}

5, Autoriteit 11%

Twee opties zijn:

var last = arr[arr.length - 1]

of

var last = arr.slice(-1)[0]

De eerste is sneller, maar de laatste ziet er mooier uit

http://jsperf.com/slice-vs-length-1-arr

6, Autoriteit 5%

Hier is hoe u het zonder effect op de originele array

krijgt

a = [1,2,5,6,1,874,98,"abc"];
a.length; //returns 8 elements

Als u POP () gebruikt, wijzigt het uw array

a.pop();  // will return "abc" AND REMOVES IT from the array 
a.length; // returns 7

Maar u kunt dit gebruiken, dus het heeft geen effect op de originele array:

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 

Antwoord 7, autoriteit 5%

Prestaties

Vandaag 2020.05.16 voer ik tests uit van gekozen oplossingen op Chrome v81.0, Safari v13.1 en Firefox v76.0 op MacOs High Sierra v10.13.6

Conclusies

• arr[arr.length-1](D) wordt aanbevolen als snelste oplossing voor meerdere browsers
• veranderlijke oplossing arr.pop()(A) en onveranderlijke _.last(arr)(L) zijn snel
• oplossingen I, J zijn traag voor lange strings
• oplossingen H, K (jQuery) zijn het langzaamst in alle browsers

Details

Ik test twee gevallen voor oplossingen:

• veranderlijk: A,
  B,
  C,

• onveranderlijk: D,
  E,
  F,
  G,
  H,
  Ik,
  J (mijn),

• onveranderlijk van externe bibliotheken: K,
  L,
  M,

voor twee gevallen

• korte tekenreeks – 10 tekens – u kunt de test HIER

uitvoeren

• lange reeks – 1M tekens – u kunt de test HIER

uitvoeren

Antwoord 8, autoriteit 4%

De “schoonste” ES6-manier (IMO) zou zijn:

const foo = [1,2,3,4];
const bar = [...foo].pop();

Dit vermijdt het muteren van foo, zoals .pop()zou hebben gedaan, als we de spread-operator niet hadden gebruikt.
Dat gezegd hebbende, vind ik de oplossing foo.slice(-1)[0]ook goed.

Antwoord 9, autoriteit 3%

const [lastItem] = array.slice(-1);

Array.prototype.slicemet -1 kan worden gebruikt om een nieuwe array te maken die alleen het laatste item van de originele array bevat, je kunt dan Destructuring Assignmentom een variabele te maken met het eerste item van die nieuwe array.

const lotteryNumbers = [12, 16, 4, 33, 41, 22];
const [lastNumber] = lotteryNumbers.slice(-1);
console.log(lotteryNumbers.slice(-1));
// => [22]
console.log(lastNumber);
// => 22

while(loc_array.pop()!= "index.html"){
}
var newT = document.createTextNode(unescape(capWords(loc_array[loc_array.length])));

const lastElement = myArray[myArray.length - 1];

var fileName = loc_array.slice(-1)[0];
if(fileName.toLowerCase() == "index.html")
{
  //your code...
}

lastElement = document.location.href.split('/').splice(-1,1);

let thePop = arr.pop()
thePop && arr.push(thePop)

arr.push(thePop = arr.pop())    //Unsafe if arr empty

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 :)

var arr = [1,2,3,4,5];
console.log(arr.slice(-1)[0])
console.log(arr[arr.length-1])
const [last] = [...arr].reverse();
console.log(last)
let copyArr = [...arr];
console.log(copyArr.reverse()[0]);

loc_array.splice(-1)[0] === 'index.html'

loc_array.slice(-1)[0] === 'index.html'

const {length, [length-1]: last}=[1,2,3,4,5]
console.log(last)

Object.defineProperty( Array.prototype, "getLast", {
    enumerable: false,
    configurable: false,
    writable: false,
    value: function() {
        return this[ this.length - 1 ];
    }
} );

if (_.last(loc_array) === 'index.html'){
  etc...
}

> $([1,2,3]).get(-1)
3
> $([]).get(-1)
undefined

const myArray = [1, 2, 3]
console.log(myArray.at(-1))
// => 3

const myArray = [1, 2, 3]
console.log(myArray.lastItem)
// => 3

Array.from(myArray).pop()

arr.lastItem // get last item
arr.lastItem = 'value' // set last item
arr.lastIndex // get last index

var animals = ['dog', 'cat'];
animals.reverse()[0]
"cat"
animals.reverse()[0]
"dog"
animals.reverse()[1]
"dog"
animals.reverse()[1]
"cat"

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]

var arr = [1, 2, 3];
var last_element = arr.reverse()[0];

var arr = [1, 2, 3];
var last_element = arr.slice().reverse()[0];

Array.prototype.last = function () {
    return this[this.length - 1];
};

const last = Symbol('last');
Array.prototype[last] = function() {
    return this[this.length - 1];
};
console.log([0, 1][last]());