184 lines
4.6 KiB
Markdown
184 lines
4.6 KiB
Markdown
Standard Iterable Types
|
|
========================
|
|
|
|
{{#include ../links.md}}
|
|
|
|
Certain [standard types] are iterable via a [`for`] statement.
|
|
|
|
|
|
Iterate Through Arrays
|
|
----------------------
|
|
|
|
Iterating through an [array] yields cloned _copies_ of each element.
|
|
|
|
```rust
|
|
let a = [1, 3, 5, 7, 9, 42];
|
|
|
|
// Loop through the array
|
|
for x in a {
|
|
if x > 10 { continue; } // skip to the next iteration
|
|
|
|
print(x);
|
|
|
|
if x == 42 { break; } // break out of for loop
|
|
}
|
|
```
|
|
|
|
Iterate Through Strings
|
|
-----------------------
|
|
|
|
Iterating through a [string] yields individual [characters].
|
|
|
|
The `chars` method also allow iterating through characters in a [string], optionally accepting the
|
|
character position to start from (counting from the end if negative), as well as the number of
|
|
characters to iterate (defaults to all).
|
|
|
|
`char` also accepts a [range] which can be created via the `..` (exclusive) and `..=` (inclusive) operators.
|
|
|
|
```rust
|
|
let s = "hello, world!";
|
|
|
|
// Iterate through all the characters.
|
|
for ch in s {
|
|
print(ch);
|
|
}
|
|
|
|
// Iterate starting from the 3rd character and stopping at the 7th.
|
|
for ch in s.chars(2, 5) {
|
|
if ch > 'z' { continue; } // skip to the next iteration
|
|
|
|
print(ch);
|
|
|
|
if x == '@' { break; } // break out of for loop
|
|
}
|
|
|
|
// Iterate starting from the 3rd character and stopping at the end.
|
|
for ch in s.chars(2..s.len) {
|
|
if ch > 'z' { continue; } // skip to the next iteration
|
|
|
|
print(ch);
|
|
|
|
if x == '@' { break; } // break out of for loop
|
|
}
|
|
```
|
|
|
|
|
|
Iterate Through Numeric Ranges
|
|
------------------------------
|
|
|
|
[Ranges] are created via the `..` (exclusive) and `..=` (inclusive) operators.
|
|
|
|
The `range` function similarly creates exclusive [ranges], plus allowing optional step values.
|
|
|
|
```rust
|
|
// Iterate starting from 0 and stopping at 49
|
|
// The step is assumed to be 1 when omitted for integers
|
|
for x in 0..50 {
|
|
if x > 10 { continue; } // skip to the next iteration
|
|
|
|
print(x);
|
|
|
|
if x == 42 { break; } // break out of for loop
|
|
}
|
|
|
|
// The 'range' function is just the same
|
|
for x in range(0, 50) {
|
|
if x > 10 { continue; } // skip to the next iteration
|
|
|
|
print(x);
|
|
|
|
if x == 42 { break; } // break out of for loop
|
|
}
|
|
|
|
// The 'range' function also takes a step
|
|
for x in range(0, 50, 3) { // step by 3
|
|
if x > 10 { continue; } // skip to the next iteration
|
|
|
|
print(x);
|
|
|
|
if x == 42 { break; } // break out of for loop
|
|
}
|
|
|
|
// The 'range' function can also step backwards
|
|
for x in range(50..0, -3) { // step down by -3
|
|
if x < 10 { continue; } // skip to the next iteration
|
|
|
|
print(x);
|
|
|
|
if x == 42 { break; } // break out of for loop
|
|
}
|
|
|
|
// It works also for floating-point numbers
|
|
for x in range(5.0, 0.0, -2.0) { // step down by -2.0
|
|
if x < 10 { continue; } // skip to the next iteration
|
|
|
|
print(x);
|
|
|
|
if x == 4.2 { break; } // break out of for loop
|
|
}
|
|
```
|
|
|
|
Iterate Through Bit-Fields
|
|
--------------------------
|
|
|
|
The `bits` function allows iterating through an integer as a [bit-field].
|
|
|
|
`bits` optionally accepts the bit number to start from (counting from the most-significant-bit if
|
|
negative), as well as the number of bits to iterate (defaults all).
|
|
|
|
`bits` also accepts a [range] which can be created via the `..` (exclusive) and `..=` (inclusive) operators.
|
|
|
|
```js , no_run
|
|
let x = 0b_1001110010_1101100010_1100010100;
|
|
let num_on = 0;
|
|
|
|
// Iterate through all the bits
|
|
for bit in x.bits() {
|
|
if bit { num_on += 1; }
|
|
}
|
|
|
|
print(`There are ${num_on} bits turned on!`);
|
|
|
|
const START = 3;
|
|
|
|
// Iterate through all the bits from 3 through 12
|
|
for (bit, index) in x.bits(START, 10) {
|
|
print(`Bit #${index} is ${if bit { "ON" } else { "OFF" }}!`);
|
|
|
|
if index >= 7 { break; } // break out of for loop
|
|
}
|
|
|
|
// Iterate through all the bits from 3 through 12
|
|
for (bit, index) in x.bits(3..=12) {
|
|
print(`Bit #${index} is ${if bit { "ON" } else { "OFF" }}!`);
|
|
|
|
if index >= 7 { break; } // break out of for loop
|
|
}
|
|
```
|
|
|
|
Iterate Through Object Maps
|
|
---------------------------
|
|
|
|
Two methods, `keys` and `values`, return [arrays] containing cloned _copies_
|
|
of all property names and values of an [object map], respectively.
|
|
|
|
These [arrays] can be iterated.
|
|
|
|
```rust
|
|
let map = #{a:1, b:3, c:5, d:7, e:9};
|
|
|
|
// Property names are returned in unsorted, random order
|
|
for x in map.keys() {
|
|
if x > 10 { continue; } // skip to the next iteration
|
|
|
|
print(x);
|
|
|
|
if x == 42 { break; } // break out of for loop
|
|
}
|
|
|
|
// Property values are returned in unsorted, random order
|
|
for val in map.values() {
|
|
print(val);
|
|
}
|
|
```
|