If you don't need the array afterwards, you could use

array.pop()

But that removes the element from the array!

The pop returns T | undefined so you need to take care of that in your implementation.

If you are sure there will be always a value you can use non-null assertion operator (!):

     var poped = array.pop()
     array.push(poped!);

Here is another way which has not yet been mentioned:

items.slice(-1)[0]

As of July 2021, browsers are starting to support the at() method for Arrays which allows for the following syntax:

const arr: number[] = [1, 2, 3];

// shows 3
alert(arr.at(-1)); 

It's not clear to me at what point TypeScript will start to support this (it's not working for me just yet) but it should be available soon I would guess.

Edit: This is available as of typescript@4.5.4

Here are a the options summarized together, for anyone finding this question late like me.

var myArray = [1,2,3,4,5,6];

// Fastest method, requires the array is in a variable
myArray[myArray.length - 1];

// Also very fast but it will remove the element from the array also, this may or may 
// not matter in your case.
myArray.pop();

// Slowest but very readable and doesn't require a variable
myArray.slice(-1)[0]

If you need this call more often it's possible to declare it globally:

interface Array<T> {
    last(): T | undefined;
}
if (!Array.prototype.last) {
    Array.prototype.last = function () {
        if (!this.length) {
            return undefined;
        }
        return this[this.length - 1];
    };
}

then you can just call

items.last()

I'm going with this one as my first contribution to stackoverflow:

var items: String[] = ["tom", "jeff", "sam"];

const lastOne = [...items].pop();

NOTE: Unlike the use of pop() without the spread operator, this approach doesn't remove the last element from the original array.