지금까지 내 JavaScript 코드는 다음과 같습니다.

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

현재 URL에서 배열의 두 번째 항목이 마지막 항목입니다. 그러나 배열의 마지막 항목이 있는지 확인하고 싶습니다. "index.html"그렇다면 세 번째 항목부터 마지막 ​​항목까지 가져옵니다.

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

서버가 "index.html"및 "inDEX.htML"에 대해 동일한 파일을 제공하는 경우 다음을 사용할 수도 있습니다 .toLowerCase().

그러나 가능하면이 서버 측을 수행하는 것이 좋습니다. JS가없는 사람들에게는 더 깨끗하고 효과적입니다.

단점이 있는지 확실하지 않지만 이것은 매우 간결한 것 같습니다.

arr.slice(-1)[0] 

또는

arr.slice(-1).pop()

undefined배열이 비어 있으면 둘 다 반환 됩니다.

Array.pop 사용 :

var lastItem = anArray.pop();

중요 :이 마지막 요소를 반환 하고 제거 배열에서 그것을

@chaiguy가 게시 한 것의 짧은 버전 :

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

-1 인덱스를 읽으면 undefined이미 반환 됩니다.

편집하다:

요즘 선호는 모듈을 사용하고 프로토 타입을 만지거나 전역 네임 스페이스를 사용하지 않는 것 같습니다.

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

두 가지 옵션이 있습니다 :

var last = arr[arr.length - 1]

또는

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

전자는 더 빠르지 만 후자는 더 좋아 보인다

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

원래 ARRAY에 영향을 미치지 않고 얻는 방법은 다음과 같습니다.

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

pop ()을 사용하면 배열 이 수정됩니다.

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

그러나 이것을 사용 하면 원래 배열 에는 영향 을 미치지 않습니다 .

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 

"가장 깨끗한"ES6 방식 (IMO)은 다음과 같습니다.

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

이 피합니다는 돌연변이 foo로, .pop()겠습니까 있던 우리는 확산 연산자를 사용하지 않은 경우.
즉, 나는 foo.slice(-1)[0]해결책도 좋아 한다.

오히려 array.pop()인덱스보다 사용하고 싶습니다 .

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

이렇게하면 항상 index.html 이전의 요소를 얻을 수 있습니다 (배열에 index.html을 하나의 항목으로 분리 한 경우). 참고 : 배열에서 마지막 요소는 손실됩니다.

제거하지 않고 요소 만 가져 오려면 다음을 사용하는 것이 더 간단합니다.

arr.slice(-1)[0]

참고 : 배열이 비어 있으면 (예 []:)undefined 됩니다.

그건 그렇고 ... 나는 성능을 확인하지 않았지만, 작성하는 것이 더 간단하고 깨끗하다고 ​​생각합니다.

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

-1이 포함 된 Array.prototype.slice 를 사용하여 원래 Array의 마지막 항목 만 포함하는 새 Array를 만든 다음 Destructuring Assignment 를 사용하여 새 Array의 첫 번째 항목을 사용하여 변수를 만들 수 있습니다 .

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

console.log(lotteryNumbers.slice(-1));
// => [22]
console.log(lastNumber);
// => 22

음수 값을 가진 slice 메서드를 사용하면 배열의 마지막 항목을 가져올 수 있습니다 .

당신은 그것에 대해 자세한 내용을보실 수 있습니다 여기 아래에.

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

pop ()을 사용하면 배열이 변경되므로 항상 좋은 생각은 아닙니다.

이 패턴을 사용할 수 있습니다 ...

let [last] = arr.slice(-1);

잘 읽히지 만 새로운 어레이를 만들어 다른 솔루션보다 효율적이지 않지만 응용 프로그램 의 성능 병목 현상 은 거의 없습니다 .

이 질문은 오랫동안 사용되어 왔기 때문에 아무도 마지막 요소를 다시 사용한 다음에 언급하지 않은 것에 놀랐습니다 pop().

