Structure

String.UnicodeScalarView

A view of a string’s contents as a collection of Unicode scalar values.

Declaration

@frozen struct UnicodeScalarView

Overview

You can access a string’s view of Unicode scalar values by using its unicodeScalars property. Unicode scalar values are the 21-bit codes that are the basic unit of Unicode. Each scalar value is represented by a Unicode.Scalar instance and is equivalent to a UTF-32 code unit.

let flowers = "Flowers 💐"
for v in flowers.unicodeScalars {
    print(v.value)
}
// 70
// 108
// 111
// 119
// 101
// 114
// 115
// 32
// 128144

Some characters that are visible in a string are made up of more than one Unicode scalar value. In that case, a string’s unicodeScalars view contains more elements than the string itself.

let flag = "🇵🇷"
for c in flag {
    print(c)
}
// 🇵🇷

for v in flag.unicodeScalars {
    print(v.value)
}
// 127477
// 127479

You can convert a String.UnicodeScalarView instance back into a string using the String type’s init(_:) initializer.

let favemoji = "My favorite emoji is 🎉"
if let i = favemoji.unicodeScalars.firstIndex(where: { $0.value >= 128 }) {
    let asciiPrefix = String(favemoji.unicodeScalars[..<i])
    print(asciiPrefix)
}
// Prints "My favorite emoji is "

Topics

Type Aliases

typealias String.UnicodeScalarView.Index

A type that represents a position in the collection.

typealias String.UnicodeScalarView.Element

A type representing the sequence’s elements.

typealias String.UnicodeScalarView.Indices

A type that represents the indices that are valid for subscripting the collection, in ascending order.

typealias String.UnicodeScalarView.SubSequence

A sequence that represents a contiguous subrange of the collection’s elements.

Initializers

init()

Creates an empty view instance.

init<S>(S)

Creates a new instance of a collection containing the elements of a sequence.

init(repeating: Unicode.Scalar, count: Int)

Creates a new collection containing the specified number of a single, repeated value.

Instance Properties

var count: Int

The number of elements in the collection.

var customMirror: Mirror

Returns a mirror that reflects the Unicode scalars view of a string.

var customPlaygroundQuickLook: _PlaygroundQuickLook

A custom playground Quick Look for this instance.

Deprecated
var debugDescription: String

A textual representation of this instance, suitable for debugging.

var description: String

A textual representation of this instance.

var endIndex: String.UnicodeScalarView.Index

The “past the end” position—that is, the position one greater than the last valid subscript argument.

var first: Unicode.Scalar?

The first element of the collection.

var indices: DefaultIndices<String.UnicodeScalarView>

The indices that are valid for subscripting the collection, in ascending order.

var isEmpty: Bool

A Boolean value indicating whether the collection is empty.

var last: Unicode.Scalar?

The last element of the collection.

var lazy: LazySequence<String.UnicodeScalarView>

A sequence containing the same elements as this sequence, but on which some operations, such as map and filter, are implemented lazily.

var startIndex: String.UnicodeScalarView.Index

The position of the first Unicode scalar value if the string is nonempty.

var underestimatedCount: Int

A value less than or equal to the number of elements in the collection.

Instance Methods

func allSatisfy((Unicode.Scalar) -> Bool) -> Bool

Returns a Boolean value indicating whether every element of a sequence satisfies a given predicate.

func append(Unicode.Scalar)

Appends the given Unicode scalar to the view.

func append<S>(contentsOf: S)

Appends the Unicode scalar values in the given sequence to the view.

func append<S>(contentsOf: S)

Adds the elements of a sequence or collection to the end of this collection.

func compactMap<ElementOfResult>((Unicode.Scalar) -> ElementOfResult?) -> [ElementOfResult]

Returns an array containing the non-nil results of calling the given transformation with each element of this sequence.

func contains(Unicode.Scalar) -> Bool

Returns a Boolean value indicating whether the sequence contains the given element.

func contains(where: (Unicode.Scalar) -> Bool) -> Bool

Returns a Boolean value indicating whether the sequence contains an element that satisfies the given predicate.

func difference<C>(from: C) -> CollectionDifference<Unicode.Scalar>

Returns the difference needed to produce this collection’s ordered elements from the given collection.

func difference<C>(from: C, by: (C.Element, Unicode.Scalar) -> Bool) -> CollectionDifference<Unicode.Scalar>

Returns the difference needed to produce this collection’s ordered elements from the given collection, using the given predicate as an equivalence test.

func drop(while: (Unicode.Scalar) -> Bool) -> Substring.UnicodeScalarView

Returns a subsequence by skipping elements while predicate returns true and returning the remaining elements.

func dropFirst(Int) -> Substring.UnicodeScalarView

Returns a subsequence containing all but the given number of initial elements.

func dropLast(Int) -> Substring.UnicodeScalarView

Returns a subsequence containing all but the specified number of final elements.

func elementsEqual<OtherSequence>(OtherSequence) -> Bool

Returns a Boolean value indicating whether this sequence and another sequence contain the same elements in the same order.

func elementsEqual<OtherSequence>(OtherSequence, by: (Unicode.Scalar, OtherSequence.Element) -> Bool) -> Bool

