-
-
Notifications
You must be signed in to change notification settings - Fork 175
/
AboutAssignmentAndArithmetic.Koans.ps1
173 lines (137 loc) · 5.22 KB
/
AboutAssignmentAndArithmetic.Koans.ps1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
using module PSKoans
[Koan(Position = 106)]
param()
<#
Assignment and Arithmetic Operators
Just like many other programming languages, PowerShell has special operators designed to
work with data.
You can use the following command to get a full overview of how operators work:
Get-Help about_Operators
Loosely, operators fall into a few categories: assignment (=), arithmetic, comparison,
redirection, and string operators.
In terms of order of operations, arithmetic operators typically execute before
comparison operators, followed by string operators, redirection operators, and finally
assignment operators execute last.
#>
Describe 'Assignment Operator' {
It 'is used to assign a value to variables' {
$ExpectedValue = 1 + 1
$ActualValue = __
$ActualValue | Should -Be $ExpectedValue
}
It 'is also used to assign a value to properties or elements' {
# With arrays, we can assign values directly to indexes
$Array = 1, 2, 3
$Array[2] = 5
$Array | Should -Be @(1, 2, 3) # What would change?
}
}
Describe 'Arithmetic Operators' {
<#
These can be used for standard arithmetic with numerical values, as well as some limited
usage with arrays and strings that can come in handy.
#>
Context 'Addition' {
It 'is used to add two items together' {
13 + 4 | Should -Be 17
__ + 6 | Should -Be 13
13.7 + 4 | Should -Be __
}
It 'can be used to concatenate strings' {
'hello' + 'world' | Should -Be __
'My name is ' + 'Jim' | Should -Be 'My name is Jim'
}
It 'can be used to create arrays' {
<#
As we covered in AboutArrays, this is not so much 'adding' arrays together as it is
building a totally new array. It does, however, have its uses.
#>
$Array = 1, 2, 3, 4, 5
$NewArray = $Array + 7
# Match the input with what's actually in $NewArray!
1, 2, 3, 4, 5, 6, 7, 8 | Should -Be $NewArray
}
It 'behaves according to the type of the left-hand item' {
'10.5' + 11 | Should -Be 21.5 # Or should it?
11 + '12.5' | Should -Be __
12.21 + 'FILL_ME_IN' -eq 23.43 | Should -BeTrue
# Adding items into typed arrays will also cause the resulting value to be converted
[int[]]@(1, 2, 3, 4, 5) + '17' | Should -Be __
}
}
Context 'Subtraction' {
It 'works similarly to addition' {
12 - 7 | Should -Be 5
11 - 3.5 | Should -Be __
}
It 'cannot be used with strings' {
{'hello' - 'h'} | Should -Throw
# Except, of course, when the string contains a useable number.
'12' - '7.5' | Should -Be __
# In other words, subtraction only operates on numerical values.
{@(1, 2) - 1} | Should -Throw
}
}
Context 'Multiplication' {
It 'can be used on both integer and non-integer numerals' {
12 * 4 | Should -Be __
12.1 * 2 | Should -Be 24.2
}
It 'can also be used on strings' {
'A' * 4 -eq 'FILL_ME_IN' | Should -BeTrue
__ * 4 -eq 'NANANANA' | Should -BeTrue
}
}
Context 'Division' {
It 'is restricted to numeric use only' {
# As with subtraction, there's no useful meaning of using division on a string
# so any attempts to do so will throw an error.
{'hello!' / 3} | Should -Throw
# Unlike with other numerical operators, however, division often results
# in a non-integer (double) value even when both operands are integers.
3 / 4 | Should -Be 0.75
__ / 10 -eq 0.5 | Should -BeTrue
}
}
Context 'Modulus' {
# Modulus is a bit of an odd one, but common enough in programming. It performs a
# division, and then returns the integer value of the remainder.
It 'is usually used with integers' {
$Remainder = 15 % 7
__ | Should -Be $Remainder
}
It 'cannot be used on non-numeric values' {
{
$String = 'hello!'
$String % 4
} | Should -Throw -ExpectedMessage __
{
$Array = 1, 10, 20
$Array % 4
} | Should -Throw -ExpectedMessage __
}
}
}
Describe 'Assignment/Arithmetic Combination Operators' {
It 'can be used to simplify expressions' {
# With only assignment and arithmetic, some expressions can get a bit unwieldy
$Value = 5
$Value = $Value + 5
$Value | Should -Be 10
# We can combine the two to increment or decrement a variable!
$Value = 12
$Value += 7
$Value | Should -Be 19
$Value -= 3
$Value | Should -Be __
# We can even combine multiplication and division with assignment
$Value /= 2
$Value | Should -Be 8
$Value *= 3
$Value | Should -Be __
# Modulus hasn't been left out, either.
$Value = 12
$Value %= 4
$Value | Should -Be __
}
}