# Part 1: Regular Expressions in Swift

In Swift, regular expressions are available through the `NSRegularExpression` class, part of the Foundation framework. This class provides the means to create, evaluate, and manipulate regular expressions.

## Basic Components of Regular Expressions

Before diving into Swift-specific details, let's explore the fundamental components of regular expressions:

### 1\. Literal Characters

Literal characters are regular characters (letters, digits, symbols) that match themselves. For example, the regular expression `apple` would match the string `"apple"`.

### 2\. Metacharacters

Metacharacters are special characters that have a reserved meaning in regular expressions. Some common metacharacters include:

* `.` dot
    
* `*` asterisk
    
* `+` plus
    
* `?` question mark
    
* `|` pipe
    
* `[` `]` square brackets
    
* `{` `}` curly braces
    
* `(` `)` parentheses
    

### 3\. Character Classes

Character classes allow you to match any one character from a set of characters. For example, `[aeiou]` matches any vowel.

### 4\. Predefined Character Classes

Regular expressions also provide predefined character classes for common character groups, such as:

* `\d` matches any digit (equivalent to `[0-9]`).
    
* `\w` matches any word character (equivalent to `[a-zA-Z0-9_]`).
    
* `\s` matches any whitespace character.
    
* `\D`, `\W`, and `\S` are their negations.
    

### 5\. Quantifiers

Quantifiers specify how many times a character or group of characters should be matched:

* `*` matches zero or more occurrences.
    
* `+` matches one or more occurrences.
    
* `?` matches zero or one occurrence.
    
* `{n}` matches exactly `n` occurrences.
    
* `{n,}` matches at least `n` occurrences.
    
* `{n,m}` matches between `n` and `m` occurrences.
    

### 6\. Anchors

Anchors are used to specify the position within a string where a match should occur:

* `^` matches the start of a string.
    
* `$` matches the end of a string.
    

## Using Regular Expressions in Swift

Now that you have a basic understanding of regular expression components, let's explore how to use regular expressions in Swift. The Foundation framework provides the `NSRegularExpression` class, which we'll be working with in the next part of this series.

Here's a quick example of how to use regular expressions in Swift:

```swift
import Foundation

let inputString = "Hello, World!"
let pattern = "Hello, (\\w+)!"

do {
    let regex = try NSRegularExpression(pattern: pattern)
    if let match = regex.firstMatch(in: inputString, range: NSRange(inputString.startIndex..., in: inputString)) {
        let capturedGroupRange = match.range(at: 1)
        if let swiftRange = Range(capturedGroupRange, in: inputString) {
            let capturedText = String(inputString[swiftRange])
            print("Matched: \(capturedText)")
        }
    }
} catch {
    print("Error: \(error)")
}
```

In the above example, we import the Foundation framework, create an input string, and define a regular expression pattern. We then use the `NSRegularExpression` class to compile the pattern and search for matches within the input string. If a match is found, we extract the matched text using the `range` method and print it.

This is just a basic example to get you started. In the next part of this series, we'll dive deeper into the `NSRegularExpression` class and explore more complex regular expression patterns and use cases in Swift. Stay tuned!