Vättern runt starttider
In this section, we gather all the syntax valid in patterns and discuss why and when you might want to use each one. As you saw in Chapter 6, you can match patterns against literals directly.
The Rust Programming Language
The following code gives some examples:. This code prints one because the value in x is 1. This syntax is useful when you want your code to take an action if it gets a particular concrete value. However, there is a complication when you use named variables in match expressions. Because match starts a new scope, variables declared as part of a pattern inside the match expression will shadow those with the same name outside the match construct, as is the case with all variables.
In Listing , we declare a variable named x with the value Some 5 and a variable y with the value We then create a match expression on the value x. Look at the patterns in the match arms and println! Listing A match expression with an arm that introduces a shadowed variable y. The pattern in the second match arm introduces a new variable named y that will match any value inside a Some value.
This new y binding will match any value inside a Some , which is what we have in x. Therefore, this new y binds to the inner value of the Some in x.
Om loppet - Vätternrundan
When the match expression is done, its scope ends, and so does the scope of the inner y. The last println! To create a match expression that compares the values of the outer x and y , rather than introducing a shadowed variable, we would need to use a match guard conditional instead. In match expressions, you can match multiple patterns using the syntax, which is the pattern or operator.
In the following code, when a pattern matches any of the values within the given range, that arm will execute:. If x is 1, 2, 3, 4, or 5, the first arm will match. This syntax is more convenient for multiple match values than using the operator to express the same idea; if we were to use we would have to specify 1 2 3 4 5.
Specifying a range is much shorter, especially if we want to match, say, any number between 1 and 1,! We can also use patterns to destructure structs, enums, and tuples to use different parts of these values. Listing shows a Point struct with two fields, x and y , that we can break apart using a pattern with a let statement. This code creates the variables a and b that match the values of the x and y fields of the p struct.
Listing behaves in the same way as the code in Listing , but the variables created in the let pattern are x and y instead of a and b.
Vätternrundan: Raceatlas
Listing Destructuring struct fields using struct field shorthand. This code creates the variables x and y that match the x and y fields of the p variable. The outcome is that the variables x and y contain the values from the p struct. We can also destructure with literal values as part of the struct pattern rather than creating variables for all the fields.
Doing so allows us to test some of the fields for particular values while creating variables to destructure the other fields.
Vätternrundan
Listing Destructuring and matching literal values in one pattern. The first arm will match any point that lies on the x axis by specifying that the y field matches if its value matches the literal 0. The pattern still creates an x variable that we can use in the code for this arm. Similarly, the second arm matches any point on the y axis by specifying that the x field matches if its value is 0 and creates a variable y for the value of the y field.
In this example, the value p matches the second arm by virtue of x containing a 0, so this code will print On the y axis at 7. As an example, in Listing we use the Message enum from Listing and write a match with patterns that will destructure each inner value.