Last updated: Mar 1, 2024
Reading timeยท6 min
To get the last character of a string, call the charAt()
method on the
string, passing it the last index as a parameter.
For example, str.charAt(str.length - 1)
returns a new string containing the
last character of the string.
const str = 'abcde'; // โ Get the last character of a string using charAt() const last = str.charAt(str.length - 1); console.log(last); // ๐๏ธ e // โ Get the last character of a string using slice() const lst = str.slice(-1); console.log(lst); // ๐ 'e' const lst2 = str.slice(-2); console.log(lst2); // ๐๏ธ 'de' // โ Get the last character of a string using String.at() const last_ = str.at(-1); console.log(last_); // ๐๏ธ e
The argument we passed to the
String.charAt() method is the
index
.
0
and the last character in the string has an index of str.length - 1
.If passed an index that doesn't exist, the charAt()
method returns an empty
string.
const str = ''; const last = str.charAt(str.length - 1); console.log(last); // ๐๏ธ ""
An alternative approach is to directly access the string at the last index.
Indexes are zero-based, so the index of the last character in the string is
str.length - 1
.
const str = 'abcde'; const last = str[str.length - 1]; console.log(last); // ๐๏ธ e
Accessing the character at the last index achieves the same result as using the
charAt()
method.
However, if we try to access a character at an index that doesn't exist, we get
undefined
back.
const str = ''; const last = str[str.length - 1]; console.log(last); // ๐๏ธ undefined
charAt()
method, which returns an empty string when supplied with a non-existent index.It's always easier to reason about and manage an application if we're consistent with types.
Note: If you need to get the last N characters of a string, click on the following subheading:
Alternatively, you can use the String.slice()
method.
When passed an index of -1
, the slice()
method returns the last character of
the string.
const str = 'abcde'; const last = str.slice(-1); console.log(last); // ๐ 'e'
The parameter we passed to the String.slice() method is the start index.
The slice()
method can be passed a negative start index to count backward.
When passed an index of -1
, the slice
method returns the last character of
the string.
const str = 'abcde'; const last = str.slice(-1); console.log(last); // ๐ 'e'
The slice()
method returns an empty string if the specified index is not found
in the string.
const str = ''; const last = str.slice(-1); console.log(last); // ๐ ''
Note: If you need to get the last N characters of a string, click on the following subheading:
You can also use the String.at()
method.
The String.at()
method can be passed a value of -1
to return the last
character of a string as it supports negative indexing.
const str = 'bobbyhadz'; const last = str.at(-1); console.log(last); // ๐๏ธ z
We used the String.at() method to get the last characters of a string.
The method takes an integer that represents the index and returns the character at the specified index.
The method supports negative integers to count backward. For example, -1
returns the last character in the string and -2
returns the second last
character.
const str = 'bobbyhadz'; const last = str.at(-1); console.log(last); // ๐๏ธ z console.log(str.at(-2)); // ๐๏ธ d console.log(str.at(-3)); // ๐๏ธ a
We passed a value of -1
to the String.at()
method to get the last character
in the string.
If you pass an index that is out of range to the String.at()
method, the
method returns undefined
.
const str = ''; console.log(str.at(-1)); // ๐๏ธ undefined
Which approach you pick is a matter of personal preference. I'd use the
String.slice()
method because it returns an empty string when the supplied
index is out of range.
Pass -N
as an argument to the slice()
method to get the last N characters
of a string.
For example, str.slice(-2)
returns the last 2 characters of the string.
const str = 'bobbyhadz.com'; // โ get the last 2 characters of a string const last2 = str.slice(-2); console.log(last2); // ๐๏ธ om // โ get the last 3 characters of a string const last3 = str.slice(-3); console.log(last3); // ๐๏ธ com // โ get the last 4 characters of a string const last4 = str.slice(-4); console.log(last4); // ๐ .com
The String.slice() method extracts a section of a string and returns it, without modifying the original string.
The String.slice()
method takes the following arguments:
Name | Description |
---|---|
start index | The index of the first character to include in the returned substring |
end index | The index of the first character to exclude from the returned substring |
When only a single argument is passed to the String.slice()
method, the slice
goes to the end of the string.
Make sure to assign the result of calling the slice()
method to a variable as
the method doesn't change the original string.
The String.slice()
method can be passed negative indexes to count backward.
const str = 'bobbyhadz.com'; console.log(str.slice(-2)); // ๐๏ธ om console.log(str.slice(-5)); // ๐๏ธ z.com
slice
method is the same as specifying a start index of string.length - N
.const str = 'bobbyhadz.com'; const last3 = str.slice(-3); // ๐๏ธ com console.log(last3); const last3Again = str.slice(str.length - 3); console.log(last3Again); // ๐๏ธ com
In both examples, we tell the slice
method to copy the last 3 characters of
the string into a new string.
slice()
returns the entire string and doesn't throw an error.const str = 'bobbyhadz.com'; const last100 = str.slice(-100); console.log(last100); // ๐๏ธ bobbyhadz.com
In this example, we tried to get the last 100
characters of a string that only
contains 13
characters.
As a result, the slice
method returned a copy of the entire string.
If you have to do this often, define a reusable function.
function getLastNchars(str, n) { return str.slice(-n); } const str = 'bobbyhadz.com'; // โ get the last 2 characters of a string console.log(getLastNchars(str, 2)); // ๐๏ธ om // โ get the last 3 characters of a string console.log(getLastNchars(str, 3)); // ๐๏ธ com // โ get the last 4 characters of a string console.log(getLastNchars(str, 4)); // ๐๏ธ .com
The getLastNchars
function takes a string and N as parameters and returns the
last N characters of the string.
String.substring
Alternatively, you can use the String.substring()
method.
For example, str.substring(str.length - 3)
returns the last 3 characters of
the string.
function getLastNchars(str, n) { return str.substring(str.length - n); } const str = 'bobbyhadz.com'; // โ get the last 2 characters of a string console.log(getLastNchars(str, 2)); // ๐๏ธ om // โ get the last 3 characters of a string console.log(getLastNchars(str, 3)); // ๐๏ธ com // โ get the last 4 characters of a string console.log(getLastNchars(str, 4)); // ๐๏ธ .com
The String.substring() method returns a slice of the string from the start index to the excluding end index.
The method takes the following parameters:
Name | Description |
---|---|
start index | The index of the first character to include in the returned substring |
end index | The index of the first character to exclude from the returned substring |
If no end
index is specified the slice goes to the end of the string.
The String.substring()
method doesn't support negative values to count
backward, so we had to calculate the start index based on the string's length.
const str = 'bobbyhadz.com'; // ๐๏ธ om console.log(str.substring(str.length - 2));
slice
and substring
methods are similar, however, you should use the slice
method because its implementation is more intuitive.There are a couple of
differences
between the String.substring()
and the String.slice()
methods:
substring()
method swaps its start and end index if the start index is
greater than the end index. The slice()
method returns an empty string in
this case.const str = 'bobby'; console.log(str.substring(3, 0)); // ๐๏ธ bob console.log(str.slice(3, 0)); // ๐๏ธ ''
substring()
are negative, they are
treated as if they were 0
.const str = 'bobby'; console.log(str.substring(-3)); // ๐๏ธ bobby console.log(str.slice(-3)); // ๐๏ธ bby
When given a negative index, the slice()
method counts backward from the end
of the string to find the indexes.
For these reasons, it is recommended to use the String.slice()
method to get
the last N characters of a string.
The slice
method works in a more predictable manner.
You can learn more about the related topics by checking out the following tutorials: