ClosedRange

An interval over a comparable type, from a lower bound up to, and including, an upper bound.

You create instances of ClosedRange by using the closed range operator (...).

  • let lowercase = "a"..."z"

You can use a ClosedRange instance to quickly check if a value is contained in a particular range of values. For example:

  • print(lowercase.contains("c"))      // Prints "true"
  • print(lowercase.contains("5"))      // Prints "false"
  • print(lowercase.contains("z"))      // Prints "true"

Unlike Range, instances of ClosedRange cannot represent an empty interval.

  • let lowercaseA = "a"..."a"
  • print(lowercaseA.isEmpty)
  • // Prints "false"

See Also: CountableRange, Range, CountableClosedRange

Inheritance CustomDebugStringConvertible, CustomReflectable, CustomStringConvertible, Equatable View Protocol Hierarchy →
Import
  • import Swift

Initializers

init(_: ClosedRange<Bound>)

Creates an instance equivalent to the given range.

other: A range to convert to a ClosedRange instance.

Declaration

init(_: CountableClosedRange<Bound>)

Creates an instance equivalent to the given range.

other: A range to convert to a ClosedRange instance.

Declaration

init(_: CountableRange<Bound>)

Creates an instance equivalent to the given range.

An equivalent range must be representable as an instance of ClosedRange. For example, passing an empty range as other triggers a runtime error, because an empty range cannot be represented by a ClosedRange instance.

other: A range to convert to a ClosedRange instance.

Declaration

init(_: Range<Bound>)

Creates an instance equivalent to the given range.

An equivalent range must be representable as an instance of ClosedRange. For example, passing an empty range as other triggers a runtime error, because an empty range cannot be represented by a ClosedRange instance.

other: A range to convert to a ClosedRange instance.

Declaration

  • init(_ other: Range<Bound>)
init(uncheckedBounds bounds: (lower: Bound,:)

Creates an instance with the given bounds.

Because this initializer does not perform any checks, it should be used as an optimization only when you are absolutely certain that lower is less than or equal to upper. Using the closed range operator (...) to form ClosedRange instances is preferred.

bounds: A tuple of the lower and upper bounds of the range.

Declaration

  • init(uncheckedBounds bounds: (lower: Bound, upper: Bound))

Instance Variables

var count: Bound.Stride

The number of values contained in the range.

Declaration

  • var count: Bound.Stride { get }
var customMirror: Mirror

The custom mirror for this instance.

If this type has value semantics, the mirror should be unaffected by subsequent mutations of the instance.

Declaration

  • var customMirror: Mirror { get }
var debugDescription: String

A textual representation of the range, suitable for debugging.

Declaration

  • var debugDescription: String { get }
var description: String

A textual representation of the range.

Declaration

  • var description: String { get }
var isEmpty: Bool

A Boolean value indicating whether the range contains no elements.

Because a closed range cannot represent an empty range, this property is always false.

Declaration

  • var isEmpty: Bool { get }
var lowerBound: Bound

The range's lower bound.

Declaration

  • var lowerBound: Bound { get }
var upperBound: Bound

The range's upper bound.

Declaration

  • var upperBound: Bound { get }

Instance Methods

func ==(_:rhs:)

Returns a Boolean value indicating whether two values are equal.

Equality is the inverse of inequality. For any values a and b, a == b implies that a != b is false.

Parameters: lhs: A value to compare. rhs: Another value to compare.

Declaration

func ~=(_:value:)

Declaration

func clamped(to:)

Returns a copy of this range clamped to the given limiting range.

The bounds of the result are always limited to the bounds of limits. For example:

  • let x: ClosedRange = 0...20
  • print(x.clamped(to: 10...1000))
  • // Prints "10...20"

If the two ranges do not overlap, the result is a single-element range at the upper or lower bound of limits.

  • let y: ClosedRange = 0...5
  • print(y.clamped(to: 10...1000))
  • // Prints "10...10"

limits: The range to clamp the bounds of this range. Returns: A new range clamped to the bounds of limits.

Declaration

func contains(_:)

Returns a Boolean value indicating whether the given element is contained within the range.

A ClosedRange instance contains both its lower and upper bound. element is contained in the range if it is between the two bounds or equal to either bound.

element: The element to check for containment. Returns: true if element is contained in the range; otherwise, false.

Declaration

  • func contains(_ element: Bound) -> Bool
func overlaps(_: ClosedRange<Bound>)

Returns a Boolean value indicating whether this range and the given range contain an element in common.

This example shows two overlapping ranges:

Because a closed range includes its upper bound, the ranges in the following example also overlap:

  • let y: ClosedRange = 20...30
  • print(x.overlaps(y))
  • // Prints "true"

other: A range to check for elements in common. Returns: true if this range and other have at least one element in common; otherwise, false.

Declaration

func overlaps(_: CountableClosedRange<Bound>)

Returns a Boolean value indicating whether this range and the given range contain an element in common.

This example shows two overlapping ranges:

Because a closed range includes its upper bound, the ranges in the following example also overlap:

other: A range to check for elements in common. Returns: true if this range and other have at least one element in common; otherwise, false.

Declaration

func overlaps(_: CountableRange<Bound>)

Returns a Boolean value indicating whether this range and the given range contain an element in common.

This example shows two overlapping ranges:

Because a closed range includes its upper bound, the ranges in the following example also overlap:

other: A range to check for elements in common. Returns: true if this range and other have at least one element in common; otherwise, false.

Declaration

func overlaps(_: Range<Bound>)

Returns a Boolean value indicating whether this range and the given range contain an element in common.

This example shows two overlapping ranges:

  • let x: ClosedRange = 0...20
  • print(x.overlaps(10..<1000 as Range))
  • // Prints "true"

Because a closed range includes its upper bound, the ranges in the following example also overlap:

  • let y: Range = 20...30
  • print(x.overlaps(y))
  • // Prints "true"

other: A range to check for elements in common. Returns: true if this range and other have at least one element in common; otherwise, false.

Declaration