Introduction

Removing alphabetic characters from a string sounds simple until you have to define what "alphabetic" means. If you only care about ASCII letters, a basic regular expression is enough. If you need to handle accented characters or non-Latin scripts, you need a Unicode-aware approach.

Start with the Exact Requirement

There are at least two common interpretations:

• remove only A-Z and a-z
• remove every character that is classified as a letter in Unicode

Those are not the same. For example, é, ß, and Ж are letters, but they are not matched by the ASCII-only pattern [A-Za-z].

If the input is strictly English-like text, the ASCII pattern is fine:

1import re
2
3text = "Room 42B, level C"
4result = re.sub(r"[A-Za-z]", "", text)
5print(repr(result))

Output:

' 42,  '

The spaces and punctuation remain because only letters are removed.

Python Solutions

In Python, a regular expression is usually the shortest answer for ASCII letters.

1import re
2
3def remove_ascii_letters(text):
4    return re.sub(r"[A-Za-z]", "", text)
5
6
7print(remove_ascii_letters("abc-123-XYZ"))

If you want a solution without regular expressions, filter character by character:

1def remove_letters(text):
2    return "".join(ch for ch in text if not ch.isalpha())
3
4
5print(remove_letters("abc-123-XYZ"))
6print(remove_letters("cafe 42"))

The isalpha() approach is often better when the requirement is "remove letters in general," because it respects Unicode letter categories.

The tradeoff is semantic clarity:

• 're.sub(r"[A-Za-z]", "", text) means ASCII letters only'
• 'ch.isalpha() means Unicode alphabetic characters'

JavaScript Solutions

For JavaScript, the same distinction exists. If you only need ASCII letters:

1function removeAsciiLetters(text) {
2  return text.replace(/[A-Za-z]/g, "");
3}
4
5console.log(removeAsciiLetters("abc-123-XYZ"));

If you want broader Unicode support in modern JavaScript engines, use Unicode property escapes:

1function removeUnicodeLetters(text) {
2  return text.replace(/\p{L}/gu, "");
3}
4
5console.log(removeUnicodeLetters("Cafe 42"));
6console.log(removeUnicodeLetters("naive 17"));

The \p{L} property means "any Unicode letter." The u flag is required so the engine interprets the property escape correctly.

Deciding What to Keep

In many real tasks, you are not just removing letters. You are preserving a smaller allowed set, such as digits and decimal separators.

For example, if the real goal is "keep digits only," write that requirement directly:

1import re
2
3def keep_digits(text):
4    return re.sub(r"\D", "", text)
5
6
7print(keep_digits("Order AB-123-CD"))

That is usually better than saying "remove alphabetic characters" because it also removes spaces and punctuation in one pass.

Likewise, in JavaScript:

1function keepDigits(text) {
2  return text.replace(/\D/g, "");
3}
4
5console.log(keepDigits("Order AB-123-CD"));

This shift in thinking matters because transformation bugs often come from solving the wrong problem too literally.

A Note on Performance

For typical application strings, regex versus manual iteration is not worth debating. Both are fast enough. Choose the version that expresses the requirement clearly.

Where performance does matter:

• very large text streams
• millions of repeated transformations
• Unicode-heavy input with complicated rules

In those cases, benchmark the actual workload instead of assuming the regex is always faster. The biggest gain usually comes from choosing the right rule set, not micro-optimizing the loop.

Handling Unicode Correctly

Unicode changes the question from "alphabetic" to "which scripts count as letters for this application?" For example, isalpha() in Python will treat many non-ASCII symbols as letters. That is correct for internationalized text, but wrong if you only wanted to strip English letters from an identifier.

A practical rule is:

• use [A-Za-z] when the domain is explicitly ASCII
• use isalpha() or \p{L} when the domain is human language text

Put that decision into tests so future changes do not silently broaden or narrow the behavior.

Common Pitfalls

• Using [A-Za-z] when the input may contain non-ASCII letters. That leaves accented and non-Latin letters untouched.
• Using isalpha() when the requirement was actually "English letters only." Unicode-aware behavior can remove more than expected.
• Removing letters when the real goal is to keep digits or some other whitelist. Express the target output directly when possible.
• Forgetting regex flags in JavaScript. Unicode property escapes need the u flag, and global replacement usually needs g.
• Ignoring spaces and punctuation. Removing letters does not automatically normalize the rest of the string.

Summary

• Define whether "alphabetic" means ASCII letters or Unicode letters.
• In Python, use [A-Za-z] for ASCII or isalpha() for broader letter detection.
• In JavaScript, use /[A-Za-z]/g for ASCII or /\p{L}/gu for Unicode-aware removal.
• If the true goal is to keep digits or another whitelist, write that rule directly.
• Add tests for accented characters and mixed-content strings so the behavior stays intentional.