How do I install the Regex package in Xcode?

Add it via Xcode's package manager by entering the GitHub URL, or update your Package.swift file with the dependency as shown in the README—it's straightforward for iOS/macOS projects.

What's better: Regex or using NSRegularExpression directly?

Regex offers a cleaner, more Swifty API with less boilerplate, but if you need fine-grained control or avoid dependencies, raw NSRegularExpression might be preferable for simple cases.

Can Regex handle complex patterns with comments and whitespace?

Yes, it supports multiline patterns with comments using the `.allowCommentsAndWhitespace` option, demonstrated in the README with raw strings for better readability.

How to extract named capture groups in Swift with Regex?

Use the `group(named:)` method on match objects, e.g., `regex.firstMatch(in: text)?.group(named: "word")?.value` to retrieve values from named groups efficiently.

Is Regex compatible with Swift on Linux or server-side projects?

It depends on Foundation's NSRegularExpression implementation on Linux, which may have limitations; test thoroughly as it's primarily designed for Apple platforms.

How to replace all matches in a string using Regex?

Use the `replacingAllMatches(of:with:)` extension on String, as shown in the README, which simplifies bulk replacements without manual iteration.

Open-Awesome

Regex

MITSwiftv1.1.0

A Swifty wrapper for NSRegularExpression that makes regular expressions more convenient and type-safe in Swift.

Visit Website GitHub

335 stars16 forks0 contributors

What is Regex?

Regex is a Swift package that provides a convenient and type-safe wrapper around Apple's NSRegularExpression API. It simplifies working with regular expressions in Swift by offering a more Swifty interface that reduces boilerplate code and improves type safety while maintaining full compatibility with standard regex syntax.

Target Audience

Swift developers working on iOS, macOS, or other Apple platforms who need to work with regular expressions in their applications and want a more modern, type-safe API.

Value Proposition

Developers choose Regex because it provides a cleaner, more Swifty API for regular expressions compared to using NSRegularExpression directly, with features like type-safe matching, convenient string replacement methods, and support for Swift's pattern matching syntax.

Overview

🔤 Swifty regular expressions

Use Cases

Best For

Validating and parsing text input in Swift applications
Performing complex string replacements with regular expressions
Extracting structured data from text using named capture groups
Implementing pattern matching logic in Swift switch statements
Working with multiline regex patterns with comments
Reducing boilerplate when using NSRegularExpression in Swift code

Not Ideal For

Projects targeting non-Apple platforms (e.g., Linux) where NSRegularExpression support may be incomplete or buggy
Developers needing advanced regex features beyond NSRegularExpression's syntax, like lookbehind assertions
Simple string manipulation tasks where Swift's native String methods or raw regex usage suffice without extra dependencies
Teams already using alternative Swift regex libraries (e.g., SwiftRegex or custom solutions) and prefer to avoid migration overhead

Pros & Cons

Pros

Type-Safe API

Reduces boilerplate and improves code safety with Swifty interfaces, such as concise method calls like `Regex(#"\d+"#).isMatched(by: "123")` instead of manual NSRegularExpression instantiation.

Convenient Matching Methods

Simplifies common operations with methods like `firstMatch(in:)` and `allMatches(in:)`, making regex usage more readable and less error-prone, as shown in the README examples.

Named Capture Groups

Provides easy access to named groups via the `group(named:)` method, enhancing code clarity when extracting specific data from matches, demonstrated in the unicorn example.

Pattern Matching Integration

Seamlessly works with Swift's switch statements for expressive control flow, allowing direct use of regex patterns in case clauses, as illustrated in the README.

Cons

Limited to NSRegularExpression

Inherits all constraints of Apple's NSRegularExpression, such as lack of support for certain Perl-compatible regex features, which can be a blocker for advanced use cases.

Dependency Overhead

Adds an external package dependency that may be unnecessary for projects with minimal regex needs, where raw NSRegularExpression or Swift string methods could suffice.

Platform Lock-in

Tightly coupled to Apple's Foundation framework, making it less suitable for cross-platform Swift projects on Linux or Windows where NSRegularExpression might behave differently.

Frequently Asked Questions

Related Projects

BonMot

Beautiful, easy attributed strings in Swift

Stars3,551

Forks194

Last commit2 years ago

SwiftRichString

👩‍🎨 Elegant Attributed String composition in Swift sauce

Stars3,147

Forks211

Last commit3 years ago

TwitterTextEditor

A standalone, flexible API that provides a full-featured rich text editor for iOS applications.

Stars3,002

Forks171