-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathBasic Operators.html
More file actions
1029 lines (850 loc) · 59.8 KB
/
Basic Operators.html
File metadata and controls
1029 lines (850 loc) · 59.8 KB
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
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<!DOCTYPE html>
<html lang="en"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>The Swift Programming Language: Basic Operators</title>
<link rel="stylesheet" type="text/css" href="resource/style-1.1.15.css">
<meta charset="utf-8"> <script>window["_GOOG_TRANS_EXT_VER"] = "1";</script></head>
<body id="conceptual_flow_with_tasks" class="jazz">
<div id="_omniture_top">
</div>
<a name="TP40014097" title="The Swift Programming Language"></a>
<section id="valence">
<div class="content-wrapper">
<p id="hierarchial_navigation">
<span id="book_title">The Swift Programming Language</span>
</p>
<img id="shortstack" src="./resource/shortstack_2x.png">
</div>
</section>
<div class="content-wrapper">
<nav class="book-parts hideInXcode" role="navigation">
<ul class="nav-parts">
<li data-id="TP40014097-CH1-XID_27" class="part-name">Welcome to Swift
<ul class="nav-chapters">
<li class="nav-chapter ">
<a href="About Swift.html#TP40014097-CH3-XID_0" data-id="TP40014097-CH3-XID_0" class="">About Swift</a>
</li>
<li class="nav-chapter">
<a href="A Swift Tour.html#TP40014097-CH2-XID_1" data-id="TP40014097-CH2-XID_1" class="">A Swift Tour</a>
</li>
</ul>
</li><li data-id="TP40014097-CH4-XID_299" class="part-name nav-part-active open-part">Language Guide
<ul class="nav-chapters" style="height: 607px;">
<li class="nav-chapter ">
<a href="The Basics.html" data-id="TP40014097-CH5-XID_399" >The Basics</a>
</li>
<li class="nav-chapter nav-visited-chapter">
<a href="Basic Operators.html#TP40014097-CH6-XID_70" data-id="TP40014097-CH6-XID_70" class="nav-chapter-active" >Basic Operators</a>
</li>
<li class="nav-chapter">
<a href="Strings and Characters.html#TP40014097-CH7-XID_368" data-id="TP40014097-CH7-XID_368">Strings and Characters</a>
</li>
<li class="nav-chapter">
<a href="Collection Types.html#TP40014097-CH8-XID_133" data-id="TP40014097-CH8-XID_133">Collection Types</a>
</li>
<li class="nav-chapter">
<a href="Control Flow.html#TP40014097-CH9-XID_153" data-id="TP40014097-CH9-XID_153">Control Flow</a>
</li>
<li class="nav-chapter">
<a href="Functions.html#TP40014097-CH10-XID_204" data-id="TP40014097-CH10-XID_204">Functions</a>
</li>
<li class="nav-chapter">
<a href="Closures.html#TP40014097-CH11-XID_117" data-id="TP40014097-CH11-XID_117">Closures</a>
</li>
<li class="nav-chapter">
<a href="Enumerations.html#TP40014097-CH12-XID_185" data-id="TP40014097-CH12-XID_185">Enumerations</a>
</li>
<li class="nav-chapter">
<a href="Classes and Structures.html#TP40014097-CH13-XID_94" data-id="TP40014097-CH13-XID_94">Classes and Structures</a>
</li>
<li class="nav-chapter">
<a href="Properties.html#TP40014097-CH14-XID_323" data-id="TP40014097-CH14-XID_323">Properties</a>
</li>
<li class="nav-chapter">
<a href="Methods.html#TP40014097-CH15-XID_300" data-id="TP40014097-CH15-XID_300">Methods</a>
</li>
<li class="nav-chapter">
<a href="Subscripts.html#TP40014097-CH16-XID_393" data-id="TP40014097-CH16-XID_393">Subscripts</a>
</li>
<li class="nav-chapter">
<a href="Inheritance.html#TP40014097-CH17-XID_251" data-id="TP40014097-CH17-XID_251">Inheritance</a>
</li>
<li class="nav-chapter">
<a href="Initialization.html#TP40014097-CH18-XID_266" data-id="TP40014097-CH18-XID_266">Initialization</a>
</li>
<li class="nav-chapter">
<a href="Deinitialization.html#TP40014097-CH19-XID_182" data-id="TP40014097-CH19-XID_182">Deinitialization</a>
</li>
<li class="nav-chapter">
<a href="Automatic Reference Counting.html#TP40014097-CH20-XID_50" data-id="TP40014097-CH20-XID_50">Automatic Reference Counting</a>
</li>
<li class="nav-chapter">
<a href="Optional Chaining.html#TP40014097-CH21-XID_312" data-id="TP40014097-CH21-XID_312">Optional Chaining</a>
</li>
<li class="nav-chapter">
<a href="Type Casting.html#TP40014097-CH22-XID_443" data-id="TP40014097-CH22-XID_443">Type Casting</a>
</li>
<li class="nav-chapter">
<a href="Nested Types.html#TP40014097-CH23-XID_309" data-id="TP40014097-CH23-XID_309">Nested Types</a>
</li>
<li class="nav-chapter">
<a href="Extensions.html#TP40014097-CH24-XID_191" data-id="TP40014097-CH24-XID_191">Extensions</a>
</li>
<li class="nav-chapter">
<a href="Protocols.html#TP40014097-CH25-XID_345" data-id="TP40014097-CH25-XID_345">Protocols</a>
</li>
<li class="nav-chapter">
<a href="Generics.html#TP40014097-CH26-XID_234" data-id="TP40014097-CH26-XID_234">Generics</a>
</li>
<li class="nav-chapter">
<a href="Advanced Operators.html#TP40014097-CH27-XID_28" data-id="TP40014097-CH27-XID_28">Advanced Operators</a>
</li>
</ul>
</li><li data-id="TP40014097-CH28-XID_912" class="part-name">Language Reference
<ul class="nav-chapters">
<li class="nav-chapter">
<a href="About the Language Reference.html#TP40014097-CH29-XID_453" data-id="TP40014097-CH29-XID_453" class="">About the Language Reference</a>
</li>
<li class="nav-chapter">
<a href="Lexical Structure.html#TP40014097-CH30-XID_794" data-id="TP40014097-CH30-XID_794">Lexical Structure</a>
</li>
<li class="nav-chapter">
<a href="Types.html#TP40014097-CH31-XID_988" data-id="TP40014097-CH31-XID_988">Types</a>
</li>
<li class="nav-chapter">
<a href="Expressions.html#TP40014097-CH32-XID_655" data-id="TP40014097-CH32-XID_655">Expressions</a>
</li>
<li class="nav-chapter">
<a href="Statements.html#TP40014097-CH33-XID_913" data-id="TP40014097-CH33-XID_913">Statements</a>
</li>
<li class="nav-chapter">
<a href="Declarations.html#TP40014097-CH34-XID_475" data-id="TP40014097-CH34-XID_475">Declarations</a>
</li>
<li class="nav-chapter">
<a href="Attributes.html#TP40014097-CH35-XID_460" data-id="TP40014097-CH35-XID_460">Attributes</a>
</li>
<li class="nav-chapter">
<a href="Patterns.html#TP40014097-CH36-XID_878" data-id="TP40014097-CH36-XID_878">Patterns</a>
</li>
<li class="nav-chapter">
<a href="Generic Parameters and Arguments.html#TP40014097-CH37-XID_774" data-id="TP40014097-CH37-XID_774">Generic Parameters and Arguments</a>
</li>
<li class="nav-chapter">
<a href="Summary of the Grammar.html#TP40014097-CH38-XID_1030" data-id="TP40014097-CH38-XID_1030">Summary of the Grammar</a>
</li>
</ul>
</li>
</ul>
</nav>
<article class="chapter">
<a name="TP40014097-CH6"></a><a name="TP40014097-CH6-XID_70"></a>
<div class="pixel-line"></div>
<h2 class="chapter-name chapter-name-short">Basic Operators</h2>
<section id="mini_toc" class="hideInXcode" role="navigation">
<div id="mini_toc_button">
<p>On This Page</p>
</div>
<ul class="list-bullet">
<li class="item">
<p class="para">
<a href="#TP40014097-CH6-XID_71">
Terminology
</a>
</p>
</li>
<li class="item">
<p class="para">
<a href="#TP40014097-CH6-XID_72">
Assignment Operator
</a>
</p>
</li>
<li class="item">
<p class="para">
<a href="#TP40014097-CH6-XID_73">
Arithmetic Operators
</a>
</p>
</li>
<li class="item">
<p class="para">
<a href="#TP40014097-CH6-XID_80">
Compound Assignment Operators
</a>
</p>
</li>
<li class="item">
<p class="para">
<a href="#TP40014097-CH6-XID_82">
Comparison Operators
</a>
</p>
</li>
<li class="item">
<p class="para">
<a href="#TP40014097-CH6-XID_84">
Ternary Conditional Operator
</a>
</p>
</li>
<li class="item">
<p class="para">
<a href="#TP40014097-CH6-XID_85">
Range Operators
</a>
</p>
</li>
<li class="item">
<p class="para">
<a href="#TP40014097-CH6-XID_88">
Logical Operators
</a>
</p>
</li>
</ul>
</section>
<section class="section">
<p class="para">
An <em>operator</em> is a special symbol or phrase that you use to check, change, or combine values. For example, the addition operator (<code class="code-voice">+</code>) adds two numbers together (as in <code class="code-voice">let i = 1 + 2</code>). More complex examples include the logical AND operator <code class="code-voice">&&</code> (as in <code class="code-voice">if enteredDoorCode && passedRetinaScan</code>) and the increment operator <code class="code-voice">++i</code>, which is a shortcut to increase the value of <code class="code-voice">i</code> by <code class="code-voice">1</code>.
</p>
<p class="para">
Swift supports most standard C operators and improves several capabilities to eliminate common coding errors. The assignment operator (<code class="code-voice">=</code>) does not return a value, to prevent it from being mistakenly used when the equal to operator (<code class="code-voice">==</code>) is intended. Arithmetic operators (<code class="code-voice">+</code>, <code class="code-voice">-</code>, <code class="code-voice">*</code>, <code class="code-voice">/</code>, <code class="code-voice">%</code> and so forth) detect and disallow value overflow, to avoid unexpected results when working with numbers that become larger or smaller than the allowed value range of the type that stores them. You can opt in to value overflow behavior by using Swift’s overflow operators, as described in <span class="x-name"><a href="Advanced Operators.html#TP40014097-CH27-XID_37" data-id="TP40014097-CH27-XID_37">Overflow Operators</a></span>.
</p>
<p class="para">
Unlike C, Swift lets you perform remainder (<code class="code-voice">%</code>) calculations on floating-point numbers. Swift also provides two range operators (<code class="code-voice">a..b</code> and <code class="code-voice">a...b</code>) not found in C, as a shortcut for expressing a range of values.
</p>
<p class="para">
This chapter describes the common operators in Swift. <span class="x-name"><a href="Advanced Operators.html#TP40014097-CH27-XID_28" data-id="TP40014097-CH27-XID_28">Advanced Operators</a></span> covers Swift’s advanced operators, and describes how to define your own custom operators and implement the standard operators for your own custom types.
</p>
</section>
<section class="section">
<a name="TP40014097-CH6-XID_71"></a>
<h3 class="section-name" tabindex="0">Terminology</h3>
<p class="para">
Operators are unary, binary, or ternary:
</p><ul class="list-bullet">
<li class="item"><p class="para">
<em>Unary</em> operators operate on a single target (such as <code class="code-voice">-a</code>). Unary <em>prefix</em> operators appear immediately before their target (such as <code class="code-voice">!b</code>), and unary <em>postfix</em> operators appear immediately after their target (such as <code class="code-voice">i++</code>).
</p>
</li><li class="item"><p class="para">
<em>Binary</em> operators operate on two targets (such as <code class="code-voice">2 + 3</code>) and are <em>infix</em> because they appear in between their two targets.
</p>
</li><li class="item"><p class="para">
<em>Ternary</em> operators operate on three targets. Like C, Swift has only one ternary operator, the ternary conditional operator (<code class="code-voice">a ? b : c</code>).
</p>
</li>
</ul><p class="para">
The values that operators affect are <em>operands</em>. In the expression <code class="code-voice">1 + 2</code>, the <code class="code-voice">+</code> symbol is a binary operator and its two operands are the values <code class="code-voice">1</code> and <code class="code-voice">2</code>.
</p>
</section>
<section class="section">
<a name="TP40014097-CH6-XID_72"></a>
<h3 class="section-name" tabindex="0">Assignment Operator</h3>
<p class="para">
The <em>assignment operator</em> (<code class="code-voice">a = b</code>) initializes or updates the value of <code class="code-voice">a</code> with the value of <code class="code-voice">b</code>:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">b</span> = <span class="m">10</span></code></li>
<li><code class="code-voice"><span class="kt">var</span> <span class="vc">a</span> = <span class="m">5</span></code></li>
<li><code class="code-voice"><span class="vc">a</span> = <span class="vc">b</span></code></li>
<li><code class="code-voice"><span class="c">// a is now equal to 10</span></code></li>
</ul>
</div>
</section><p class="para">
If the right side of the assignment is a tuple with multiple values, its elements can be decomposed into multiple constants or variables at once:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">let</span> (<span class="vc">x</span>, <span class="vc">y</span>) = (<span class="m">1</span>, <span class="m">2</span>)</code></li>
<li><code class="code-voice"><span class="c">// x is equal to 1, and y is equal to 2</span></code></li>
</ul>
</div>
</section><p class="para">
Unlike the assignment operator in C and Objective-C, the assignment operator in Swift does not itself return a value. The following statement is not valid:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">if</span> <span class="vc">x</span> = <span class="vc">y</span> {</code></li>
<li><code class="code-voice"> <span class="c">// this is not valid, because x = y does not return a value</span></code></li>
<li><code class="code-voice">}</code></li>
</ul>
</div>
</section><p class="para">
This feature prevents the assignment operator (<code class="code-voice">=</code>) from being used by accident when the equal to operator (<code class="code-voice">==</code>) is actually intended. By making <code class="code-voice">if x = y</code> invalid, Swift helps you to avoid these kinds of errors in your code.
</p>
</section>
<section class="section">
<a name="TP40014097-CH6-XID_73"></a>
<h3 class="section-name" tabindex="0">Arithmetic Operators</h3>
<p class="para">
Swift supports the four standard <em>arithmetic operators</em> for all number types:
</p><ul class="list-bullet">
<li class="item"><p class="para">
Addition (<code class="code-voice">+</code>)
</p>
</li><li class="item"><p class="para">
Subtraction (<code class="code-voice">-</code>)
</p>
</li><li class="item"><p class="para">
Multiplication (<code class="code-voice">*</code>)
</p>
</li><li class="item"><p class="para">
Division (<code class="code-voice">/</code>)
</p>
</li>
</ul><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="m">1</span> + <span class="m">2</span> <span class="c">// equals 3</span></code></li>
<li><code class="code-voice"><span class="m">5</span> - <span class="m">3</span> <span class="c">// equals 2</span></code></li>
<li><code class="code-voice"><span class="m">2</span> * <span class="m">3</span> <span class="c">// equals 6</span></code></li>
<li><code class="code-voice"><span class="m">10.0</span> / <span class="m">2.5</span> <span class="c">// equals 4.0</span></code></li>
</ul>
</div>
</section><p class="para">
Unlike the arithmetic operators in C and Objective-C, the Swift arithmetic operators do not allow values to overflow by default. You can opt in to value overflow behavior by using Swift’s overflow operators (such as <code class="code-voice">a &+ b</code>). See <span class="x-name"><a href="Advanced Operators.html#TP40014097-CH27-XID_37" data-id="TP40014097-CH27-XID_37">Overflow Operators</a></span>.
</p><p class="para">
The addition operator is also supported for <code class="code-voice">String</code> concatenation:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="s">"hello, "</span> + <span class="s">"world"</span> <span class="c">// equals "hello, world"</span></code></li>
</ul>
</div>
</section><p class="para">
Two <code class="code-voice">Character</code> values, or one <code class="code-voice">Character</code> value and one <code class="code-voice">String</code> value, can be added together to make a new <code class="code-voice">String</code> value:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">dog</span>: <span class="n"></span> = <span class="s">"🐶"</span></code></li>
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">cow</span>: <span class="n"></span> = <span class="s">"🐮"</span></code></li>
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">dogCow</span> = <span class="vc">dog</span> + <span class="vc">cow</span></code></li>
<li><code class="code-voice"><span class="c">// dogCow is equal to "🐶🐮"</span></code></li>
</ul>
</div>
</section><p class="para">
See also <span class="x-name"><a href="Strings and Characters.html#TP40014097-CH7-XID_379" data-id="TP40014097-CH7-XID_379"></a></span>.
</p>
<section class="section">
<a name="TP40014097-CH6-XID_74"></a>
<h3 class="section-name" tabindex="0">Remainder Operator</h3>
<p class="para">
The <em>remainder operator</em> (<code class="code-voice">a % b</code>) works out how many multiples of <code class="code-voice">b</code> will fit inside <code class="code-voice">a</code> and returns the value that is left over (known as the <em>remainder</em>).
</p><div class="note">
<a name="TP40014097-CH6-XID_75"></a>
<aside class="aside">
<p class="aside-title">Note
</p>
<p class="para">The remainder operator (<code class="code-voice">%</code>) is also known as a <em>modulo operator</em> in other languages. However, its behavior in Swift for negative numbers means that it is, strictly speaking, a remainder rather than a modulo operation.
</p>
</aside>
</div><p class="para">
Here’s how the remainder operator works. To calculate <code class="code-voice">9 % 4</code>, you first work out how many <code class="code-voice">4</code>s will fit inside <code class="code-voice">9</code>:
</p><figure class="figure">
<span class="caption"></span>
<img src="./resource/remainderInteger_2x.png" alt="image: ../Art/remainderInteger_2x.png" width="337" height="66">
</figure><p class="para">
You can fit two <code class="code-voice">4</code>s inside <code class="code-voice">9</code>, and the remainder is <code class="code-voice">1</code> (shown in orange).
</p><p class="para">
In Swift, this would be written as:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="m">9</span> % <span class="m">4</span> <span class="c">// equals 1</span></code></li>
</ul>
</div>
</section><p class="para">
To determine the answer for <code class="code-voice">a % b</code>, the <code class="code-voice">%</code> operator calculates the following equation and returns <code class="code-voice">remainder</code> as its output:
</p><p class="para">
<code class="code-voice">a</code> = (<code class="code-voice">b</code> × <code class="code-voice">some multiplier</code>) + <code class="code-voice">remainder</code>
</p><p class="para">
where <code class="code-voice">some multiplier</code> is the largest number of multiples of <code class="code-voice">b</code> that will fit inside <code class="code-voice">a</code>.
</p><p class="para">
Inserting <code class="code-voice">9</code> and <code class="code-voice">4</code> into this equation yields:
</p><p class="para">
<code class="code-voice">9</code> = (<code class="code-voice">4</code> × <code class="code-voice">2</code>) + <code class="code-voice">1</code>
</p><p class="para">
The same method is applied when calculating the remainder for a negative value of <code class="code-voice">a</code>:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice">-<span class="m">9</span> % <span class="m">4</span> <span class="c">// equals -1</span></code></li>
</ul>
</div>
</section><p class="para">
Inserting <code class="code-voice">-9</code> and <code class="code-voice">4</code> into the equation yields:
</p><p class="para">
<code class="code-voice">-9</code> = (<code class="code-voice">4</code> × <code class="code-voice">-2</code>) + <code class="code-voice">-1</code>
</p><p class="para">
giving a remainder value of <code class="code-voice">-1</code>.
</p><p class="para">
The sign of <code class="code-voice">b</code> is ignored for negative values of <code class="code-voice">b</code>. This means that <code class="code-voice">a % b</code> and <code class="code-voice">a % -b</code> always give the same answer.
</p>
</section>
<section class="section">
<a name="TP40014097-CH6-XID_76"></a>
<h3 class="section-name" tabindex="0">Floating-Point Remainder Calculations</h3>
<p class="para">
Unlike the remainder operator in C and Objective-C, Swift’s remainder operator can also operate on floating-point numbers:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="m">8</span> % <span class="m">2.5</span> <span class="c">// equals 0.5</span></code></li>
</ul>
</div>
</section><p class="para">
In this example, <code class="code-voice">8</code> divided by <code class="code-voice">2.5</code> equals <code class="code-voice">3</code>, with a remainder of <code class="code-voice">0.5</code>, so the remainder operator returns a <code class="code-voice">Double</code> value of <code class="code-voice">0.5</code>.
</p><figure class="figure">
<span class="caption"></span>
<img src="./resource/remainderFloat_2x.png" alt="image: ../Art/remainderFloat_2x.png" width="301" height="66">
</figure>
</section>
<section class="section">
<a name="TP40014097-CH6-XID_77"></a>
<h3 class="section-name" tabindex="0">Increment and Decrement Operators</h3>
<p class="para">
Like C, Swift provides an <em>increment operator</em> (<code class="code-voice">++</code>) and a <em>decrement operator</em> (<code class="code-voice">--</code>) as a shortcut to increase or decrease the value of a numeric variable by <code class="code-voice">1</code>. You can use these operators with variables of any integer or floating-point type.
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">var</span> <span class="vc">i</span> = <span class="m">0</span></code></li>
<li><code class="code-voice">++<span class="vc">i</span> <span class="c">// i now equals 1</span></code></li>
</ul>
</div>
</section><p class="para">
Each time you call <code class="code-voice">++i</code>, the value of <code class="code-voice">i</code> is increased by <code class="code-voice">1</code>. Essentially, <code class="code-voice">++i</code> is shorthand for saying <code class="code-voice">i = i + 1</code>. Likewise, <code class="code-voice">--i</code> can be used as shorthand for <code class="code-voice">i = i - 1</code>.
</p><p class="para">
The <code class="code-voice">++</code> and <code class="code-voice">--</code> symbols can be used as prefix operators or as postfix operators. <code class="code-voice">++i</code> and <code class="code-voice">i++</code> are both valid ways to increase the value of <code class="code-voice">i</code> by <code class="code-voice">1</code>. Similarly, <code class="code-voice">--i</code> and <code class="code-voice">i--</code> are both valid ways to decrease the value of <code class="code-voice">i</code> by <code class="code-voice">1</code>.
</p><p class="para">
Note that these operators modify <code class="code-voice">i</code> and also return a value. If you only want to increment or decrement the value stored in <code class="code-voice">i</code>, you can ignore the returned value. However, if you <em>do</em> use the returned value, it will be different based on whether you used the prefix or postfix version of the operator, according to the following rules:
</p><ul class="list-bullet">
<li class="item"><p class="para">
If the operator is written <em>before</em> the variable, it increments the variable <em>before</em> returning its value.
</p>
</li><li class="item"><p class="para">
If the operator is written <em>after</em> the variable, it increments the variable <em>after</em> returning its value.
</p>
</li>
</ul><p class="para">
For example:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">var</span> <span class="vc">a</span> = <span class="m">0</span></code></li>
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">b</span> = ++<span class="vc">a</span></code></li>
<li><code class="code-voice"><span class="c">// a and b are now both equal to 1</span></code></li>
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">c</span> = <span class="vc">a</span>++</code></li>
<li><code class="code-voice"><span class="c">// a is now equal to 2, but c has been set to the pre-increment value of 1</span></code></li>
</ul>
</div>
</section><p class="para">
In the example above, <code class="code-voice">let b = ++a</code> increments <code class="code-voice">a</code> <em>before</em> returning its value. This is why both <code class="code-voice">a</code> and <code class="code-voice">b</code> are equal to to the new value of <code class="code-voice">1</code>.
</p><p class="para">
However, <code class="code-voice">let c = a++</code> increments <code class="code-voice">a</code> <em>after</em> returning its value. This means that <code class="code-voice">c</code> gets the old value of <code class="code-voice">1</code>, and <code class="code-voice">a</code> is then updated to equal <code class="code-voice">2</code>.
</p><p class="para">
Unless you need the specific behavior of <code class="code-voice">i++</code>, it is recommended that you use <code class="code-voice">++i</code> and <code class="code-voice">--i</code> in all cases, because they have the typical expected behavior of modifying <code class="code-voice">i</code> and returning the result.
</p>
</section>
<section class="section">
<a name="TP40014097-CH6-XID_78"></a>
<h3 class="section-name" tabindex="0">Unary Minus Operator</h3>
<p class="para">
The sign of a numeric value can be toggled using a prefixed <code class="code-voice">-</code>, known as the <em>unary minus operator</em>:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">three</span> = <span class="m">3</span></code></li>
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">minusThree</span> = -<span class="vc">three</span> <span class="c">// minusThree equals -3</span></code></li>
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">plusThree</span> = -<span class="vc">minusThree</span> <span class="c">// plusThree equals 3, or "minus minus three"</span></code></li>
</ul>
</div>
</section><p class="para">
The unary minus operator (<code class="code-voice">-</code>) is prepended directly before the value it operates on, without any white space.
</p>
</section>
<section class="section">
<a name="TP40014097-CH6-XID_79"></a>
<h3 class="section-name" tabindex="0">Unary Plus Operator</h3>
<p class="para">
The <em>unary plus operator</em> (<code class="code-voice">+</code>) simply returns the value it operates on, without any change:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">minusSix</span> = -<span class="m">6</span></code></li>
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">alsoMinusSix</span> = +<span class="vc">minusSix</span> <span class="c">// alsoMinusSix equals -6</span></code></li>
</ul>
</div>
</section><p class="para">
Although the unary plus operator doesn’t actually do anything, you can use it to provide symmetry in your code for positive numbers when also using the unary minus operator for negative numbers.
</p>
</section>
</section>
<section class="section">
<a name="TP40014097-CH6-XID_80"></a>
<h3 class="section-name" tabindex="0">Compound Assignment Operators</h3>
<p class="para">
Like C, Swift provides <em>compound assignment operators</em> that combine assignment (<code class="code-voice">=</code>) with another operation. One example is the <em>addition assignment operator</em> (<code class="code-voice">+=</code>):
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">var</span> <span class="vc">a</span> = <span class="m">1</span></code></li>
<li><code class="code-voice"><span class="vc">a</span> += <span class="m">2</span></code></li>
<li><code class="code-voice"><span class="c">// a is now equal to 3</span></code></li>
</ul>
</div>
</section><p class="para">
The expression <code class="code-voice">a += 2</code> is shorthand for <code class="code-voice">a = a + 2</code>. Effectively, the addition and the assignment are combined into one operator that performs both tasks at the same time.
</p><div class="note">
<a name="TP40014097-CH6-XID_81"></a>
<aside class="aside">
<p class="aside-title">Note
</p>
<p class="para">The compound assignment operators do not return a value. You cannot write <code class="code-voice">let b = a += 2</code>, for example. This behavior is different from the increment and decrement operators mentioned above.
</p>
</aside>
</div><p class="para">
A complete list of compound assignment operators can be found in <span class="x-name"><a href="Expressions.html#TP40014097-CH32-XID_655" data-id="TP40014097-CH32-XID_655">Expressions</a></span>.
</p>
</section>
<section class="section">
<a name="TP40014097-CH6-XID_82"></a>
<h3 class="section-name" tabindex="0">Comparison Operators</h3>
<p class="para">
Swift supports all standard C <em>comparison operators</em>:
</p><ul class="list-bullet">
<li class="item"><p class="para">
Equal to (<code class="code-voice">a == b</code>)
</p>
</li><li class="item"><p class="para">
Not equal to (<code class="code-voice">a != b</code>)
</p>
</li><li class="item"><p class="para">
Greater than (<code class="code-voice">a > b</code>)
</p>
</li><li class="item"><p class="para">
Less than (<code class="code-voice">a < b</code>)
</p>
</li><li class="item"><p class="para">
Greater than or equal to (<code class="code-voice">a >= b</code>)
</p>
</li><li class="item"><p class="para">
Less than or equal to (<code class="code-voice">a <= b</code>)
</p>
</li>
</ul><div class="note">
<a name="TP40014097-CH6-XID_83"></a>
<aside class="aside">
<p class="aside-title">Note
</p>
<p class="para">Swift also provides two <em>identity operators</em> (<code class="code-voice">===</code> and <code class="code-voice">!==</code>), which you use to test whether two object references both refer to the same object instance. For more information, see <span class="x-name"><a href="Classes and Structures.html#TP40014097-CH13-XID_94" data-id="TP40014097-CH13-XID_94">Classes and Structures</a></span>.
</p>
</aside>
</div><p class="para">
Each of the comparison operators returns a <code class="code-voice">Bool</code> value to indicate whether or not the statement is true:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="m">1</span> == <span class="m">1</span> <span class="c">// true, because 1 is equal to 1</span></code></li>
<li><code class="code-voice"><span class="m">2</span> != <span class="m">1</span> <span class="c">// true, because 2 is not equal to 1</span></code></li>
<li><code class="code-voice"><span class="m">2</span> > <span class="m">1</span> <span class="c">// true, because 2 is greater than 1</span></code></li>
<li><code class="code-voice"><span class="m">1</span> < <span class="m">2</span> <span class="c">// true, because 1 is less than 2</span></code></li>
<li><code class="code-voice"><span class="m">1</span> >= <span class="m">1</span> <span class="c">// true, because 1 is greater than or equal to 1</span></code></li>
<li><code class="code-voice"><span class="m">2</span> <= <span class="m">1</span> <span class="c">// false, because 2 is not less than or equal to 1</span></code></li>
</ul>
</div>
</section><p class="para">
Comparison operators are often used in conditional statements, such as the <code class="code-voice">if</code> statement:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">name</span> = <span class="s">"world"</span></code></li>
<li><code class="code-voice"><span class="kt">if</span> <span class="vc">name</span> == <span class="s">"world"</span> {</code></li>
<li><code class="code-voice"> <span class="vc">println</span>(<span class="s">"hello, world"</span>)</code></li>
<li><code class="code-voice">} <span class="kt">else</span> {</code></li>
<li><code class="code-voice"> <span class="vc">println</span>(<span class="s">"I'm sorry </span>\(<span class="vc">name</span>)<span class="s">, but I don't recognize you"</span>)</code></li>
<li><code class="code-voice">}</code></li>
<li><code class="code-voice"><span class="c">// prints "hello, world", because name is indeed equal to "world"</span></code></li>
</ul>
</div>
</section><p class="para">
For more on the <code class="code-voice">if</code> statement, see <span class="x-name"><a href="Control Flow.html#TP40014097-CH9-XID_153" data-id="TP40014097-CH9-XID_153">Control Flow</a></span>.
</p>
</section>
<section class="section">
<a name="TP40014097-CH6-XID_84"></a>
<h3 class="section-name" tabindex="0">Ternary Conditional Operator</h3>
<p class="para">
The <em>ternary conditional operator</em> is a special operator with three parts, which takes the form <code class="code-voice">question ? answer1 : answer2</code>. It is a shortcut for evaluating one of two expressions based on whether <code class="code-voice">question</code> is true or false. If <code class="code-voice">question</code> is true, it evaluates <code class="code-voice">answer1</code> and returns its value; otherwise, it evaluates <code class="code-voice">answer2</code> and returns its value.
</p><p class="para">
The ternary conditional operator is shorthand for the code below:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">if</span> <span class="vc">question</span> {</code></li>
<li><code class="code-voice"> <span class="vc">answer1</span></code></li>
<li><code class="code-voice">} <span class="kt">else</span> {</code></li>
<li><code class="code-voice"> <span class="vc">answer2</span></code></li>
<li><code class="code-voice">}</code></li>
</ul>
</div>
</section><p class="para">
Here’s an example, which calculates the pixel height for a table row. The row height should be 50 pixels taller than the content height if the row has a header, and 20 pixels taller if the row doesn’t have a header:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">contentHeight</span> = <span class="m">40</span></code></li>
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">hasHeader</span> = <span class="vc">true</span></code></li>
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">rowHeight</span> = <span class="vc">contentHeight</span> + (<span class="vc">hasHeader</span> ? <span class="m">50</span> : <span class="m">20</span>)</code></li>
<li><code class="code-voice"><span class="c">// rowHeight is equal to 90</span></code></li>
</ul>
</div>
</section><p class="para">
The preceding example is shorthand for the code below:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">contentHeight</span> = <span class="m">40</span></code></li>
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">hasHeader</span> = <span class="vc">true</span></code></li>
<li><code class="code-voice"><span class="kt">var</span> <span class="vc">rowHeight</span> = <span class="vc">contentHeight</span></code></li>
<li><code class="code-voice"><span class="kt">if</span> <span class="vc">hasHeader</span> {</code></li>
<li><code class="code-voice"> <span class="vc">rowHeight</span> = <span class="vc">rowHeight</span> + <span class="m">50</span></code></li>
<li><code class="code-voice">} <span class="kt">else</span> {</code></li>
<li><code class="code-voice"> <span class="vc">rowHeight</span> = <span class="vc">rowHeight</span> + <span class="m">20</span></code></li>
<li><code class="code-voice">}</code></li>
<li><code class="code-voice"><span class="c">// rowHeight is equal to 90</span></code></li>
</ul>
</div>
</section><p class="para">
The first example’s use of the ternary conditional operator means that <code class="code-voice">rowHeight</code> can be set to the correct value on a single line of code. This is more concise than the second example, and removes the need for <code class="code-voice">rowHeight</code> to be a variable, because its value does not need to be modified within an <code class="code-voice">if</code> statement.
</p><p class="para">
The ternary conditional operator provides an efficient shorthand for deciding which of two expressions to consider. Use the ternary conditional operator with care, however. Its conciseness can lead to hard-to-read code if overused. Avoid combining multiple instances of the ternary conditional operator into one compound statement.
</p>
</section>
<section class="section">
<a name="TP40014097-CH6-XID_85"></a>
<h3 class="section-name" tabindex="0">Range Operators</h3>
<p class="para">
Swift includes two <em>range operators</em>, which are shortcuts for expressing a range of values.
</p>
<section class="section">
<a name="TP40014097-CH6-XID_86"></a>
<h3 class="section-name" tabindex="0">Closed Range Operator</h3>
<p class="para">
The <em>closed range operator</em> (<code class="code-voice">a...b</code>) defines a range that runs from <code class="code-voice">a</code> to <code class="code-voice">b</code>, and includes the values <code class="code-voice">a</code> and <code class="code-voice">b</code>.
</p><p class="para">
The closed range operator is useful when iterating over a range in which you want all of the values to be used, such as with a <code class="code-voice">for</code>-<code class="code-voice">in</code> loop:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">for</span> <span class="vc">index</span> <span class="kt">in</span> <span class="m">1</span>...<span class="m">5</span> {</code></li>
<li><code class="code-voice"> <span class="vc">println</span>(<span class="s">"</span>\(<span class="vc">index</span>)<span class="s"> times 5 is </span>\(<span class="vc">index</span> * <span class="m">5</span>)<span class="s">"</span>)</code></li>
<li><code class="code-voice">}</code></li>
<li><code class="code-voice"><span class="c">// 1 times 5 is 5</span></code></li>
<li><code class="code-voice"><span class="c">// 2 times 5 is 10</span></code></li>
<li><code class="code-voice"><span class="c">// 3 times 5 is 15</span></code></li>
<li><code class="code-voice"><span class="c">// 4 times 5 is 20</span></code></li>
<li><code class="code-voice"><span class="c">// 5 times 5 is 25</span></code></li>
</ul>
</div>
</section><p class="para">
For more on <code class="code-voice">for</code>-<code class="code-voice">in</code> loops, see <span class="x-name"><a href="Control Flow.html#TP40014097-CH9-XID_153" data-id="TP40014097-CH9-XID_153">Control Flow</a></span>.
</p>
</section>
<section class="section">
<a name="TP40014097-CH6-XID_87"></a>
<h3 class="section-name" tabindex="0">Half-Closed Range Operator</h3>
<p class="para">
The <em>half-closed range operator</em> (<code class="code-voice">a..b</code>) defines a range that runs from <code class="code-voice">a</code> to <code class="code-voice">b</code>, but does not include <code class="code-voice">b</code>. It is said to be <em>half-closed</em> because it contains its first value, but not its final value.
</p><p class="para">
Half-closed ranges are particularly useful when you work with zero-based lists such as arrays, where it is useful to count up to (but not including) the length of the list:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">names</span> = [<span class="s">"Anna"</span>, <span class="s">"Alex"</span>, <span class="s">"Brian"</span>, <span class="s">"Jack"</span>]</code></li>
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">count</span> = <span class="vc">names</span>.<span class="vc">count</span></code></li>
<li><code class="code-voice"><span class="kt">for</span> <span class="vc">i</span> <span class="kt">in</span> <span class="m">0</span>..<span class="vc">count</span> {</code></li>
<li><code class="code-voice"> <span class="vc">println</span>(<span class="s">"Person </span>\(<span class="vc">i</span> + <span class="m">1</span>)<span class="s"> is called </span>\(<span class="vc">names</span>[<span class="vc">i</span>])<span class="s">"</span>)</code></li>
<li><code class="code-voice">}</code></li>
<li><code class="code-voice"><span class="c">// Person 1 is called Anna</span></code></li>
<li><code class="code-voice"><span class="c">// Person 2 is called Alex</span></code></li>
<li><code class="code-voice"><span class="c">// Person 3 is called Brian</span></code></li>
<li><code class="code-voice"><span class="c">// Person 4 is called Jack</span></code></li>
</ul>
</div>
</section><p class="para">
Note that the array contains four items, but <code class="code-voice">0..count</code> only counts as far as <code class="code-voice">3</code> (the index of the last item in the array), because it is a half-closed range. For more on arrays, see <span class="x-name"><a href="Collection Types.html#TP40014097-CH8-XID_135" data-id="TP40014097-CH8-XID_135">Arrays</a></span>.
</p>
</section>
</section>
<section class="section">
<a name="TP40014097-CH6-XID_88"></a>
<h3 class="section-name" tabindex="0">Logical Operators</h3>
<p class="para">
<em>Logical operators</em> modify or combine the Boolean logic values <code class="code-voice">true</code> and <code class="code-voice">false</code>. Swift supports the three standard logical operators found in C-based languages:
</p><ul class="list-bullet">
<li class="item"><p class="para">
Logical NOT (<code class="code-voice">!a</code>)
</p>
</li><li class="item"><p class="para">
Logical AND (<code class="code-voice">a && b</code>)
</p>
</li><li class="item"><p class="para">
Logical OR (<code class="code-voice">a || b</code>)
</p>
</li>
</ul>
<section class="section">
<a name="TP40014097-CH6-XID_89"></a>
<h3 class="section-name" tabindex="0">Logical NOT Operator</h3>
<p class="para">
The <em>logical NOT operator</em> (<code class="code-voice">!a</code>) inverts a Boolean value so that <code class="code-voice">true</code> becomes <code class="code-voice">false</code>, and <code class="code-voice">false</code> becomes <code class="code-voice">true</code>.
</p><p class="para">
The logical NOT operator is a prefix operator, and appears immediately before the value it operates on, without any white space. It can be read as “not <code class="code-voice">a</code>”, as seen in the following example:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">allowedEntry</span> = <span class="vc">false</span></code></li>
<li><code class="code-voice"><span class="kt">if</span> !<span class="vc">allowedEntry</span> {</code></li>
<li><code class="code-voice"> <span class="vc">println</span>(<span class="s">"ACCESS DENIED"</span>)</code></li>
<li><code class="code-voice">}</code></li>
<li><code class="code-voice"><span class="c">// prints "ACCESS DENIED"</span></code></li>
</ul>
</div>
</section><p class="para">
The phrase <code class="code-voice">if !allowedEntry</code> can be read as “if not allowed entry.” The subsequent line is only executed if “not allowed entry” is true; that is, if <code class="code-voice">allowedEntry</code> is <code class="code-voice">false</code>.
</p><p class="para">
As in this example, careful choice of Boolean constant and variable names can help to keep code readable and concise, while avoiding double negatives or confusing logic statements.
</p>
</section>
<section class="section">
<a name="TP40014097-CH6-XID_90"></a>
<h3 class="section-name" tabindex="0">Logical AND Operator</h3>
<p class="para">
The <em>logical AND operator</em> (<code class="code-voice">a && b</code>) creates logical expressions where both values must be <code class="code-voice">true</code> for the overall expression to also be <code class="code-voice">true</code>.
</p><p class="para">
If either value is <code class="code-voice">false</code>, the overall expression will also be <code class="code-voice">false</code>. In fact, if the <em>first</em> value is <code class="code-voice">false</code>, the second value won’t even be evaluated, because it can’t possibly make the overall expression equate to <code class="code-voice">true</code>. This is known as <em>short-circuit evaluation</em>.
</p><p class="para">
This example considers two <code class="code-voice">Bool</code> values and only allows access if both values are <code class="code-voice">true</code>:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">enteredDoorCode</span> = <span class="vc">true</span></code></li>
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">passedRetinaScan</span> = <span class="vc">false</span></code></li>
<li><code class="code-voice"><span class="kt">if</span> <span class="vc">enteredDoorCode</span> && <span class="vc">passedRetinaScan</span> {</code></li>
<li><code class="code-voice"> <span class="vc">println</span>(<span class="s">"Welcome!"</span>)</code></li>
<li><code class="code-voice">} <span class="kt">else</span> {</code></li>
<li><code class="code-voice"> <span class="vc">println</span>(<span class="s">"ACCESS DENIED"</span>)</code></li>
<li><code class="code-voice">}</code></li>
<li><code class="code-voice"><span class="c">// prints "ACCESS DENIED"</span></code></li>
</ul>
</div>
</section>
</section>
<section class="section">
<a name="TP40014097-CH6-XID_91"></a>
<h3 class="section-name" tabindex="0">Logical OR Operator</h3>
<p class="para">
The <em>logical OR operator</em> (<code class="code-voice">a || b</code>) is an infix operator made from two adjacent pipe characters. You use it to create logical expressions in which only <em>one</em> of the two values has to be <code class="code-voice">true</code> for the overall expression to be <code class="code-voice">true</code>.
</p><p class="para">
Like the Logical AND operator above, the Logical OR operator uses short-circuit evaluation to consider its expressions. If the left side of a Logical OR expression is <code class="code-voice">true</code>, the right side is not evaluated, because it cannot change the outcome of the overall expression.
</p><p class="para">
In the example below, the first <code class="code-voice">Bool</code> value (<code class="code-voice">hasDoorKey</code>) is <code class="code-voice">false</code>, but the second value (<code class="code-voice">knowsOverridePassword</code>) is <code class="code-voice">true</code>. Because one value is <code class="code-voice">true</code>, the overall expression also evaluates to <code class="code-voice">true</code>, and access is allowed:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">hasDoorKey</span> = <span class="vc">false</span></code></li>
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">knowsOverridePassword</span> = <span class="vc">true</span></code></li>
<li><code class="code-voice"><span class="kt">if</span> <span class="vc">hasDoorKey</span> || <span class="vc">knowsOverridePassword</span> {</code></li>
<li><code class="code-voice"> <span class="vc">println</span>(<span class="s">"Welcome!"</span>)</code></li>
<li><code class="code-voice">} <span class="kt">else</span> {</code></li>
<li><code class="code-voice"> <span class="vc">println</span>(<span class="s">"ACCESS DENIED"</span>)</code></li>
<li><code class="code-voice">}</code></li>
<li><code class="code-voice"><span class="c">// prints "Welcome!"</span></code></li>
</ul>
</div>
</section>
</section>
<section class="section">
<a name="TP40014097-CH6-XID_92"></a>
<h3 class="section-name" tabindex="0">Combining Logical Operators</h3>
<p class="para">
You can combine multiple logical operators to create longer compound expressions:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">if</span> <span class="vc">enteredDoorCode</span> && <span class="vc">passedRetinaScan</span> || <span class="vc">hasDoorKey</span> || <span class="vc">knowsOverridePassword</span> {</code></li>
<li><code class="code-voice"> <span class="vc">println</span>(<span class="s">"Welcome!"</span>)</code></li>
<li><code class="code-voice">} <span class="kt">else</span> {</code></li>
<li><code class="code-voice"> <span class="vc">println</span>(<span class="s">"ACCESS DENIED"</span>)</code></li>
<li><code class="code-voice">}</code></li>
<li><code class="code-voice"><span class="c">// prints "Welcome!"</span></code></li>
</ul>
</div>
</section><p class="para">
This example uses multiple <code class="code-voice">&&</code> and <code class="code-voice">||</code> operators to create a longer compound expression. However, the <code class="code-voice">&&</code> and <code class="code-voice">||</code> operators still operate on only two values, so this is actually three smaller expressions chained together. It can be read as:
</p><p class="para">
If we’ve entered the correct door code and passed the retina scan; or if we have a valid door key; or if we know the emergency override password, then allow access.
</p><p class="para">
Based on the values of <code class="code-voice">enteredDoorCode</code>, <code class="code-voice">passedRetinaScan</code>, and <code class="code-voice">hasDoorKey</code>, the first two mini-expressions are <code class="code-voice">false</code>. However, the emergency override password is known, so the overall compound expression still evaluates to <code class="code-voice">true</code>.
</p>
</section>
<section class="section">
<a name="TP40014097-CH6-XID_93"></a>
<h3 class="section-name" tabindex="0">Explicit Parentheses</h3>
<p class="para">
It is sometimes useful to include parentheses when they are not strictly needed, to make the intention of a complex expression easier to read. In the door access example above, it is useful to add parentheses around the first part of the compound expression to make its intent explicit:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">if</span> (<span class="vc">enteredDoorCode</span> && <span class="vc">passedRetinaScan</span>) || <span class="vc">hasDoorKey</span> || <span class="vc">knowsOverridePassword</span> {</code></li>
<li><code class="code-voice"> <span class="vc">println</span>(<span class="s">"Welcome!"</span>)</code></li>
<li><code class="code-voice">} <span class="kt">else</span> {</code></li>
<li><code class="code-voice"> <span class="vc">println</span>(<span class="s">"ACCESS DENIED"</span>)</code></li>
<li><code class="code-voice">}</code></li>
<li><code class="code-voice"><span class="c">// prints "Welcome!"</span></code></li>