Returns a Boolean value indicating whether this sequence and another sequence contain equivalent elements in the same order, using the given predicate as the equivalence test.

func enumerated() -> EnumeratedSequence<String.UnicodeScalarView>

Returns a sequence of pairs (n, x), where n represents a consecutive integer starting at zero and x represents an element of the sequence.

func filter((Unicode.Scalar) -> Bool) -> String.UnicodeScalarView

Returns a new collection of the same type containing, in order, the elements of the original collection that satisfy the given predicate.

func first(where: (Unicode.Scalar) -> Bool) -> Unicode.Scalar?

Returns the first element of the sequence that satisfies the given predicate.

func firstIndex(of: Unicode.Scalar) -> String.Index?

Returns the first index where the specified value appears in the collection.

func firstIndex(where: (Unicode.Scalar) -> Bool) -> String.Index?

Returns the first index in which an element of the collection satisfies the given predicate.

func flatMap<SegmentOfResult>((Unicode.Scalar) -> SegmentOfResult) -> [SegmentOfResult.Element]

Returns an array containing the concatenated results of calling the given transformation with each element of this sequence.

func forEach((Unicode.Scalar) -> Void)

Calls the given closure on each element in the sequence in the same order as a for-in loop.

func formIndex(inout String.Index, offsetBy: Int)

Offsets the given index by the specified distance.

func formIndex(inout String.Index, offsetBy: Int, limitedBy: String.Index) -> Bool

Offsets the given index by the specified distance, or so that it equals the given limiting index.

func formIndex(after: inout String.Index)

Replaces the given index with its successor.

func formIndex(before: inout String.Index)

Replaces the given index with its predecessor.

func index(String.Index, offsetBy: Int) -> String.Index

Returns an index that is the specified distance from the given index.

func index(String.Index, offsetBy: Int, limitedBy: String.Index) -> String.Index?

Returns an index that is the specified distance from the given index, unless that distance is beyond a given limiting index.

func index(of: Unicode.Scalar) -> String.Index?

Returns the first index where the specified value appears in the collection.

Deprecated
func insert(Unicode.Scalar, at: String.Index)

Inserts a new element into the collection at the specified position.

func insert<C>(contentsOf: C, at: String.Index)

Inserts the elements of a sequence into the collection at the specified position.

func last(where: (Unicode.Scalar) -> Bool) -> Unicode.Scalar?

Returns the last element of the sequence that satisfies the given predicate.

func lastIndex(of: Unicode.Scalar) -> String.Index?

Returns the last index where the specified value appears in the collection.

func lastIndex(where: (Unicode.Scalar) -> Bool) -> String.Index?

Returns the index of the last element in the collection that matches the given predicate.

func lexicographicallyPrecedes<OtherSequence>(OtherSequence) -> Bool

Returns a Boolean value indicating whether the sequence precedes another sequence in a lexicographical (dictionary) ordering, using the less-than operator (<) to compare elements.

func lexicographicallyPrecedes<OtherSequence>(OtherSequence, by: (Unicode.Scalar, Unicode.Scalar) -> Bool) -> Bool

Returns a Boolean value indicating whether the sequence precedes another sequence in a lexicographical (dictionary) ordering, using the given predicate to compare elements.

func makeIterator() -> String.UnicodeScalarView.Iterator

Returns an iterator over the elements of the collection.

func map<T>((Unicode.Scalar) -> T) -> [T]

Returns an array containing the results of mapping the given closure over the sequence’s elements.

func max() -> Unicode.Scalar?

Returns the maximum element in the sequence.

func max(by: (Unicode.Scalar, Unicode.Scalar) -> Bool) -> Unicode.Scalar?

Returns the maximum element in the sequence, using the given predicate as the comparison between elements.

func min() -> Unicode.Scalar?

Returns the minimum element in the sequence.

func min(by: (Unicode.Scalar, Unicode.Scalar) -> Bool) -> Unicode.Scalar?

Returns the minimum element in the sequence, using the given predicate as the comparison between elements.

func popLast() -> Unicode.Scalar?

Removes and returns the last element of the collection.

func prefix(Int) -> Substring.UnicodeScalarView

Returns a subsequence, up to the specified maximum length, containing the initial elements of the collection.

func prefix(through: String.Index) -> Substring.UnicodeScalarView

Returns a subsequence from the start of the collection through the specified position.

func prefix(upTo: String.Index) -> Substring.UnicodeScalarView

Returns a subsequence from the start of the collection up to, but not including, the specified position.

func prefix(while: (Unicode.Scalar) -> Bool) -> Substring.UnicodeScalarView

Returns a subsequence containing the initial elements until predicate returns false and skipping the remaining elements.

func randomElement() -> Unicode.Scalar?

Returns a random element of the collection.

func randomElement<T>(using: inout T) -> Unicode.Scalar?

Returns a random element of the collection, using the given generator as a source for randomness.

func reduce<Result>(Result, (Result, Unicode.Scalar) -> Result) -> Result

Returns the result of combining the elements of the sequence using the given closure.

func reduce<Result>(into: Result, (inout Result, Unicode.Scalar) -> ()) -> Result

Returns the result of combining the elements of the sequence using the given closure.

func remove(at: String.Index) -> Unicode.Scalar

Removes and returns the element at the specified position.

func removeAll(keepingCapacity: Bool)

Removes all elements from the collection.

func removeAll(where: (Unicode.Scalar) -> Bool)

Removes all the elements that satisfy the given predicate.

func removeFirst() -> Unicode.Scalar

Removes and returns the first element of the collection.

func removeFirst(Int)

Removes the specified number of elements from the beginning of the collection.

func removeLast() -> Unicode.Scalar

Removes and returns the last element of the collection.

func removeLast(Int)

Removes the specified number of elements from the end of the collection.

func removeSubrange(Range<String.Index>)

Removes the elements in the specified subrange from the collection.

func removeSubrange<R>(R)

Removes the elements in the specified subrange from the collection.

func replaceSubrange<C>(Range<String.UnicodeScalarView.Index>, with: C)

Replaces the elements within the specified bounds with the given Unicode scalar values.

func replaceSubrange<C, R>(R, with: C)

Replaces the specified subrange of elements with the given collection.

func reserveCapacity(Int)

Reserves enough space in the view’s underlying storage to store the specified number of ASCII characters.

func reversed() -> ReversedCollection<String.UnicodeScalarView>

Returns a view presenting the elements of the collection in reverse order.

func shuffled() -> [Unicode.Scalar]

Returns the elements of the sequence, shuffled.

func shuffled<T>(using: inout T) -> [Unicode.Scalar]

Returns the elements of the sequence, shuffled using the given generator as a source for randomness.

func sorted() -> [Unicode.Scalar]

Returns the elements of the sequence, sorted.

func sorted(by: (Unicode.Scalar, Unicode.Scalar) -> Bool) -> [Unicode.Scalar]

Returns the elements of the sequence, sorted using the given predicate as the comparison between elements.

func split(maxSplits: Int, omittingEmptySubsequences: Bool, whereSeparator: (Unicode.Scalar) -> Bool) -> [Substring.UnicodeScalarView]

Returns the longest possible subsequences of the collection, in order, that don’t contain elements satisfying the given predicate.

func split(separator: Unicode.Scalar, maxSplits: Int, omittingEmptySubsequences: Bool) -> [Substring.UnicodeScalarView]

Returns the longest possible subsequences of the collection, in order, around elements equal to the given element.

func starts<PossiblePrefix>(with: PossiblePrefix) -> Bool

Returns a Boolean value indicating whether the initial elements of the sequence are the same as the elements in another sequence.

func starts<PossiblePrefix>(with: PossiblePrefix, by: (Unicode.Scalar, PossiblePrefix.Element) -> Bool) -> Bool

Returns a Boolean value indicating whether the initial elements of the sequence are equivalent to the elements in another sequence, using the given predicate as the equivalence test.

func suffix(Int) -> Substring.UnicodeScalarView

Returns a subsequence, up to the given maximum length, containing the final elements of the collection.

func suffix(from: String.Index) -> Substring.UnicodeScalarView

Returns a subsequence from the specified position to the end of the collection.

func withContiguousStorageIfAvailable<R>((UnsafeBufferPointer<Unicode.Scalar>) -> R) -> R?

Call body(p), where p is a pointer to the collection’s contiguous storage. If no such storage exists, it is first created. If the collection does not support an internal representation in a form of contiguous storage, body is not called and nil is returned.

Subscripts

subscript(String.UnicodeScalarView.Index) -> Unicode.Scalar

Accesses the Unicode scalar value at the given position.

subscript(Range<String.UnicodeScalarView.Index>) -> String.UnicodeScalarView.SubSequence

Accesses a contiguous subrange of the collection’s elements.

subscript<R>(R) -> Substring.UnicodeScalarView

Accesses the contiguous subrange of the collection’s elements specified by a range expression.

Operator Functions

static func + <Other>(Other, String.UnicodeScalarView) -> String.UnicodeScalarView

Creates a new collection by concatenating the elements of a sequence and a collection.

static func + <Other>(String.UnicodeScalarView, Other) -> String.UnicodeScalarView

Creates a new collection by concatenating the elements of a collection and a sequence.

static func + <Other>(String.UnicodeScalarView, Other) -> String.UnicodeScalarView

Creates a new collection by concatenating the elements of two collections.

static func += <Other>(inout String.UnicodeScalarView, Other)

Appends the elements of a sequence to a range-replaceable collection.

Structures

struct String.UnicodeScalarView.Iterator

A type that provides the collection’s iteration interface and encapsulates its iteration state.

Relationships

From Protocol

See Also

Related String Types

struct Substring

A slice of a string.

protocol StringProtocol

A type that can represent a string as a collection of characters.

struct String.Index

A position of a character or code unit in a string.

struct String.UTF16View

A view of a string’s contents as a collection of UTF-16 code units.

struct String.UTF8View

A view of a string’s contents as a collection of UTF-8 code units.

struct String.Iterator

A type that provides the collection’s iteration interface and encapsulates its iteration state.