A view of a dictionary’s values.

SDK

- Xcode 9.0+

Framework

- Swift Standard Library

Structure# Dictionary.Values

A view of a dictionary’s values.

SDK

- Xcode 9.0+

Framework

- Swift Standard Library

`var count: Int`

The number of values in the dictionary.

`var count: Int`

The number of elements in the collection.

`var first: Value?`

The first element of the collection.

`var indices: Default`Indices<Dictionary<Key, Value>.Values>

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

`var is`Empty : Bool

A Boolean value indicating whether the collection is empty.

`var lazy: Lazy`Sequence<Dictionary<Key, Value>.Values>

A sequence containing the same elements as this sequence, but on which some operations, such as `map`

and `filter`

, are implemented lazily.

`var lazy: Lazy`Collection<Dictionary<Key, Value>.Values>

A view onto this collection that provides lazy implementations of normally eager operations, such as `map`

and `filter`

.

`var underestimated`Count : Int

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

`var underestimated`Count : Int

Returns a value less than or equal to the number of elements in the sequence, nondestructively.

`func contains(where: (Value) -> Bool)`

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

`func drop(while: (Value) -> Bool)`

Returns a subsequence by skipping elements while `predicate`

returns `true`

and returning the remaining elements.

`func drop`First ()

Returns a subsequence containing all but the first element of the sequence.

`func drop`First (Int)

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

`func drop`Last ()

Returns a subsequence containing all but the last element of the sequence.

`func drop`Last (Int)

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

`func elements`Equal <OtherSequence>(OtherSequence)

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

`func elements`Equal <OtherSequence>(OtherSequence, by: (Value, Value) -> 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()`

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((Value) -> Bool)`

Returns an array containing, in order, the elements of the sequence that satisfy the given predicate.

`func first(where: (Value) -> Bool)`

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

`func for`Each ((Value) -> Void)

Calls the given closure on each element in the sequence in the same order as a `for`

-`in`

loop.

`func index(of: Value)`

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

`func index(where: (Value) -> Bool)`

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

`func joined()`

Returns the elements of this collection of collections, concatenated.

`func joined()`

Returns the elements of this sequence of sequences, concatenated.

`func joined(separator: String)`

Returns a new string by concatenating the elements of the sequence, adding the given separator between each element.

`func joined<Separator>(separator: Separator)`

Returns the concatenated elements of this sequence of sequences, inserting the given separator between each element.

`func lexicographically`Precedes <OtherSequence>(OtherSequence)

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 lexicographically`Precedes <OtherSequence>(OtherSequence, by: (Value, Value) -> 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 make`Iterator ()

Returns an iterator over the elements of the collection.

`func map<T>((Value) -> T)`

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

`func map<T>((Value) -> T)`

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

`func max()`

Returns the maximum element in the sequence.

`func max(by: (Value, Value) -> Bool)`

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

`func min()`

Returns the minimum element in the sequence.

`func min(by: (Value, Value) -> Bool)`

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

`func prefix(Int)`

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

`func prefix(through: Dictionary<Key, Value>.Index)`

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

`func prefix(up`To : Dictionary<Key, Value>.Index)

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

`func prefix(while: (Value) -> Bool)`

Returns a subsequence containing the initial elements until `predicate`

returns `false`

and skipping the remaining elements.

`func reduce<Result>(Result, (Result, Value) -> Result)`

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

`func reduce<Result>(into: Result, (inout Result, Value) -> ())`

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

`func reversed()`

Returns an array containing the elements of this sequence in reverse order.

`func sorted()`

Returns the elements of the collection, sorted.

`func sorted()`

Returns the elements of the sequence, sorted.

`func sorted(by: (Value, Value) -> Bool)`

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

`func split(max`Splits : Int, omittingEmptySubsequences : Bool, whereSeparator : (Value) -> Bool)

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

`func split(separator: Value, max`Splits : Int, omittingEmptySubsequences : Bool)

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

`func split(separator: Value, max`Splits : Int, omittingEmptySubsequences : Bool)

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

`func starts<Possible`Prefix>( with: PossiblePrefix)

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

`func starts<Possible`Prefix>( with: PossiblePrefix, by: (Value, Value) -> 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)`

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

`func suffix(from: Dictionary<Key, Value>.Index)`

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

`func swap`At (Dictionary<Key, Value>.Index, Dictionary<Key, Value>.Index)

Exchanges the values at the specified indices of the collection.

`subscript(Range<Dictionary<Key, Value>.Index>)`

Accesses a contiguous subrange of the collection’s elements.

`struct Dictionary`.Keys

A view of a dictionary’s keys.

`struct Dictionary`.Index

The position of a key-value pair in a dictionary.

`struct Dictionary`Iterator

An iterator over the members of a `Dictionary<Key, Value>`

.