Difference between revisions of "W1037 Expressions and Operators"
Line 48: | Line 48: | ||
<syntaxhighlight lang="swift"> | <syntaxhighlight lang="swift"> | ||
let g = 0xFp3 // g is a Double of value 120 | let g = 0xFp3 // g is a Double of value 120 | ||
</syntaxhighlight> | |||
Note that for ''literal constants'', Swift will interpret the expression as a Double if any of the component expressions evaluate to a Double. ⚠ This does not apply to named constants. | |||
=== Readability === | |||
Both integers and floating point numbers may have leading zeroes and embedded underscores for easier reading (by humans). | |||
<syntaxhighlight lang="swift"> | |||
let oneBillion = 1_000_000_000 | |||
let tenBillion = 010_000_000_000 | |||
</syntaxhighlight> | </syntaxhighlight> | ||
Revision as of 19:46, 28 October 2019
Coming Soon | |
Expressions |
Prerequisites[edit]
- W1031 Positive Integers
- W1032 Negative Integers
- W1033 Character Encoding
- W1038 L-Values and R-Values
Introduction[edit]
An expression is a finite series of symbols that is well-formed according to agreed upon rules. The symbols may include constants, variables, operators, and brackets. A valid expression will yield a value of a specific type according to the rules of the language.
Type Inference[edit]
Integers[edit]
All expressions, when evaluated, yield a particular type. For example, in the expression:
let x = 3
x will be of type Int, which is an integer whose size depends on the size of the underlying platform. (On 32-bit platforms, Int will be equivalent to Int32, and on 64-bit platforms, Int will be equivalent to Int64.) On the other hand, in the expression:
let y = 3.0
y will be of type Double, which is a double-precision, floating-point type. Because Swift is a type-safe language, all expressions will always have a specific type. Type-safety enables the compiler to warn us when we make a mistake, such as by using an Int when we intended a Double. Like many other type-safe languages, we're able to explicitly specify the type of a constant of variable:
let x : Int = 3
We're able to use explicit typing to ensure that we're evaluating the expression as the desired type as in the example above. However, in most cases, Swift allows us to be more brief, and rely on type inference. Type inference will rely on the literal value(s) or named value(s) to determine the type. Let's look at a few examples:
let maximumClassCount = 8
// maximumClassCount will be of type Int
let maximumGPA = 5.0
// maximumGPA will be of type Double
In addition to decimal, literal integer expressions Swift will also infer the Int type from binary, octal, and hexadecimal:
let n = 0b101 // An integer formed from a binary, literal constant
let m = 0o17 // An integer formed from an octal, literal constant
let p = 0x2F // An integer formed from a hexadecimal, literal constant
Floating Points[edit]
Floating point numbers may be specified in decimal or in hexadecimal. Decimal numbers may have an optional exponent (indicated by e or E), which means that the base number is multiplied by .
let f = 1.23e5 // f is a Double of value 123,000
Hexadecimal numbers may also have an optional exponent (indicated by p or P), which means that the base number is multiplied by .
let g = 0xFp3 // g is a Double of value 120
Note that for literal constants, Swift will interpret the expression as a Double if any of the component expressions evaluate to a Double. ⚠ This does not apply to named constants.
Readability[edit]
Both integers and floating point numbers may have leading zeroes and embedded underscores for easier reading (by humans).
let oneBillion = 1_000_000_000
let tenBillion = 010_000_000_000
Key Concepts[edit]
Exercises[edit]
References[edit]
- Expressions (Wikipedia.org)
- Expressions (Swift.org)