> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Swift Character
A `Character` in Swift represents a single extended grapheme cluster. An extended grapheme cluster is a sequence of one or more Unicode scalar values that, when rendered together, produce a single human-readable typographic character.
Because Swift uses the same double-quote syntax for both strings and characters, a `Character` must be explicitly type-annotated during initialization; otherwise, the compiler infers a `String`.
```swift theme={"dark"}
let explicitCharacter: Character = "A"
let inferredString = "A" // Type is String
```
## Extended Grapheme Clusters
A `Character` is not strictly bound to a single, fixed-width memory unit (like an 8-bit `char` in C). Instead, it encapsulates whatever Unicode scalars are necessary to form the visual character. This includes base characters combined with modifying marks, or multiple emojis joined by zero-width joiners (ZWJ).
```swift theme={"dark"}
// Single Unicode scalar
let singleScalar: Character = "\u{E9}" // é
// Base scalar (e) + Combining acute accent (´)
let combinedScalar: Character = "\u{65}\u{301}" // é
// Multiple scalars joined by Zero-Width Joiners
let familyEmoji: Character = "\u{1F468}\u{200D}\u{1F469}\u{200D}\u{1F466}" // 👨👩👦
```
In all three examples above, the result is a single `Character` instance. When placed inside a `String` collection, each of these instances contributes exactly 1 to the string's total `count`, despite the differing number of underlying Unicode scalars.
## Canonical Equivalence
Swift evaluates `Character` equality based on canonical equivalence. Two `Character` instances are considered equal if they represent the same linguistic meaning and visual appearance, regardless of whether they are composed of the exact same underlying Unicode scalars.
```swift theme={"dark"}
let precomposed: Character = "\u{E9}" // U+00E9
let decomposed: Character = "\u{65}\u{301}" // U+0065 + U+0301
print(precomposed == decomposed) // true
```
## Memory and Indexing Implications
Because a `Character` can consist of an arbitrary number of Unicode scalars, its memory footprint is variable. Consequently, Swift strings (which are collections of `Character` instances) cannot be indexed using standard integer offsets in $O(1)$ time. To determine the boundaries of a `Character`, Swift must iterate through the underlying Unicode scalars to evaluate where one extended grapheme cluster ends and the next begins.
## Introspection Properties
The `Character` type provides built-in properties to evaluate its Unicode classification and underlying scalar data without requiring manual bitwise operations or regex.
```swift theme={"dark"}
let char: Character = "A"
let isASCII = char.isASCII // true
let asciiVal = char.asciiValue // Optional(65)
let isHex = char.isHexDigit // true
let isLetter = char.isLetter // true
let isWhitespace = char.isWhitespace // false
```
Tired of Poor Swift Skills? Fix That With Deep Grasping!
Learn More
