Home Remove ‘-‘ in Regex Without Affecting ‘–>’?

Coding Best Practices

Remove ‘-‘ in Regex Without Affecting ‘–>’?

Learn how to use regex to remove ‘-‘ while preserving ‘–>’ using Python. Regex anchors and lookarounds are key to solving this issue.

byDev Solutions

December 26, 2025

Regex tutorial thumbnail showing how to remove dashes in text without affecting arrow symbols like '-->' using Python lookarounds

💡 Using regex lookarounds lets you remove some dashes while keeping arrow patterns like '-->'.
🐍 The Python regex pattern (?<!-)-(?!>) removes only dashes that are not part of an arrow.
⚙️ Regex performance gets much better when you compile it with re.compile() for repetitive or large tasks.
🌍 How regex lookarounds work is different in various languages. JavaScript, Java, and Python all support it, but there are some things to know.
📄 People use this in the real world to clean logs, config files, and markdown files. Here, you need to keep symbols like arrows.

How to Use Regex to Remove Dashes But Keep Arrows in Python

When you clean up text data, dashes (-) often act as separators. They also appear in special patterns, like arrows ('-->'). If you just remove all dashes, you can accidentally break these important patterns. This guide will show you how to use a Python regular expression for this. The regex removes dashes that stand alone. But it keeps arrows and similar symbols. It does this by using advanced features like lookaheads and lookbehinds.

How Dashes Work in Regex

Before you make a good pattern, you need to understand how the dash works in regular expressions. The dash (-) means different things depending on where it is:

Literal Match: If it's not inside character classes ([]), the dash is read as a literal dash character in your text.

MEDevel.com: Open-source for Healthcare and Education

Collecting and validating open-source software for healthcare, education, enterprise, development, medical imaging, medical records, and digital pathology.
Visit Medevel
Range Operator: Inside square brackets, like [a-z], it makes a range of characters.
Escape Not Always Needed: Outside brackets, you usually don't need to escape it. But sometimes it helps make things clearer. For instance:
```
re.search(r'-', 'a-b')  # Matches the dash
```

It has two behaviors. You avoid confusion by separating it or escaping it when needed.

Other regex things often used when making this pattern include:

^ and $: These mark the start or end of a line.
Quantifiers like +, *, and ?: These control how many times something is matched.
Precedence and grouping with parentheses (): These help make more complex logic.

When you understand these basics, the next step—matching specific things—becomes much easier.

Why Just Using `replace()` Can Break Your Data

Using basic text replacement might seem like a good first idea. But it does not work when symbols are important.

Example:

s = "parse-this --> but-not-that"
print(s.replace("-", ""))

Output:

"parsethis > butnotthat"

What happened here?

All dashes were removed.
The arrow string '-->' was broken down into '>'.

This breaks the arrow's meaning. The arrow might play an important part. For example, it could show state changes, flows in diagrams, or control settings in a config file.

In short, just replacing everything can break your data when you need to keep certain dash patterns. This is why regex works well; it is precise.

Being Precise: Lookarounds in Regex

To work smarter, you need lookarounds. These are good tools in regex. They let you match characters based on what is around them. But they do not include that surrounding text in the result.

Types of Lookarounds:

Lookahead ((?=...)): This checks what must come after.
Negative Lookahead ((?!...)): This checks what must NOT come after.
Lookbehind ((?<=...)): This checks what must come before.
Negative Lookbehind ((?<!...)): This checks what must NOT come before.

These are called zero-width assertions. This is because they check the context but do not use up characters. This lets you make precise changes like:

Removing a dash that is NOT between '-->'.
Ignoring a dash that is in the middle of '-->'.

For example:

re.sub(r'(?<!-)-(?!>)', '', 'data --> flow')

Here, the regex breaks down like this:

(?<!-): There is no dash right before.
-: This is the dash being checked.
(?!>): There is no arrowhead '>' right after.

All these things together mean: "Remove dashes only if they are not part of '-->'.

The Correct Regex Pattern Explained

The pattern that works is:

r'(?<!-)-(?!>)'

Let's look at it step-by-step in Python:

import re

s = "clean-this --> but-not-this --> or-this-one"
result = re.sub(r'(?<!-)-(?!>)', '', s)
print(result)

Output:

cleanthis --> butnotthis --> orthisone

How the Pattern Works

Here is a more detailed explanation:

✅ It does not match the second dash in '-->' because it has another dash (--) before it. And it has a '>' after it.
✅ It cleans dashes in normal words like clean-this. This is because there is no dash before it, or '>' after it.

This smart way it works is very useful in strings with different parts. For example, in documentation, log files, and custom markup.

Python Examples for Real Situations

Here is a function ready for use:

def clean_dashes(text):
    pattern = re.compile(r'(?<!-)-(?!>)')
    return pattern.sub('', text)

How the Test Cases Work

Here are some strings and their results:

examples = [
    "word-with-dash",          # → wordwithdash
    "arrow --> preserved",     # → arrow --> preserved
    "mix--match --> again",    # → mix--match --> again
    "---> triple arrow",       # → ---> triple arrow
    "--boundary-case"          # → --boundarycase
]

