|
|
| (12 intermediate revisions by one other user not shown) |
| Line 1: |
Line 1: |
| {{ComingSoon|Expressions}} | | {{MovedToMoodle|CS-151,Unit III,Chapters 6-7}} |
| [[File:The expression of the emotions in man and animals (1872) (14762147996).jpg|thumb|link=|The expression of the emotions in man and animals (1872)]]
| |
| == Prerequisites ==
| |
| * [[W1031 Positive Integers]]
| |
| * [[W1032 Negative Integers]]
| |
| * [[W1033 Character Encoding]]
| |
| * [[W1038 L-Values and R-Values]]
| |
| == Introduction ==
| |
| 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 ==
| |
| === Integers ===
| |
| All expressions, when evaluated, yield a particular '''type'''. For example, in the expression:
| |
| <syntaxhighlight lang="swift">
| |
| let x = 3
| |
| </syntaxhighlight>
| |
| ''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:
| |
| <syntaxhighlight lang="swift">
| |
| let y = 3.0
| |
| </syntaxhighlight>
| |
| ''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:
| |
| <syntaxhighlight lang="swift">
| |
| let x : Int = 3
| |
| </syntaxhighlight>
| |
| 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:
| |
| <syntaxhighlight lang="swift">
| |
| let maximumClassCount = 8
| |
| // maximumClassCount will be of type Int
| |
| | |
| let maximumGPA = 5.0
| |
| // maximumGPA will be of type Double
| |
| </syntaxhighlight>
| |
| In addition to decimal, literal integer expressions Swift will also infer the Int type from binary, octal, and hexadecimal:
| |
| <syntaxhighlight lang="swift">
| |
| 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
| |
| </syntaxhighlight>
| |
| {{Caution|
| |
| Regardless of the base used in an integer expression, the ultimate value is simply an integer.}}
| |
| === Floating Points ===
| |
| 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 <math>10^n</math>.
| |
| <syntaxhighlight lang="swift">
| |
| let f = 1.23e5 // f is a Double of value 123,000
| |
| </syntaxhighlight>
| |
| Hexadecimal numbers may also have an optional exponent (indicated by '''p''' or '''P'''), which means that the base number is multiplied by <math>2^n</math>.
| |
| <syntaxhighlight lang="swift">
| |
| let g = 0xFp3 // g is a Double of value 120
| |
| </syntaxhighlight>
| |
| | |
| == Key Concepts ==
| |
| == Exercises ==
| |
| == References ==
| |
| * [https://en.wikipedia.org/wiki/Expression_(mathematics) Expressions] (Wikipedia.org)
| |
| * [https://docs.swift.org/swift-book/ReferenceManual/Expressions.html Expressions] (Swift.org)
| |
