How to Remove the Last Character from a String in JavaScript

By the end of this page, you will understand how to remove the last character from a string in JavaScript, especially when working with trailing delimiters like commas. You will learn the safest common approach, how methods like slice() work, when to check the final character first, and how this pattern is used in real code.

Strings are immutable in JavaScript, which means you cannot change a character inside an existing string. Any operation that “removes” part of a string actually creates a new string.

When you need to remove the last character, the most common tool is slice(). It lets you extract part of a string by position.

For example:

const text = "hello,";
const result = text.slice(0, -1);
console.log(result); // "hello"

This means:

• Start at index 0
• Stop one character before the end

This is useful when:

• trimming a trailing comma
• removing a final newline
• cleaning separators from generated text
• formatting CSV-like output

Why this matters in real programming:

• APIs often build query strings or comma-separated values
• log messages may add separators in loops
• exported text formats often need cleanup
• user input may contain unwanted trailing punctuation

A key idea is that you should only remove the last character if it is actually the delimiter you want to remove. Otherwise, you might accidentally delete valid data.

Think of a string like a row of labeled boxes:

a , b , c , d , e ,

If you want everything except the final box, slice(0, -1) means:

• start from the beginning
• take all boxes up to, but not including, the last one

If you only want to remove a comma when the last box is a comma, first peek at the last box, then decide whether to trim it.

So the process is like:

1. Look at the last item
2. If it is a comma, drop it
3. Otherwise, keep the string unchanged

The most common syntax is:

string.slice(0, -1)

Example: remove the last character

const value = "a,b,c,d,e,";
const result = value.slice(0, -1);

console.log(result); // "a,b,c,d,e"

This works well if you are sure the last character should always be removed.

Safer example: remove only a trailing comma

const value = "a,b,c,d,e,";
const result = value.endsWith(",") ? value.slice(0, -1) : value;

console.log(result); // "a,b,c,d,e"

This version avoids removing a valid final character when there is no comma.

Using replace() for a trailing comma

 value = ;
 result = value.(, );

.(result); 

Consider this example:

const value = "a,b,c,";
const result = value.endsWith(",") ? value.slice(0, -1) : value;
console.log(result);

Step-by-step

1. value is assigned:

"a,b,c,"

1. value.endsWith(",") checks the final character.

   • The final character is ,
   • So the condition is true

2. Because the condition is true, JavaScript runs:

value.slice(0, -1)

1. slice(0, -1) means:

Here are common situations where this pattern appears:

Building comma-separated lists

let items = "";
items += "apple,";
items += "banana,";
items += "orange,";

items = items.endsWith(",") ? items.slice(0, -1) : items;

Cleaning generated CSV-like text

When exporting values, code may accidentally leave a trailing delimiter at the end of a row.

Formatting query parameters or tags

A script may build text like:

red,blue,green,

and then trim the final comma.

Removing trailing newline characters

The same idea works for other characters too:

const text = "line 1\n";
const cleaned = text.endsWith("\n") ? text.slice(0, -1) : text;

Log and report generation

When assembling output inside loops, separators are often easier to add each time and then clean up once at the end.

In real projects, developers often avoid manually trimming delimiters by using built-in array methods like join(). But when strings are already built, trimming is still useful.

Common pattern: guard clause

function removeTrailingComma(text) {
  if (!text.endsWith(",")) {
    return text;
  }

  return text.slice(0, -1);
}

This is readable and safe.

Common pattern: validation before cleanup

function normalizeTags(text) {
  if (typeof text !== "string") {
    throw new TypeError("Expected a string");
  }

  return text.replace(/,$/, "");
}

Better pattern: avoid the problem with join()

 values = [, , , , ];
 result = values.();

.(result); 

1. Always removing the last character without checking

Broken example:

const value = "a,b,c";
const result = value.slice(0, -1);
console.log(result); // "a,b,"

Problem:

• This removes c, even though there was no trailing comma.

Better:

const result = value.endsWith(",") ? value.slice(0, -1) : value;

2. Forgetting that strings are immutable

Broken example:

let value = "a,b,c,";
value[value.length - 1] = "";

Problem:

• String characters cannot be changed directly.

Better:

value = value.(, -);

// Remove the last character no matter what it is
str.slice(0, -1)

// Remove the last character only if it is a comma
str.endsWith(",") ? str.slice(0, -1) : str

// Remove a trailing comma with regex
str.replace(/,$/, "")

// Best way to build a comma-separated string from an array
arr.join(",")

Rules

• Strings are immutable in JavaScript.
• slice() returns a new string.
• Negative indexes in slice() count from the end.
• endsWith() is useful when removal should be conditional.
• replace(/,$/, '') removes only one comma at the end.

Edge cases

"".slice(0, -1)           // ""
"abc".slice(0, -)        
.(, ) 
.(, )  

How do I remove the last character from a string in JavaScript?

Use:

str.slice(0, -1)

This returns a new string without the final character.

How do I remove a trailing comma only if it exists?

Use:

str.endsWith(",") ? str.slice(0, -1) : str

This keeps the string unchanged if there is no comma.

Is slice() faster than replace()?

For this simple task, slice() is usually the most direct choice. In most real applications, readability matters more than tiny performance differences.

What happens if the string is empty?

slice(0, -1) on an empty string returns an empty string. endsWith(",") returns false.

Can I change a string character directly in JavaScript?

No. Strings are immutable. You must create a new string.

What is the best way to avoid trailing commas entirely?

• String.prototype.slice() — the main method used to extract part of a string.
• String.prototype.endsWith() — useful for checking whether a string ends with a specific character.
• String.prototype.replace() — another common way to remove trailing patterns.
• arrays and join() — the best way to create delimited strings without trailing separators.
• string immutability — explains why string operations return new values.
• string indexing — helps you understand positions and the last character.
• regular expressions — useful when matching characters only at the end of a string.