arr.pop()정확히 같은 효율성 arr[arr.length-1]이며 둘 다 같은 속도 arr.push()입니다.

따라서 다음을 수행 할 수 있습니다.

[체크 --- EDITED thePop없는 undefined추진 전에] ---

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

--- 끝 편집 ---

이것으로 줄일 수 있습니다 (동일한 속도 [편집 : 안전하지 않습니다!]) :

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

이 두 배는 느리지 arr[arr.length-1]만 인덱스를 사용할 필요는 없습니다. 그것은 어느 날이든 금의 가치가 있습니다.

내가 시도한 솔루션 중 ETU (Execution Time Unit)의 배수로 arr[arr.length-1]:

[방법] .............. [ETU 5 일분] ... [ETU 1 백만 일분]

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

마지막 세 옵션 인 ESPECIALLY [...arr].pop()는 어레이의 크기가 증가함에 따라 훨씬 더 나빠집니다. 내 컴퓨터의 메모리 제한이없는 컴퓨터에서는 [...arr].pop()아마도 120 : 1 비율과 같은 것을 유지합니다. 여전히, 아무도 자원 돼지를 좋아하지 않습니다.

마지막 요소를 한 번에 얻으려면 다음을 사용할 수 있습니다 Array#splice().

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

여기서는 분할 요소를 배열에 저장 한 다음 마지막 요소에 도달 할 필요가 없습니다. 마지막 요소를 얻는 것이 유일한 목표라면 이것을 사용해야합니다.

참고 : 마지막 요소를 제거 하여 원래 배열 을 변경합니다 . 마지막 요소 splice(-1,1)를 표시하는 pop()함수 로 생각하십시오 .

Array 프로토 타입을 오버로드하는 것을 두려워하지 않는 사람들을 위해 (그리고 열거 마스킹 을 사용해서는 안 됨)

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

jQuery 는 이것을 깔끔하게 해결합니다.

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

나는 일반적으로 underscorejs를 사용 합니다 .

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

나를 위해 그 의미보다 더 의미 loc_array.slice(-1)[0]

여기에 와서 더 많은 자바 스크립트 아트가 있습니다.

을 사용 reduceRight()했지만 더 짧은 다른 대답의 정신으로 :

[3, 2, 1, 5].reduceRight(a => a);

초기 값을 제공하지 않으면 가장 마지막 요소가 초기 요소로 선택된다는 사실에 의존합니다 ( 여기 에서 문서를 확인 하십시오 ). 콜백은 초기 값을 계속 반환하므로 마지막 요소는 마지막에 반환되는 요소입니다.

이것이 자바 스크립트 기술 로 간주되어야하며 내가 O (n) 시간 안에 실행되기 때문에 내가 그것을 추천 할 수있는 방법 이 아니라는 것을 명심하십시오 .

그리고 지금 진지한 대답

내가 보는 가장 좋은 방법은 (보다 간결하게 원한다는 것을 고려할 때 array[array.length - 1]) 다음과 같습니다.

const last = a => a[a.length - 1];

그런 다음 함수를 사용하십시오.

last([3, 2, 1, 5])

이 함수는 [3, 2, 1, 5]위에서 사용한 것과 같은 익명 배열을 처리하는 경우 실제로 유용합니다 . 그렇지 않으면 두 번 인스턴스화해야하며 비효율적이고 추악합니다.

[3, 2, 1, 5][[3, 2, 1, 5].length - 1]

어.

예를 들어, 익명 배열이 있고 변수를 정의해야하는 상황이 있지만 last()대신 사용할 수 있습니다 .

last("1.2.3".split("."));

다른 옵션을 여기에 두십시오.

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

위의 접근 방식이 더 깨끗하고 짧은 온라인 사용자라는 것을 알았습니다. 자유롭게 사용해보십시오.

참고 : 원래 배열을 수정합니다. 수정하지 않으려면 사용할 수 있습니다 slice()

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

이것을 지적 해 주셔서 감사합니다 @VinayPai .

자바 스크립트에서 배열의 마지막 값을 찾는 여러 가지 방법

• 원래 배열에 영향을 미치지 않고

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)
console.log(arr.reverse()[0])

• 원래 배열을 수정합니다

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

console.log(arr.pop())
arr.push(5)
console.log(...arr.splice(-1));

• 자체 헬퍼 메소드를 작성하여

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

Object.defineProperty(arr, 'last', 
{ get: function(){
  return this[this.length-1];
 }
})

console.log(arr.last);

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

이것은 성능 관점에서 가장 좋은 옵션입니다 (arr.slice (-1)보다 ~ 1000 배 빠름).

개인적으로 kuporific / kritzikratzi의 답변을지지합니다. 중첩 배열로 작업하는 경우 array [array.length-1] 메서드가 매우보기 흉합니다.

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]

ECMAScript 제안서 1 단계 에는 마지막 요소를 반환하는 배열 속성을 추가하라는 제안이 있습니다. proposal-array-last .

통사론:

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

arr.lastIndex // get last index

polyfill 을 사용할 수 있습니다 .

제안서 작성자 : Keith Cirkel ( 차이 오토 머 )

원점 배열에서 마지막 항목을 제거하지 못하게하려면 다음을 사용할 수 있습니다

Array.from(myArray).pop()

대부분의 모든 브라우저 (ES6)에서 지원

프로토 타입에 last()함수를 추가 할 수 있습니다 Array.

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

무엇 이건 당신은하지 않습니다 만 사용 reverse()!

몇 가지 답변 은 원래 배열 reverse을 reverse수정하고 다른 언어 또는 프레임 워크에서와 같이 사본을 반환하지 않는다는 사실은 언급 하지만 언급 하지는 않습니다.

var animals = ['dog', 'cat'];

animals.reverse()[0]
"cat"

animals.reverse()[0]
"dog"

animals.reverse()[1]
"dog"

animals.reverse()[1]
"cat"

이것은 최악의 디버그 코드 유형일 수 있습니다!

ES6 객체 파괴는 또 다른 방법입니다.

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

객체 파괴를 사용하여 Array에서 length 속성을 추출 합니다. 이미 추출 된 키를 [length-1]로 사용하여 다른 동적 키를 작성 하고이를 한 줄에 last에 할당하십시오 .

의 모든 인스턴스를 통해 액세스 할 수 있도록 프로토 타입에 새 특성 게터 를 추가 할 수 있습니다 .ArrayArray

Getter를 사용하면 마치 함수의 값인 것처럼 함수의 반환 값에 액세스 할 수 있습니다. 물론 함수의 반환 값은 배열의 마지막 값입니다 ( this[this.length - 1]).

마지막으로 last-property가 여전히 있는지 여부를 확인하는 조건으로 랩핑합니다 undefined(이에 의존하는 다른 스크립트로 정의되지 않음).

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'

IE ≤ 8에서는 작동하지 않습니다.

편집 :

최근에 나는 내 요구에 가장 적합한 솔루션을 하나 더 생각해 냈습니다.

function w(anArray) {
  return {
    last() {
      return anArray [anArray.length - 1];
    };
  };
}

위의 정의가 적용되면 이제 말할 수 있습니다.

let last = w ([1,2,3]).last();
console.log(last) ; // -> 3

이름 "w" 은 "래퍼"를 의미합니다. 이 래퍼에 'last ()'외에 더 많은 메소드를 쉽게 추가하는 방법을 알 수 있습니다.

"내 필요에 가장 적합"이라고 말하면 JavaScript 내장 유형에 다른 "도우미 메소드"를 쉽게 추가 할 수 있기 때문입니다. 예를 들어 Lisp의 car ()와 cdr ()이 떠 오릅니다.

가장 쉽고 비효율적 인 방법은 다음과 같습니다.

var array = ['fenerbahce','arsenal','milan'];
var reversed_array = array.reverse(); //inverts array [milan,arsenal,fenerbahce]
console.log(reversed_array[0]) // result is "milan".