Remove the Last N Characters from a Ruby String

You will learn how Ruby string slicing removes characters from the end of a string, when to use non-mutating versus mutating methods, and how to handle boundary cases safely.

Ruby strings support slicing, which means extracting a selected portion of text by position or range. To remove the last n characters, keep the portion that comes before those characters.

The most direct non-mutating approach is:

result = text[0...-n]

0...-n is an exclusive range:

• 0 starts at the first character.
• -n counts backward from the end.
• ... excludes the endpoint.

For example, text[0...-3] keeps everything except the final three characters.

This matters because string cleanup is common in programming: removing a file extension, trimming a suffix from an identifier, or preparing text for display. Ruby offers both methods that return a new string and methods that modify the original string, so choosing the right one prevents unexpected side effects.

Think of a string as a strip of letter tiles.

"ruby.rb"
 r u b y . r b

If you remove the final 3 tiles, you keep the tiles from the beginning up to—but not including—the position three tiles from the end.

Negative indexes are like counting from the right side:

• -1 means the last character.
• -2 means the second-to-last character.
• -n means the character position n places from the end.

The range 0...-n tells Ruby: “Keep tiles from the start until just before that backward position.”

Use string slicing when you want a new string and want to leave the original unchanged.

text = "Hello, world!"
n = 6

without_last_n = text[0...-n]

puts without_last_n # Hello,
puts text           # Hello, world!

text[0...-n] returns the characters from index 0 through the position before -n.

You can also use String#chop when you specifically need to remove one trailing character:

word = "Ruby!"
puts word.chop # Ruby

For a variable number of characters, slicing is generally clearer:

filename = "report.csv"
base_name = filename[0...-4]

puts base_name # report

If you intentionally need to modify the original string, use slice!:

filename = "report.csv"
filename.slice!(-4, 4)

puts filename # report

Here, slice!(-4, 4) starts four characters from the end and removes four characters in place.

Consider this code:

text = "programming"
n = 3
result = text[0...-n]

Step by step:

1. text contains "programming", which has 11 characters.
2. n is 3, so -n becomes -3.
3. Index -3 refers to the i in the ending "ing".
4. The exclusive range 0...-3 starts at the first character and stops before index -3.
5. Ruby returns "programm".
6. text still equals "programming" because normal slicing does not mutate it.

puts result # programm
puts text   # programming

• Remove a known file extension:

  file = "photo.jpeg"
  name = file[0...-5]
  # "photo"
  

• Remove a suffix from an imported code:

  product_code = "SKU-4829-OLD"
  current_code = product_code[0...-4]
  # "SKU-4829"
  

• Hide the last few characters of a value before display:

  reference = "ORDER-829174"
  visible_part = reference[0...-4]
  # "ORDER-82"
  

  In real applications, masking sensitive values usually requires more deliberate formatting, but removing a suffix can be part of preparing display text.

• Remove a delimiter that was appended while building output:

  csv_fragment = "red,green,blue,"
  csv_fragment = csv_fragment[0...-1]
  # "red,green,blue"
  

In production code, do not remove characters solely because you expect a fixed suffix. First verify that the suffix is actually present.

For example, use delete_suffix when removing a known ending:

filename = "report.csv"
base_name = filename.delete_suffix(".csv")

puts base_name # report

This is safer than removing four characters because it leaves unrelated filenames unchanged:

filename = "report.txt"
base_name = filename.delete_suffix(".csv")

puts base_name # report.txt

A common validation pattern checks the requested count before slicing:

def remove_last_characters(text, count)
  raise ArgumentError, "count must be non-negative" if count.negative?
  raise ArgumentError, "count is too large" if count > text.length

  text[0...-count]
end

There is one important special case: text[0...-0] is not a good way to represent “remove zero characters.” Handle zero explicitly:

def remove_last_characters(text, count)
  return text if count.zero?

  text[0...-count]
end

Developers also prefer non-mutating code by default. Mutation with slice! can be appropriate inside a focused parsing routine, but it can surprise callers that still need the original string.

Using an inclusive range

This removes one character too few because .. includes its endpoint:

text = "abcdef"
text[0..-3] # "abcd" — only "ef" was removed

Use ... for “everything before the final n characters”:

text[0...-3] # "abc"

Forgetting the zero case

text = "hello"
text[0...-0]

-0 is 0, so this range does not mean “keep the entire string.” Handle n == 0 separately:

result = n.zero? ? text : text[0...-n]

Accidentally changing the original string

text = "hello"
text.slice!(-2, 2)
puts text # hel

slice! mutates text. Use text[0...-n] if the original must remain available.

Removing a fixed number of characters without checking the suffix

filename = "notes.txt"
filename[0...-4] # "notes"

This happens to remove .txt, but it does not prove that the intended suffix existed. Prefer delete_suffix(".csv") when removing a known suffix.

Confusing characters with bytes

For normal UTF-8 Ruby strings, string slicing works with characters. Avoid byte-based methods such as byteslice unless you are deliberately working with binary data or a byte protocol.

String#chomp is related but different: it removes a record separator, normally a trailing newline, rather than an arbitrary number of characters.

"hello\n".chomp # "hello"
"hello!".chop   # "hello"

# Keep all but the last n characters (new string)
result = text[0...-n]

# Correct handling when n may be zero
result = n.zero? ? text : text[0...-n]

# Remove one final character (new string)
result = text.chop

# Remove one final character (mutates text)
text.chop!

# Remove n characters from the end (mutates text)
text.slice!(-n, n)

# Remove an exact suffix safely (new string)
result = text.delete_suffix(".csv")

# Remove an exact suffix safely (mutates text)
text.delete_suffix!(".csv")

Rules to remember:

• Use ..., not .., when excluding the final n characters.
• -1 refers to the last character.
• Handle n == 0 before using 0...-n.
• Prefer delete_suffix if you know the exact ending you want to remove.
• Methods ending in ! usually mutate the receiver.

How do I remove the last 3 characters from a Ruby string?

Use an exclusive range:

result = text[0...-3]

Does text[0...-n] modify the original Ruby string?

No. It returns a new string. Use slice! or another bang method only when you want to mutate the original.

Why use ... instead of .. in Ruby string slicing?

... excludes its endpoint. Since -n identifies the start of the final n characters, excluding it removes all of those characters.

What should I do when n is zero?

Return the original text (or a duplicate if needed). Do not rely on text[0...-0].

result = n.zero? ? text : text[0...-n]

What is the best Ruby method for removing a file extension?

Use delete_suffix when the extension is known:

"report.csv".delete_suffix(".csv")

Should I use chop or chomp to remove trailing text?

Use chop for one final character. Use chomp for a trailing newline or other record separator. Use slicing for an arbitrary count.

What happens if I try to remove more characters than the string contains?

The exact slice result can be surprising depending on the range and input. In application code, validate that n <= text.length when an oversized count is an error.

• Ruby string indexing — teaches positive and negative positions such as 0 and -1.
• Ruby ranges — explains inclusive (..) and exclusive (...) endpoints.
• String mutation in Ruby — helps distinguish methods that return new strings from bang methods that modify existing strings.
• String#delete_suffix — provides a semantic alternative for removing known endings.
• String#chop and String#chomp — remove trailing characters or line separators for specific use cases.
• Input validation and guard clauses — helps safely handle zero, negative, or oversized removal counts.