for example in examples:
    print(clean_dashes(example))

It does not matter how the arrows look or how dashes show up in your text. This regex performs a smart cleanup without breaking the text's structure.

Things to Know About Edge Cases

Regexes do not always cover all unusual cases right away:

Things to Think About:

Arrows with more dashes ('--->') still work.

Dashes at Start/End

clean_dashes("-start-middle-end-")  # Output: startmiddleend

Badly Formed Arrows like '->':
- This pattern would remove the dash. This leaves '>'.
- To also protect ->, you would need:
```
re.sub(r'(?<!-)-(?!?>)', '', text)  # Also handles '->'
```

For the most strength, you can add more to the logic. Include any known arrow formats you want to keep.

Other Options Besides Regex: When to Use Them

Regex is strong, but it is not always the easiest to read or keep up with. Other options include:

Splitting Strings with .split():
This is good for text with clear boundaries.
Protect and Put Back Strategy:
First, replace --> with a placeholder, like __ARROW__. Then, clean the dashes. And then, put back -->.

Example:

def safe_clean(text):
    placeholder = '__ARROW__'
    text = text.replace('-->', placeholder)
    text = text.replace('-', '')
    return text.replace(placeholder, '-->')

This way avoids complex regex. And it works well with few future problems.

Parser Libraries:
Use libraries like parsy or lark that break text into tokens. Use them if your text has more structured rules than simple strings.

Tips for Speed and Better Performance

How fast it works matters for large amounts of data. Regex performance can get worse with complex patterns and a lot of data.

Good Practices:

✅ Compile Once:
```
pattern = re.compile(r'(?<!-)-(?!>)')
```
Use this object in loops. This helps avoid recompiling it each time.
✅ Time Your Regex:
Use timeit in Python or profiling tools to check how fast your regex is.
❌ Do not use greedy patterns unless you really need them.
✅ Store results if you process the same things often.

Useful Tools for Testing Regex

Checking your regex makes development faster and leads to fewer bugs.

Regex101: This gives a live explanation of each part.
Pythex: You can test pure Python regex here.
VSCode Extensions: Regex previewer plugins help you find problems right in the IDE.

Also, think about writing specific unittest cases. These can check how well your code handles errors.

Make Regex Functions You Can Use Again

Organize regex into modules for use across projects:

def remove_dashes_except_arrows(text):
    """
    Removes dashes that stand alone while keeping '-->' patterns.
    """
    return re.sub(r'(?<!-)-(?!>)', '', text)

✅ Put this in a utils/text_cleaning.py file. And then import it into other projects.

Using This Strategy for Other Symbols

You can use the same logic for other similar cases:

Keep `==>` but remove other `=`:

pattern_eq = r'(?<!=)=(?!=>)'

Remove `/` unless it is part of `//`

pattern_slash = r'(?<!/)/(?!/)'

Keep `<--`, `-->`, `==>`

Use alternation grouping:

def clean_but_preserve_arrows(text):
    replacements = {'<--': '__LEFT__', '-->': '__RIGHT__', '==>': '__EQ__'}
    for k, v in replacements.items():
        text = text.replace(k, v)
    text = text.replace('-', '')
    for k, v in replacements.items():
        text = text.replace(v, k)
    return text

This strategy is longer. But it is stronger for cases where you want to keep many patterns.

How Regex Works in Different Programming Languages

Most modern programming languages support lookarounds. But some have version specific points.

✅ Python:

re.sub(r'(?<!-)-(?!>)', '', x)

✅ JavaScript (ES2018+):

x.replace(/(?<!-)-(?!>)/g, '');

Make sure your Node or browser environment supports lookbehind.

✅ Java:

str.replaceAll("(?<!-)-(?!>)", "");

Java has good regex support since SE6.

✅ PHP:

preg_replace("/(?<!-)-(?!>)/", "", $str);

✅ Perl:

$str =~ s/(?<!-)-(?!>)//g;

Always check if the regex engine in your environment supports lookarounds. This is extra important for older setups.

Real Uses for Regex Dash Filtering

This custom solution is useful in many areas:

Markdown File Cleanup:
Remove separators like ---. But keep items like '-->', which may show changes.
Config File Cleaning:
Keep <--, ==>, or special arrow syntax used in settings for computers to read.
Log File Preparation:
Take out unneeded hyphens while keeping trace operators like '---> error'.
Syntax Highlighting:
Token classifiers can use this logic to tell symbols apart.
Code Documentation Generators:
Tools that read structured comments can use regex filtering to keep diagrams inside the text.

Conclusion: Regex is Strong When Used Well

Regex is a very good tool for someone who understands its details. The pattern (?<!-)-(?!>) is a great example of how to use lookarounds to precisely change text. But always remember: how easy it is to read, how fast it runs, and how easy it is to keep up with also matter.

Use this regex module in your next script that automates tasks or data cleaning process. If you find other tricky cases where you need to keep patterns, think about using similar ways. And share your solution with others.