struct
Range
A half-open interval from a lower bound up to, but not including, an upper bound.
Inheritance | CustomDebugStringConvertible, CustomReflectable, CustomStringConvertible, Equatable, RangeExpression |
---|
Initializers
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 half-open range operator
(..<
) to form Range
instances is preferred.
- Parameter bounds: A tuple of the lower and upper bounds of the range.
Declaration
@
inlinable
public
init
(
uncheckedBounds
bounds
: (
lower
:
Bound
,
upper
:
Bound
))
Instance Variables
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
A textual representation of the range, suitable for debugging.
Declaration
var
debugDescription
:
String
The range's lower bound.
In an empty range, lowerBound
is equal to upperBound
.
Declaration
let
lowerBound
:
Bound
The range's upper bound.
In an empty range, upperBound
is equal to lowerBound
. A Range
instance does not contain its upper bound.
Declaration
let
upperBound
:
Bound
Instance Methods
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
:
Range
=
0
..
<
20
(
x
.
clamped
(
to
:
10
..
<
1000
))
// Prints "10..<20"
If the two ranges do not overlap, the result is an empty range within the
bounds of limits
.
let
y
:
Range
=
0
..
<
5
(
y
.
clamped
(
to
:
10
..
<
1000
))
// Prints "10..<10"
- Parameter limits: The range to clamp the bounds of this range.
Declaration
Returns a Boolean value indicating whether the given element is contained within the range.
Because Range
represents a half-open range, a Range
instance does not
contain its upper bound. element
is contained in the range if it is
greater than or equal to the lower bound and less than the upper bound.
- Parameter element: The element to check for containment.
Declaration
@
inlinable
public
func
contains
(
_
element
:
Bound
) -
>
Bool
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
:
Range
=
0
..
<
20
(
x
.
overlaps
(
10
...
1000
))
// Prints "true"
Because a half-open range does not include its upper bound, the ranges in the following example do not overlap:
let
y
=
20
..
<
30
(
x
.
overlaps
(
y
))
// Prints "false"
- Parameter other: A range to check for elements in common.
Declaration
Declaration
@
inlinable
public
func
overlaps
(
_
other
:
ClosedRange
<
Bound
>
) -
>
Bool
Returns the range of indices described by this range expression within the given collection.
- Parameter collection: The collection to evaluate this range expression in relation to.
Declaration
@
inlinable
public
func
relative
<
C
>
(
to
collection
:
C
) -
>
Range
<
Bound
>
where
Bound
==
C
.
Index
,
C
:
Collection
Type Methods
Declaration
public
static
func
!=(
lhs
:
Self
,
rhs
:
Self
) -
>
Bool
Returns a Boolean value indicating whether two ranges are equal.
Two ranges are equal when they have the same lower and upper bounds. That requirement holds even for empty ranges.
let
x
=
5
..
<
15
(
x
==
5
..
<
15
)
// Prints "true"
let
y
=
5
..
<
5
(
y
==
15
..
<
15
)
// Prints "false"
Declaration
Declaration
@
inlinable
public
static
func
~=(
pattern
:
Self
,
value
:
Self
.
Bound
) -
>
Bool
You create a
Range
instance by using the half-open range operator (..<
).You can use a
Range
instance to quickly check if a value is contained in a particular range of values. For example:Range
instances can represent an empty interval, unlikeClosedRange
.Using a Range as a Collection of Consecutive Values
When a range uses integers as its lower and upper bounds, or any other type that conforms to the
Strideable
protocol with an integer stride, you can use that range in afor
-in
loop or with any sequence or collection method. The elements of the range are the consecutive values from its lower bound up to, but not including, its upper bound.Because floating-point types such as
Float
andDouble
are their ownStride
types, they cannot be used as the bounds of a countable range. If you need to iterate over consecutive floating-point values, see thestride(from:to:by:)
function.