andre/the-swift-programming-language-in-chinese
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

make gitbook

Browse Source
This commit is contained in:
numbbbbb
2014-06-14 23:24:20 +08:00
parent a0489eef96
commit 4634005f9c
42 changed files with 981 additions and 1046 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
chapter3/01_About_the_Language_Reference.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="3.1" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="3.1" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,11 +587,10 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_83">
<section class="normal" id="section-gitbook_559">
<blockquote>
<p>翻译：ChildhoodAndy</p>
<p>校对：numbbbbb</p>
<p>翻译：ChildhoodAndy<br>校对：numbbbbb</p>
</blockquote>
<h1 id="-">关于语言附注</h1>
<hr>
@ -614,14 +613,11 @@
</ul>
<p>举个例子，getter-setter的语法块的定义如下：</p>
<blockquote>
<p>GRAMMAR OF A GETTER-SETTER BLOCK</p>
<p><em>getter-setter-block</em> → {­ <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-clause" target="_blank"><em>getter-clause</em></a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-clause" target="_blank">­<em>setter-clause</em>­</a><em>opt</em> ­}­ | {­ <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-clause" target="_blank"><em>setter-clause</em></a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-clause" target="_blank">­<em>getter-clause</em></a>­}­</p>
<p>GRAMMAR OF A GETTER-SETTER BLOCK<br><em>getter-setter-block</em> → {­ <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-clause" target="_blank"><em>getter-clause</em></a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-clause" target="_blank">­<em>setter-clause</em>­</a><em>opt</em> ­}­ | {­ <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-clause" target="_blank"><em>setter-clause</em></a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-clause" target="_blank">­<em>getter-clause</em></a>­}­</p>
</blockquote>
<p>这个定义表明，一个getter-setter方法​​块可以由一个getter子句后跟一个可选的setter子句构成，用大括号括起来，或者由一个setter子句后跟一个getter子句构成，用大括号括起来。上述的文法产生等价于下面的两个产生，明确阐明如何二中择一：</p>
<blockquote>
<p>GRAMMAR OF A GETTER-SETTER BLOCK</p>
<p>getter-setter-block → {­ <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-clause" target="_blank"><em>getter-clause</em></a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-clause" target="_blank"><em>­setter-clause</em>­</a><em>opt</em> ­}­­</p>
<p>getter-setter-block → {­ <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-clause" target="_blank"><em>setter-clause</em></a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-clause" target="_blank"><em>­getter-clause</em></a>­}­</p>
<p>GRAMMAR OF A GETTER-SETTER BLOCK<br>getter-setter-block → {­ <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-clause" target="_blank"><em>getter-clause</em></a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-clause" target="_blank"><em>­setter-clause</em>­</a><em>opt</em> ­}­­<br>getter-setter-block → {­ <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-clause" target="_blank"><em>setter-clause</em></a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-clause" target="_blank"><em>­getter-clause</em></a>­}­</p>
</blockquote>

114
chapter3/02_Lexical_Structure.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="3.2" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="3.2" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,7 +587,7 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_89">
<section class="normal" id="section-gitbook_567">
<blockquote>
<p>翻译：superkam</p>
@ -615,44 +615,16 @@
<p>使用保留字（<em>reserved word</em>）作为标识符，需要在其前后增加反引号 <code>`</code>。例如，<code>class</code> 不是合法的标识符，但可以使用 <code>`class`</code>。反引号不属于标识符的一部分，<code>`x`</code> 和 <code>x</code> 表示同一标识符。</p>
<p>闭包（<em>closure</em>）中如果没有明确指定参数名称，参数将被隐式命名为 <code>$0</code>、<code>$1</code>、<code>$2</code>... 这些命名在闭包作用域内是合法的标识符。</p>
<blockquote>
<p>标识符语法</p>
<p><em>identifier</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-head" target="_blank">identifier-head­</a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-characters" target="_blank">identifier-characters</a>­ <em>opt</em></p>
<p><em>identifier</em> → `­ <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-head" target="_blank">identifier-head­</a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-characters" target="_blank">identifier-characters­</a> <em>opt­</em> `­</p>
<p><em>identifier</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/implicit-parameter-name" target="_blank">implicit-parameter-name­</a></p>
<p><em>identifier-list</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier" target="_blank">identifier­</a> | <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier" target="_blank">identifier­</a> , <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-list" target="_blank">­identifier-list</a>­</p>
<p><em>identifier-head</em> → A 到 Z 大写或小写字母</p>
<p><em>identifier-head</em> → U+00A8, U+00AA, U+00AD, U+00AF, U+00B2–U+00B5, 或 U+00B7–U+00BA</p>
<p><em>identifier-head</em> → U+00BC–U+00BE, U+00C0–U+00D6, U+00D8–U+00F6, 或 U+00F8–U+00FF</p>
<p><em>identifier-head</em> → U+0100–U+02FF, U+0370–U+167F, U+1681–U+180D, 或 U+180F–U+1DBF</p>
<p><em>identifier-head</em> → U+1E00–U+1FFF</p>
<p><em>identifier-head</em> → U+200B–U+200D, U+202A–U+202E, U+203F–U+2040, U+2054, 或 U+2060–U+206F</p>
<p><em>identifier-head</em> → U+2070–U+20CF, U+2100–U+218F, U+2460–U+24FF, 或 U+2776–U+2793</p>
<p><em>identifier-head</em> → U+2C00–U+2DFF 或 U+2E80–U+2FFF</p>
<p><em>identifier-head</em> → U+3004–U+3007, U+3021–U+302F, U+3031–U+303F, 或 U+3040–U+D7FF</p>
<p><em>identifier-head</em> → U+F900–U+FD3D, U+FD40–U+FDCF, U+FDF0–U+FE1F, 或 U+FE30–U+FE44</p>
<p><em>identifier-head</em> → U+FE47–U+FFFD</p>
<p><em>identifier-head</em> → U+10000–U+1FFFD, U+20000–U+2FFFD, U+30000–U+3FFFD, 或 U+40000–U+4FFFD</p>
<p><em>identifier-head</em> → U+50000–U+5FFFD, U+60000–U+6FFFD, U+70000–U+7FFFD, 或 U+80000–U+8FFFD</p>
<p><em>identifier-head</em> → U+90000–U+9FFFD, U+A0000–U+AFFFD, U+B0000–U+BFFFD, 或 U+C0000–U+CFFFD</p>
<p><em>identifier-head</em> → U+D0000–U+DFFFD 或 U+E0000–U+EFFFD</p>
<p><em>identifier-character</em> → 数字 0 到 9</p>
<p><em>identifier-character</em> → U+0300–U+036F, U+1DC0–U+1DFF, U+20D0–U+20FF, or U+FE20–U+FE2F</p>
<p><em>identifier-character</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-head" target="_blank">identifier-head­</a></p>
<p><em>identifier-characters</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-character" target="_blank">identifier-character</a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-characters" target="_blank">­identifier-characters­</a> <em>opt­</em></p>
<p><em>implicit-parameter-name</em> → <strong>$­</strong> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-digits" target="_blank">decimal-digits­</a></p>
<p>标识符语法<br><em>标识符</em> → <a href="LexicalStructure.html#identifier_head"><em>标识符头(Head)</em></a> <a href="LexicalStructure.html#identifier_characters"><em>标识符字符列表</em></a> <em>可选</em><br><em>标识符</em> → <strong>`</strong> <a href="LexicalStructure.html#identifier_head"><em>标识符头(Head)</em></a> <a href="LexicalStructure.html#identifier_characters"><em>标识符字符列表</em></a> <em>可选</em> <strong>`</strong><br><em>标识符</em> → <a href="LexicalStructure.html#implicit_parameter_name"><em>隐式参数名</em></a><br><em>标识符列表</em> → <a href="LexicalStructure.html#identifier"><em>标识符</em></a> | <a href="LexicalStructure.html#identifier"><em>标识符</em></a> <strong>,</strong> <a href="LexicalStructure.html#identifier_list"><em>标识符列表</em></a><br><em>标识符头(Head)</em> → Upper- or lowercase letter A through Z<br><em>标识符头(Head)</em> → U+00A8, U+00AA, U+00AD, U+00AF, U+00B2–U+00B5, or U+00B7–U+00BA<br><em>标识符头(Head)</em> → U+00BC–U+00BE, U+00C0–U+00D6, U+00D8–U+00F6, or U+00F8–U+00FF<br><em>标识符头(Head)</em> → U+0100–U+02FF, U+0370–U+167F, U+1681–U+180D, or U+180F–U+1DBF<br><em>标识符头(Head)</em> → U+1E00–U+1FFF<br><em>标识符头(Head)</em> → U+200B–U+200D, U+202A–U+202E, U+203F–U+2040, U+2054, or U+2060–U+206F<br><em>标识符头(Head)</em> → U+2070–U+20CF, U+2100–U+218F, U+2460–U+24FF, or U+2776–U+2793<br><em>标识符头(Head)</em> → U+2C00–U+2DFF or U+2E80–U+2FFF<br><em>标识符头(Head)</em> → U+3004–U+3007, U+3021–U+302F, U+3031–U+303F, or U+3040–U+D7FF<br><em>标识符头(Head)</em> → U+F900–U+FD3D, U+FD40–U+FDCF, U+FDF0–U+FE1F, or U+FE30–U+FE44<br><em>标识符头(Head)</em> → U+FE47–U+FFFD<br><em>标识符头(Head)</em> → U+10000–U+1FFFD, U+20000–U+2FFFD, U+30000–U+3FFFD, or U+40000–U+4FFFD<br><em>标识符头(Head)</em> → U+50000–U+5FFFD, U+60000–U+6FFFD, U+70000–U+7FFFD, or U+80000–U+8FFFD<br><em>标识符头(Head)</em> → U+90000–U+9FFFD, U+A0000–U+AFFFD, U+B0000–U+BFFFD, or U+C0000–U+CFFFD<br><em>标识符头(Head)</em> → U+D0000–U+DFFFD or U+E0000–U+EFFFD<br><em>标识符字符</em> → 数值 0 到 9<br><em>标识符字符</em> → U+0300–U+036F, U+1DC0–U+1DFF, U+20D0–U+20FF, or U+FE20–U+FE2F<br><em>标识符字符</em> → <a href="LexicalStructure.html#identifier_head"><em>标识符头(Head)</em></a><br><em>标识符字符列表</em> → <a href="LexicalStructure.html#identifier_character"><em>标识符字符</em></a> <a href="LexicalStructure.html#identifier_characters"><em>标识符字符列表</em></a> <em>可选</em><br><em>隐式参数名</em> → <strong>$</strong> <a href="LexicalStructure.html#decimal_digits"><em>十进制数字列表</em></a> </p>
</blockquote>
<p><a name="keywords"></a></p>
<h2 id="-">关键字</h2>
<p>被保留的关键字（<em>keywords</em>）不允许用作标识符，除非被反引号转义，参见 <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/doc/uid/TP40014097-CH30-XID_796" target="_blank">标识符</a>。</p>
<ul>
<li><p><strong>用作声明的关键字：</strong> <em>class</em>、<em>deinit</em>、<em>enum</em>、<em>extension</em>、<em>func</em>、<em>import</em>、<em>init</em>、<em>let</em>、<em>protocol</em>、<em>static</em>、<em>struct</em>、<em>subscript</em>、<em>typealias</em>、<em>var</em></p>
</li>
<li><p><strong>用作语句的关键字：</strong> <em>break</em>、<em>case</em>、<em>continue</em>、<em>default</em>、<em>do</em>、<em>else</em>、<em>fallthrough</em>、<em>if</em>、<em>in</em>、<em>for</em>、<em>return</em>、<em>switch</em>、<em>where</em>、<em>while</em></p>
</li>
<li><p><strong>用作表达和类型的关键字：</strong> <em>as</em>、<em>dynamicType</em>、<em>is</em>、<em>new</em>、<em>super</em>、<em>self</em>、<em>Self</em>、<em>Type</em>、<em>__COLUMN__</em>、<em>__FILE__</em>、<em>__FUNCTION__</em>、<em>__LINE__</em></p>
</li>
<li><p><strong>特定上下文中被保留的关键字：</strong> <em>associativity</em>、<em>didSet</em>、<em>get</em>、<em>infix</em>、<em>inout</em>、<em>left</em>、<em>mutating</em>、<em>none</em>、<em>nonmutating</em>、<em>operator</em>、<em>override</em>、<em>postfix</em>、<em>precedence</em>、<em>prefix</em>、<em>right</em>、<em>set</em>、<em>unowned</em>、<em>unowned(safe)</em>、<em>unowned(unsafe)</em>、<em>weak</em>、<em>willSet</em>，这些关键字在特定上下文之外可以被用于标识符。</p>
</li>
<li><strong>用作声明的关键字：</strong> <em>class</em>、<em>deinit</em>、<em>enum</em>、<em>extension</em>、<em>func</em>、<em>import</em>、<em>init</em>、<em>let</em>、<em>protocol</em>、<em>static</em>、<em>struct</em>、<em>subscript</em>、<em>typealias</em>、<em>var</em></li>
<li><strong>用作语句的关键字：</strong> <em>break</em>、<em>case</em>、<em>continue</em>、<em>default</em>、<em>do</em>、<em>else</em>、<em>fallthrough</em>、<em>if</em>、<em>in</em>、<em>for</em>、<em>return</em>、<em>switch</em>、<em>where</em>、<em>while</em></li>
<li><strong>用作表达和类型的关键字：</strong> <em>as</em>、<em>dynamicType</em>、<em>is</em>、<em>new</em>、<em>super</em>、<em>self</em>、<em>Self</em>、<em>Type</em>、<em>__COLUMN__</em>、<em>__FILE__</em>、<em>__FUNCTION__</em>、<em>__LINE__</em></li>
<li><strong>特定上下文中被保留的关键字：</strong> <em>associativity</em>、<em>didSet</em>、<em>get</em>、<em>infix</em>、<em>inout</em>、<em>left</em>、<em>mutating</em>、<em>none</em>、<em>nonmutating</em>、<em>operator</em>、<em>override</em>、<em>postfix</em>、<em>precedence</em>、<em>prefix</em>、<em>right</em>、<em>set</em>、<em>unowned</em>、<em>unowned(safe)</em>、<em>unowned(unsafe)</em>、<em>weak</em>、<em>willSet</em>，这些关键字在特定上下文之外可以被用于标识符。</li>
</ul>
<p><a name="literals"></a></p>
<h2 id="-">字面量</h2>
@ -662,8 +634,7 @@
&quot;Hello, world!&quot; // 文本型字面量
</code></pre>
<blockquote>
<p>字面量语法</p>
<p><em>literal</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/integer-literal" target="_blank">integer-literal­</a> | <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/floating-point-literal" target="_blank">floating-point-literal</a>­ | <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/string-literal" target="_blank">string-literal­</a></p>
<p>字面量语法<br><em>字面量</em> → <a href="LexicalStructure.html#integer_literal"><em>整型字面量</em></a> | <a href="LexicalStructure.html#floating_point_literal"><em>浮点数字面量</em></a> | <a href="LexicalStructure.html#string_literal"><em>字符串字面量</em></a> </p>
</blockquote>
<h3 id="-">整型字面量</h3>
<p>整型字面量（<em>integer literals</em>）表示未指定精度整型数的值。整型字面量默认用十进制表示，可以加前缀来指定其他的进制，二进制字面量加 <code>0b</code>，八进制字面量加 <code>0o</code>，十六进制字面量加 <code>0x</code>。</p>
@ -675,28 +646,7 @@
</code></pre>
<p>除非特殊指定，整型字面量的默认类型为 Swift 标准库类型中的 <code>Int</code>。Swift 标准库还定义了其他不同长度以及是否带符号的整数类型，请参考 <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html#//apple_ref/doc/uid/TP40014097-CH5-XID_411" target="_blank">整数类型</a>。</p>
<blockquote>
<p>整型字面量语法</p>
<p><em>integer-literal</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-literal" target="_blank">binary-literal­</a></p>
<p><em>integer-literal</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/octal-literal" target="_blank">octal-literal­</a></p>
<p><em>integer-literal</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal" target="_blank">decimal-literal­</a></p>
<p><em>integer-literal</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal" target="_blank">hexadecimal-literal</a>­</p>
<p><em>binary-literal</em> → <strong>0b</strong>­ <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-digit" target="_blank">binary-digit</a> ­<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-literal-characters" target="_blank">binary-literal-characters­</a> <em>opt­</em></p>
<p><em>binary-digit</em> → 数字 0 或 1</p>
<p><em>binary-literal-character</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-digit" target="_blank">binary-digit</a>­ | _­</p>
<p><em>binary-literal-characters</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-literal-character" target="_blank">binary-literal-character</a> ­<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-literal-characters" target="_blank">binary-literal-characters­</a> <em>opt­</em></p>
<p><em>octal-literal</em> → <strong>0o</strong>­ <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/octal-digit" target="_blank">octal-digit</a> ­<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/octal-literal-characters" target="_blank">octal-literal-characters­</a> <em>opt­</em></p>
<p><em>octal-digit</em> → 数字 0 至 7</p>
<p><em>octal-literal-character</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/octal-digit" target="_blank">octal-digit</a>­ | _­</p>
<p><em>octal-literal-characters</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/octal-literal-character" target="_blank">octal-literal-character</a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/octal-literal-characters" target="_blank">­octal-literal-characters­</a> <em>opt­</em></p>
<p><em>decimal-literal</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-digit" target="_blank">decimal-digit</a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal-characters" target="_blank">­decimal-literal-characters­</a> <em>opt­</em></p>
<p><em>decimal-digit</em> → 数字 0 至 9</p>
<p><em>decimal-digits</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-digit" target="_blank">decimal-digit­</a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-digits" target="_blank">decimal-digits­</a> <em>opt­</em></p>
<p><em>decimal-literal-character</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-digit" target="_blank">decimal-digit­</a> | _­</p>
<p><em>decimal-literal-characters</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal-character" target="_blank">decimal-literal-character</a> ­<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal-characters" target="_blank">decimal-literal-characters­</a> <em>opt­</em></p>
<p><em>hexadecimal-literal</em> → <strong>0x</strong> ­<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit" target="_blank">hexadecimal-digit</a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal-characters" target="_blank">­hexadecimal-literal-characters­</a> <em>opt­</em></p>
<p><em>hexadecimal-digit</em> → 数字 0 到 9, a 到 f, 或 A 到 F</p>
<p><em>hexadecimal-literal-character</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit" target="_blank">hexadecimal-digit</a>­ | _­</p>
<p><em>hexadecimal-literal-characters</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal-character" target="_blank">hexadecimal-literal-character­</a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal-characters" target="_blank">hexadecimal-literal-characters</a> ­<em>opt­</em></p>
<p>整型字面量语法<br><em>整型字面量</em> → <a href="LexicalStructure.html#binary_literal"><em>二进制字面量</em></a><br><em>整型字面量</em> → <a href="LexicalStructure.html#octal_literal"><em>八进制字面量</em></a><br><em>整型字面量</em> → <a href="LexicalStructure.html#decimal_literal"><em>十进制字面量</em></a><br><em>整型字面量</em> → <a href="LexicalStructure.html#hexadecimal_literal"><em>十六进制字面量</em></a><br><em>二进制字面量</em> → <strong>0b</strong> <a href="LexicalStructure.html#binary_digit"><em>二进制数字</em></a> <a href="LexicalStructure.html#binary_literal_characters"><em>二进制字面量字符列表</em></a> <em>可选</em><br><em>二进制数字</em> → 数值 0 到 1<br><em>二进制字面量字符</em> → <a href="LexicalStructure.html#binary_digit"><em>二进制数字</em></a> | <strong>_</strong><br><em>二进制字面量字符列表</em> → <a href="LexicalStructure.html#binary_literal_character"><em>二进制字面量字符</em></a> <a href="LexicalStructure.html#binary_literal_characters"><em>二进制字面量字符列表</em></a> <em>可选</em><br><em>八进制字面量</em> → <strong>0o</strong> <a href="LexicalStructure.html#octal_digit"><em>八进字数字</em></a> <a href="LexicalStructure.html#octal_literal_characters"><em>八进制字符列表</em></a> <em>可选</em><br><em>八进字数字</em> → 数值 0 到 7<br><em>八进制字符</em> → <a href="LexicalStructure.html#octal_digit"><em>八进字数字</em></a> | <strong>_</strong><br><em>八进制字符列表</em> → <a href="LexicalStructure.html#octal_literal_character"><em>八进制字符</em></a> <a href="LexicalStructure.html#octal_literal_characters"><em>八进制字符列表</em></a> <em>可选</em><br><em>十进制字面量</em> → <a href="LexicalStructure.html#decimal_digit"><em>十进制数字</em></a> <a href="LexicalStructure.html#decimal_literal_characters"><em>十进制字符列表</em></a> <em>可选</em><br><em>十进制数字</em> → 数值 0 到 9<br><em>十进制数字列表</em> → <a href="LexicalStructure.html#decimal_digit"><em>十进制数字</em></a> <a href="LexicalStructure.html#decimal_digits"><em>十进制数字列表</em></a> <em>可选</em><br><em>十进制字符</em> → <a href="LexicalStructure.html#decimal_digit"><em>十进制数字</em></a> | <strong>_</strong><br><em>十进制字符列表</em> → <a href="LexicalStructure.html#decimal_literal_character"><em>十进制字符</em></a> <a href="LexicalStructure.html#decimal_literal_characters"><em>十进制字符列表</em></a> <em>可选</em><br><em>十六进制字面量</em> → <strong>0x</strong> <a href="LexicalStructure.html#hexadecimal_digit"><em>十六进制数字</em></a> <a href="LexicalStructure.html#hexadecimal_literal_characters"><em>十六进制字面量字符列表</em></a> <em>可选</em><br><em>十六进制数字</em> → 数值 0 到 9, a through f, or A through F<br><em>十六进制字符</em> → <a href="LexicalStructure.html#hexadecimal_digit"><em>十六进制数字</em></a> | <strong>_</strong><br><em>十六进制字面量字符列表</em> → <a href="LexicalStructure.html#hexadecimal_literal_character"><em>十六进制字符</em></a> <a href="LexicalStructure.html#hexadecimal_literal_characters"><em>十六进制字面量字符列表</em></a> <em>可选</em> </p>
</blockquote>
<h3 id="-">浮点型字面量</h3>
<p>浮点型字面量（<em>floating-point literals</em>）表示未指定精度浮点数的值。</p>
@ -710,21 +660,13 @@
</code></pre>
<p>除非特殊指定，浮点型字面量的默认类型为 Swift 标准库类型中的 <code>Double</code>，表示64位浮点数。Swift 标准库也定义 <code>Float</code> 类型，表示32位浮点数。</p>
<blockquote>
<p>浮点型字面量语法</p>
<p><em>floating-point-literal</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal" target="_blank">decimal-literal</a> ­<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-fraction" target="_blank">decimal-fraction­</a> <em>opt</em> ­<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-exponent" target="_blank">decimal-exponent­</a> <em>opt­</em></p>
<p><em>floating-point-literal</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal" target="_blank">hexadecimal-literal</a> ­<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-fraction" target="_blank">hexadecimal-fraction</a> ­<em>opt­</em> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-exponent" target="_blank">hexadecimal-exponent</a>­</p>
<p><em>decimal-fraction</em> → . <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal" target="_blank">­decimal-literal­</a></p>
<p><em>decimal-exponent</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/floating-point-e" target="_blank">floating-point-e</a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/sign" target="_blank">­sign­</a> <em>opt­</em> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal" target="_blank">decimal-literal</a>­</p>
<p><em>hexadecimal-fraction</em> → . <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal" target="_blank">­hexadecimal-literal­</a> <em>opt­</em></p>
<p><em>hexadecimal-exponent</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/floating-point-p" target="_blank">floating-point-p­</a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/sign" target="_blank">sign­</a> <em>opt­</em> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal" target="_blank">hexadecimal-literal­</a></p>
<p><em>floating-point-e</em> → <strong>e­</strong> | <strong>E</strong>­</p>
<p><em>floating-point-p</em> → <strong>p</strong>­ | <strong>P</strong>­</p>
<p><em>sign</em> → <strong>+</strong>­ | <strong>-</strong>­</p>
<p>浮点型字面量语法<br><em>浮点数字面量</em> → <a href="LexicalStructure.html#decimal_literal"><em>十进制字面量</em></a> <a href="LexicalStructure.html#decimal_fraction"><em>十进制分数</em></a> <em>可选</em> <a href="LexicalStructure.html#decimal_exponent"><em>十进制指数</em></a> <em>可选</em><br><em>浮点数字面量</em> → <a href="LexicalStructure.html#hexadecimal_literal"><em>十六进制字面量</em></a> <a href="LexicalStructure.html#hexadecimal_fraction"><em>十六进制分数</em></a> <em>可选</em> <a href="LexicalStructure.html#hexadecimal_exponent"><em>十六进制指数</em></a><br><em>十进制分数</em> → <strong>.</strong> <a href="LexicalStructure.html#decimal_literal"><em>十进制字面量</em></a><br><em>十进制指数</em> → <a href="LexicalStructure.html#floating_point_e"><em>浮点数e</em></a> <a href="LexicalStructure.html#sign"><em>正负号</em></a> <em>可选</em> <a href="LexicalStructure.html#decimal_literal"><em>十进制字面量</em></a><br><em>十六进制分数</em> → <strong>.</strong> <a href="LexicalStructure.html#hexadecimal_literal"><em>十六进制字面量</em></a> <em>可选</em><br><em>十六进制指数</em> → <a href="LexicalStructure.html#floating_point_p"><em>浮点数p</em></a> <a href="LexicalStructure.html#sign"><em>正负号</em></a> <em>可选</em> <a href="LexicalStructure.html#hexadecimal_literal"><em>十六进制字面量</em></a><br><em>浮点数e</em> → <strong>e</strong> | <strong>E</strong><br><em>浮点数p</em> → <strong>p</strong> | <strong>P</strong><br><em>正负号</em> → <strong>+</strong> | <strong>-</strong> </p>
</blockquote>
<h3 id="-">文本型字面量</h3>
<p>文本型字面量（<em>string literal</em>）由双引号中的字符串组成，形式如下：</p>
<pre><code>&quot;characters&quot;
</code></pre><p>文本型字面量中不能包含未转义的双引号 <code>&quot;</code>、未转义的反斜线<code>\</code>、回车符（<em>carriage return</em>）或换行符（<em>line feed</em>）。</p>
<pre><code class="lang-swift">&quot;characters&quot;
</code></pre>
<p>文本型字面量中不能包含未转义的双引号 <code>&quot;</code>、未转义的反斜线<code>\</code>、回车符（<em>carriage return</em>）或换行符（<em>line feed</em>）。</p>
<p>可以在文本型字面量中使用的转义特殊符号如下：</p>
<ul>
<li>空字符（Null Character）<code>\0</code></li>
@ -751,16 +693,7 @@ var x = 3; &quot;1 2 \(x)&quot;
</code></pre>
<p>文本型字面量的默认类型为 <code>String</code>。组成字符串的字符类型为 <code>Character</code>。更多有关 <code>String</code> 和 <code>Character</code> 的信息请参照 <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/StringsAndCharacters.html#//apple_ref/doc/uid/TP40014097-CH7-XID_368" target="_blank">字符串和字符</a>。</p>
<blockquote>
<p>文本型字面量语法</p>
<p><em>string-literal</em> → <strong>&quot;­</strong> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/quoted-text" target="_blank">quoted-text</a> <strong>­&quot;­</strong></p>
<p><em>quoted-text</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/quoted-text-item" target="_blank">quoted-text-item­</a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/quoted-text" target="_blank">quoted-text</a> ­<em>opt­</em></p>
<p><em>quoted-text-item</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/escaped-character" target="_blank">escaped-character­</a></p>
<p><em>quoted-text-item</em> → <strong>(</strong>­ <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression" target="_blank">expression­</a> <strong>)</strong>­</p>
<p><em>quoted-text-item</em> → 除 <code>&quot;</code>、<code>\</code>­、<code>U+000A</code> 或 <code>U+000D</code> 以外的任何 Unicode 扩展字符集</p>
<p><em>escaped-character</em> → <strong>\0­</strong> | <strong>\</strong>­ | <strong>\t­</strong> | <strong>\n</strong>­ | <strong>\r­</strong> | <strong>\&quot;­</strong> | <strong>\&#39;</strong>­</p>
<p><em>escaped-character</em> → <strong>\x­</strong> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit" target="_blank">hexadecimal-digit</a>­ <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit" target="_blank">hexadecimal-digit­</a></p>
<p><em>escaped-character</em> → <strong>\u</strong> ­<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit" target="_blank">hexadecimal-digit­</a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit" target="_blank">hexadecimal-digit</a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit" target="_blank">­hexadecimal-digit</a>­ <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit" target="_blank">hexadecimal-digit­</a></p>
<p><em>escaped-character</em> → <strong>\U­</strong> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit" target="_blank">hexadecimal-digit­</a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit" target="_blank">hexadecimal-digit­</a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit" target="_blank">hexadecimal-digit­</a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit" target="_blank">hexadecimal-digit­</a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit" target="_blank">hexadecimal-digit­</a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit" target="_blank">hexadecimal-digit­</a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit" target="_blank">hexadecimal-digit­</a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit" target="_blank">hexadecimal-digit­</a></p>
<p>字符型字面量语法<br><em>字符串字面量</em> → <strong>&quot;</strong> <a href="LexicalStructure.html#quoted_text"><em>引用文本</em></a> <strong>&quot;</strong><br><em>引用文本</em> → <a href="LexicalStructure.html#quoted_text_item"><em>引用文本条目</em></a> <a href="LexicalStructure.html#quoted_text"><em>引用文本</em></a> <em>可选</em><br><em>引用文本条目</em> → <a href="LexicalStructure.html#escaped_character"><em>转义字符</em></a><br><em>引用文本条目</em> → <strong>(</strong> <a href="..\chapter3\04_Expressions.html#expression"><em>表达式</em></a> <strong>)</strong><br><em>引用文本条目</em> → 除了&quot;­, \­, U+000A, or U+000D的所有Unicode的字符<br><em>转义字符</em> → <strong>\0</strong> | <strong>\</strong> | <strong>\t</strong> | <strong>\n</strong> | <strong>\r</strong> | <strong>\&quot;</strong> | <strong>\&#39;</strong><br><em>转义字符</em> → <strong>\x</strong> <a href="LexicalStructure.html#hexadecimal_digit"><em>十六进制数字</em></a> <a href="LexicalStructure.html#hexadecimal_digit"><em>十六进制数字</em></a><br><em>转义字符</em> → <strong>\u</strong> <a href="LexicalStructure.html#hexadecimal_digit"><em>十六进制数字</em></a> <a href="LexicalStructure.html#hexadecimal_digit"><em>十六进制数字</em></a> <a href="LexicalStructure.html#hexadecimal_digit"><em>十六进制数字</em></a> <a href="LexicalStructure.html#hexadecimal_digit"><em>十六进制数字</em></a><br><em>转义字符</em> → <strong>\U</strong> <a href="LexicalStructure.html#hexadecimal_digit"><em>十六进制数字</em></a> <a href="LexicalStructure.html#hexadecimal_digit"><em>十六进制数字</em></a> <a href="LexicalStructure.html#hexadecimal_digit"><em>十六进制数字</em></a> <a href="LexicalStructure.html#hexadecimal_digit"><em>十六进制数字</em></a> <a href="LexicalStructure.html#hexadecimal_digit"><em>十六进制数字</em></a> <a href="LexicalStructure.html#hexadecimal_digit"><em>十六进制数字</em></a> <a href="LexicalStructure.html#hexadecimal_digit"><em>十六进制数字</em></a> <a href="LexicalStructure.html#hexadecimal_digit"><em>十六进制数字</em></a> </p>
</blockquote>
<p><a name="operators"></a></p>
<h2 id="-">运算符</h2>
@ -769,26 +702,17 @@ var x = 3; &quot;1 2 \(x)&quot;
<code>/</code>、<code>=</code>、<code>-</code>、<code>+</code>、<code>!</code>、<code>*</code>、<code>%</code>、<code>&lt;</code>、<code>&gt;</code>、<code>&amp;</code>、<code>|</code>、<code>^</code>、<code>~</code>、<code>.</code>。也就是说，标记 <code>=</code>, <code>-&gt;</code>、<code>//</code>、<code>/*</code>、<code>*/</code>、<code>.</code> 以及一元前缀运算符 <code>&amp;</code> 属于保留字，这些标记不能被重写或用于自定义运算符。</p>
<p>运算符两侧的空白被用来区分该运算符是否为前缀运算符（<em>prefix operator</em>）、后缀运算符（<em>postfix operator</em>）或二元运算符（<em>binary operator</em>）。规则总结如下：</p>
<ul>
<li><p>如果运算符两侧都有空白或两侧都无空白，将被看作二元运算符。例如：<code>a+b</code> 和 <code>a + b</code> 中的运算符 <code>+</code> 被看作二元运算符。</p>
</li>
<li><p>如果运算符只有左侧空白，将被看作前缀一元运算符。例如 <code>a ++b</code> 中的 <code>++</code> 被看作前缀一元运算符。</p>
</li>
<li><p>如果运算符只有右侧空白，将被看作后缀一元运算符。例如 <code>a++ b</code> 中的 <code>++</code> 被看作后缀一元运算符。</p>
</li>
<li><p>如果运算符左侧没有空白并紧跟 <code>.</code>，将被看作后缀一元运算符。例如 <code>a++.b</code> 中的 <code>++</code> 被看作后缀一元运算符（同理， <code>a++ . b</code> 中的 <code>++</code> 是后缀一元运算符而 <code>a ++ .b</code> 中的 <code>++</code> 不是）.</p>
</li>
<li>如果运算符两侧都有空白或两侧都无空白，将被看作二元运算符。例如：<code>a+b</code> 和 <code>a + b</code> 中的运算符 <code>+</code> 被看作二元运算符。</li>
<li>如果运算符只有左侧空白，将被看作前缀一元运算符。例如 <code>a ++b</code> 中的 <code>++</code> 被看作前缀一元运算符。</li>
<li>如果运算符只有右侧空白，将被看作后缀一元运算符。例如 <code>a++ b</code> 中的 <code>++</code> 被看作后缀一元运算符。</li>
<li>如果运算符左侧没有空白并紧跟 <code>.</code>，将被看作后缀一元运算符。例如 <code>a++.b</code> 中的 <code>++</code> 被看作后缀一元运算符（同理， <code>a++ . b</code> 中的 <code>++</code> 是后缀一元运算符而 <code>a ++ .b</code> 中的 <code>++</code> 不是）.</li>
</ul>
<p>鉴于这些规则，运算符前的字符 <code>(</code>、<code>[</code> 和 <code>{</code> ；运算符后的字符 <code>)</code>、<code>]</code> 和 <code>}</code> 以及字符 <code>,</code>、<code>;</code> 和 <code>:</code> 都将用于空白检测。</p>
<p>以上规则需注意一点，如果运算符 <code>!</code> 或 <code>?</code> 左侧没有空白，则不管右侧是否有空白都将被看作后缀运算符。如果将 <code>?</code> 用作可选类型（<em>optional type</em>）修饰，左侧必须无空白。如果用于条件运算符 <code>? :</code>，必须两侧都有空白。</p>
<p>在特定构成中 ，以 <code>&lt;</code> 或 <code>&gt;</code> 开头的运算符会被分离成两个或多个标记，剩余部分以同样的方式会被再次分离。因此，在 <code>Dictionary&lt;String, Array&lt;Int&gt;&gt;</code> 中没有必要添加空白来消除闭合字符 <code>&gt;</code> 的歧义。在这个例子中， 闭合字符 <code>&gt;</code> 被看作单字符标记，而不会被误解为移位运算符 <code>&gt;&gt;</code>。</p>
<p>要学习如何自定义新的运算符，请参考 <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_48" target="_blank">自定义操作符</a> 和 <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/doc/uid/TP40014097-CH34-XID_644" target="_blank">运算符声明</a>。学习如何重写现有运算符，请参考 <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_43" target="_blank">运算符方法</a>。</p>
<blockquote>
<p>运算符语法</p>
<p><em>operator</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator-character" target="_blank">operator-character­</a> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator" target="_blank">operator­</a> <em>opt­</em></p>
<p><em>operator-character</em> → <strong>/­</strong> | <strong>=­</strong> | <strong>-­</strong> | <strong>+­</strong> | <strong>!­</strong> | <strong>*­</strong> | <strong>%­</strong> | <strong>&lt;­</strong> | <strong>&gt;­</strong> | <strong>&amp;­</strong> | <strong>|­</strong> | <strong>^­</strong> | <strong>~­</strong> | <strong>.­</strong></p>
<p><em>binary-operator</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator" target="_blank">operator­</a></p>
<p><em>prefix-operator</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator" target="_blank">operator­</a></p>
<p><em>postfix-operator</em> → <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator" target="_blank">operator­</a></p>
<p>运算符语法语法<br><em>运算符</em> → <a href="LexicalStructure.html#operator_character"><em>运算符字符</em></a> <a href="LexicalStructure.html#operator"><em>运算符</em></a> <em>可选</em><br><em>运算符字符</em> → <strong>/</strong> | <strong>=</strong> | <strong>-</strong> | <strong>+</strong> | <strong>!</strong> | <strong>&#42;</strong> | <strong>%</strong> | <strong>&lt;</strong> | <strong>&gt;</strong> | <strong>&amp;</strong> | <strong>|</strong> | <strong>^</strong> | <strong>~</strong> | <strong>.</strong><br><em>二元运算符</em> → <a href="LexicalStructure.html#operator"><em>运算符</em></a><br><em>前置运算符</em> → <a href="LexicalStructure.html#operator"><em>运算符</em></a><br><em>后置运算符</em> → <a href="LexicalStructure.html#operator"><em>运算符</em></a> </p>
</blockquote>

128
chapter3/03_Types.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="3.3" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="3.3" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,11 +587,10 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_85">
<section class="normal" id="section-gitbook_561">
<blockquote>
<p>翻译：lyuka</p>
<p>校对：numbbbbb</p>
<p>翻译：lyuka<br>校对：numbbbbb, stanzhai</p>
</blockquote>
<h1 id="-types-">类型（Types）</h1>
<hr>
@ -614,36 +613,32 @@
<p><em>复合型类型</em>是没有名字的类型，它由 Swift 本身定义。Swift 存在两种复合型类型：函数类型和元组类型。一个复合型类型可以包含命名型类型和其它复合型类型。例如，元组类型<code>(Int, (Int, Int))</code>包含两个元素：第一个是命名型类型<code>Int</code>，第二个是另一个复合型类型<code>(Int, Int)</code>.</p>
<p>本节讨论 Swift 语言本身定义的类型，并描述 Swift 中的类型推断行为。</p>
<blockquote>
<p>类型的语法：
<em>type</em> → <em>array-type</em> | <em>function-type</em> | <em>type-identifier</em> | <em>tuple-type</em> | <em>optional-type</em> | <em>implicitly-unwrapped-optional-type</em> | protocol-composition-type | metatype-type</p>
<p>类型语法<br><em>类型</em> → <a href="..\chapter3\03_Types.html#array_type"><em>数组类型</em></a> | <a href="..\chapter3\03_Types.html#function_type"><em>函数类型</em></a> | <a href="..\chapter3\03_Types.html#type_identifier"><em>类型标识</em></a> | <a href="..\chapter3\03_Types.html#tuple_type"><em>元组类型</em></a> | <a href="..\chapter3\03_Types.html#optional_type"><em>可选类型</em></a> | <a href="..\chapter3\03_Types.html#implicitly_unwrapped_optional_type"><em>隐式解析可选类型</em></a> | <a href="..\chapter3\03_Types.html#protocol_composition_type"><em>协议合成类型</em></a> | <a href="..\chapter3\03_Types.html#metatype_type"><em>元型类型</em></a> </p>
</blockquote>
<p><a name="type_annotation"></a></p>
<h2 id="-">类型注解</h2>
<p>类型注解显式地指定一个变量或表达式的值。类型注解始于冒号<code>:</code>终于类型，比如下面两个例子：</p>
<pre><code class="lang-javascript"><span class="hljs-keyword">let</span> someTuple：(Double, Double) = (<span class="hljs-number">3.14159</span>, <span class="hljs-number">2.71828</span>)
func someFunction(a: Int){ <span class="hljs-comment">/* ... */</span> }
<pre><code class="lang-swift">let someTuple：(Double, Double) = (3.14159, 2.71828)
func someFunction(a: Int){ /* ... */ }
</code></pre>
<p>在第一个例子中，表达式<code>someTuple</code>的类型被指定为<code>(Double, Double)</code>。在第二个例子中，函数<code>someFunction</code>的参数<code>a</code>的类型被指定为<code>Int</code>。</p>
<p>类型注解可以在类型之前包含一个类型特性（type attributes）的可选列表。</p>
<blockquote>
<p>类型注解的语法：
<em>type-annotation</em> → :<em>attributes</em>[opt] <em>type</em></p>
<p>类型注解语法<br><em>类型注解</em> → <strong>:</strong> <a href="..\chapter3\06_Attributes.html#attributes"><em>特性(Attributes)列表</em></a> <em>可选</em> <a href="..\chapter3\03_Types.html#type"><em>类型</em></a> </p>
</blockquote>
<p><a name="type_identifier"></a></p>
<h2 id="-">类型标识符</h2>
<p>类型标识符引用命名型类型或者是命名型/复合型类型的别名。</p>
<p>大多数情况下，类型标识符引用的是同名的命名型类型。例如类型标识符<code>Int</code>引用命名型类型<code>Int</code>，同样，类型标识符<code>Dictionary&lt;String, Int&gt;</code>引用命名型类型<code>Dictionary&lt;String, Int&gt;</code>。</p>
<p>在两种情况下类型标识符引用的不是同名的类型。情况一，类型标识符引用的是命名型/复合型类型的类型别名。比如，在下面的例子中，类型标识符使用<code>Point</code>来引用元组<code>(Int, Int)</code>：</p>
<pre><code class="lang-javascript">typealias Point = (Int, Int)
<span class="hljs-keyword">let</span> origin: Point = (<span class="hljs-number">0</span>, <span class="hljs-number">0</span>)
<pre><code class="lang-swift">typealias Point = (Int, Int)
let origin: Point = (0, 0)
</code></pre>
<p>情况二，类型标识符使用dot(<code>.</code>)语法来表示在其它模块（modules）或其它类型嵌套内声明的命名型类型。例如，下面例子中的类型标识符引用在<code>ExampleModule</code>模块中声明的命名型类型<code>MyType</code>：</p>
<pre><code class="lang-javascript"><span class="hljs-keyword">var</span> someValue: ExampleModule.MyType
<pre><code class="lang-swift">var someValue: ExampleModule.MyType
</code></pre>
<blockquote>
<p>类型标识符的语法：
<em>type-identifier</em> → <em>type-name generic-argument-clause</em>[opt] | <em>type-name generic-argument-clause</em>[opt].<em>type-identifier</em>
<em>type-name</em> → <em>identifier</em></p>
<p>类型标识语法<br><em>类型标识</em> → <a href="..\chapter3\03_Types.html#type_name"><em>类型名称</em></a> <a href="GenericParametersAndArguments.html#generic_argument_clause"><em>泛型参数子句</em></a> <em>可选</em> | <a href="..\chapter3\03_Types.html#type_name"><em>类型名称</em></a> <a href="GenericParametersAndArguments.html#generic_argument_clause"><em>泛型参数子句</em></a> <em>可选</em> <strong>.</strong> <a href="..\chapter3\03_Types.html#type_identifier"><em>类型标识</em></a><br><em>类名</em> → <a href="LexicalStructure.html#identifier"><em>标识符</em></a> </p>
</blockquote>
<p><a name="tuple_type"></a></p>
<h2 id="-">元组类型</h2>
@ -651,12 +646,7 @@ func someFunction(a: Int){ <span class="hljs-comment">/* ... */</span> }
<p>你可以使用元组类型作为一个函数的返回类型，这样就可以使函数返回多个值。你也可以命名元组类型中的元素，然后用这些名字来引用每个元素的值。元素的名字由一个标识符和<code>:</code>组成。“函数和多返回值”章节里有一个展示上述特性的例子。</p>
<p><code>void</code>是空元组类型<code>()</code>的别名。如果括号内只有一个元素，那么该类型就是括号内元素的类型。比如，<code>(Int)</code>的类型是<code>Int</code>而不是<code>(Int)</code>。所以，只有当元组类型包含两个元素以上时才可以标记元组元素。</p>
<blockquote>
<p>元组类型语法：
<em>tuple</em> → (<em>tuple-type-body</em>[opt])
<em>tuple-type-body</em> → <em>tuple-type-element-list</em> ...[opt]
<em>tuple-type-element-list</em> → <em>tuple-type-element</em> | <em>tuple-type-element</em>, <em>tuple-type-element-list</em>
<em>tuple-type-element</em> → <em>attributes</em>[opt] <strong>inout</strong> [opt] <em>type</em> | <strong>inout</strong> [opt] <em>element-name type-annotation</em>
<em>element-name</em> → <em>identifier</em></p>
<p>元组类型语法<br><em>元组类型</em> → <strong>(</strong> <a href="..\chapter3\03_Types.html#tuple_type_body"><em>元组类型主体</em></a> <em>可选</em> <strong>)</strong><br><em>元组类型主体</em> → <a href="..\chapter3\03_Types.html#tuple_type_element_list"><em>元组类型的元素列表</em></a> <strong>...</strong> <em>可选</em><br><em>元组类型的元素列表</em> → <a href="..\chapter3\03_Types.html#tuple_type_element"><em>元组类型的元素</em></a> | <a href="..\chapter3\03_Types.html#tuple_type_element"><em>元组类型的元素</em></a> <strong>,</strong> <a href="..\chapter3\03_Types.html#tuple_type_element_list"><em>元组类型的元素列表</em></a><br><em>元组类型的元素</em> → <a href="..\chapter3\06_Attributes.html#attributes"><em>特性(Attributes)列表</em></a> <em>可选</em> <strong>inout</strong> <em>可选</em> <a href="..\chapter3\03_Types.html#type"><em>类型</em></a> | <strong>inout</strong> <em>可选</em> <a href="..\chapter3\03_Types.html#element_name"><em>元素名</em></a> <a href="..\chapter3\03_Types.html#type_annotation"><em>类型注解</em></a><br><em>元素名</em> → <a href="LexicalStructure.html#identifier"><em>标识符</em></a> </p>
</blockquote>
<p><a name="function_type"></a></p>
<h2 id="-">函数类型</h2>
@ -666,81 +656,78 @@ func someFunction(a: Int){ <span class="hljs-comment">/* ... */</span> }
</ul>
<p>由于 <em>参数类型</em> 和 <em>返回值类型</em> 可以是元组类型，所以函数类型可以让函数与方法支持多参数与多返回值。</p>
<p>你可以对函数类型应用带有参数类型<code>()</code>并返回表达式类型的<code>auto_closure</code>属性（见类型属性章节）。一个自动闭包函数捕获特定表达式上的隐式闭包而非表达式本身。下面的例子使用<code>auto_closure</code>属性来定义一个很简单的assert函数：</p>
<pre><code class="lang-javascript">func simpleAssert(condition: @auto_closure () -&gt; Bool, message: <span class="hljs-built_in">String</span>){
<span class="hljs-keyword">if</span> !condition(){
<pre><code class="lang-swift">func simpleAssert(condition: @auto_closure () -&gt; Bool, message: String){
if !condition(){
println(message)
}
}
<span class="hljs-keyword">let</span> testNumber = <span class="hljs-number">5</span>
simpleAssert(testNumber % <span class="hljs-number">2</span> == <span class="hljs-number">0</span>, <span class="hljs-string">"testNumber isn't an even number."</span>)
<span class="hljs-comment">// prints "testNumber isn't an even number."</span>
let testNumber = 5
simpleAssert(testNumber % 2 == 0, &quot;testNumber isn&#39;t an even number.&quot;)
// prints &quot;testNumber isn&#39;t an even number.&quot;
</code></pre>
<p>函数类型可以拥有一个可变长参数作为参数类型中的最后一个参数。从语法角度上讲，可变长参数由一个基础类型名字和<code>...</code>组成，如<code>Int...</code>。可变长参数被认为是一个包含了基础类型元素的数组。即<code>Int...</code>就是<code>Int[]</code>。关于使用可变长参数的例子，见章节“可变长参数”。</p>
<p>为了指定一个<code>in-out</code>参数，可以在参数类型前加<code>inout</code>前缀。但是你不可以对可变长参数或返回值类型使用<code>inout</code>。关于In-Out参数的讨论见章节In-Out参数部分。</p>
<p>柯里化函数（curried function）的类型相当于一个嵌套函数类型。例如，下面的柯里化函数<code>addTwoNumber()()</code>的类型是<code>Int -&gt; Int -&gt; Int</code>：</p>
<pre><code class="lang-javascript">func addTwoNumbers(a: Int)(b: Int) -&gt; Int{
<span class="hljs-keyword">return</span> a + b
<pre><code class="lang-swift">func addTwoNumbers(a: Int)(b: Int) -&gt; Int{
return a + b
}
addTwoNumbers(<span class="hljs-number">4</span>)(<span class="hljs-number">5</span>) <span class="hljs-comment">// returns 9</span>
addTwoNumbers(4)(5) // returns 9
</code></pre>
<p>柯里化函数的函数类型从右向左组成一组。例如，函数类型<code>Int -&gt; Int -&gt; Int</code>可以被理解为<code>Int -&gt; (Int -&gt; Int)</code>——也就是说，一个函数传入一个<code>Int</code>然后输出作为另一个函数的输入，然后又返回一个<code>Int</code>。例如，你可以使用如下嵌套函数来重写柯里化函数<code>addTwoNumbers()()</code>：</p>
<pre><code class="lang-javascript">func addTwoNumbers(a: Int) -&gt; (Int -&gt; Int){
<pre><code class="lang-swift">func addTwoNumbers(a: Int) -&gt; (Int -&gt; Int){
func addTheSecondNumber(b: Int) -&gt; Int{
<span class="hljs-keyword">return</span> a + b
return a + b
}
<span class="hljs-keyword">return</span> addTheSecondNumber
return addTheSecondNumber
}
addTwoNumbers(<span class="hljs-number">4</span>)(<span class="hljs-number">5</span>) <span class="hljs-comment">// Returns 9</span>
addTwoNumbers(4)(5) // Returns 9
</code></pre>
<blockquote>
<p>函数类型的语法：
<em>function-type</em> → <em>type</em> <strong>-&gt;</strong> <em>type</em></p>
<p>函数类型语法<br><em>函数类型</em> → <a href="..\chapter3\03_Types.html#type"><em>类型</em></a> <strong>-&gt;</strong> <a href="..\chapter3\03_Types.html#type"><em>类型</em></a> </p>
</blockquote>
<p><a name="array_type"></a></p>
<h2 id="-">数组类型</h2>
<p>Swift语言使用类型名紧接中括号<code>[]</code>来简化标准库中定义的命名型类型<code>Array&lt;T&gt;</code>。换句话说，下面两个声明是等价的：</p>
<pre><code class="lang-javascript"><span class="hljs-keyword">let</span> someArray: <span class="hljs-built_in">String</span>[] = [<span class="hljs-string">"Alex"</span>, <span class="hljs-string">"Brian"</span>, <span class="hljs-string">"Dave"</span>]
<span class="hljs-keyword">let</span> someArray: <span class="hljs-built_in">Array</span>&lt;<span class="hljs-built_in">String</span>&gt; = [<span class="hljs-string">"Alex"</span>, <span class="hljs-string">"Brian"</span>, <span class="hljs-string">"Dave"</span>]
<pre><code class="lang-swift">let someArray: String[] = [&quot;Alex&quot;, &quot;Brian&quot;, &quot;Dave&quot;]
let someArray: Array&lt;String&gt; = [&quot;Alex&quot;, &quot;Brian&quot;, &quot;Dave&quot;]
</code></pre>
<p>上面两种情况下，常量<code>someArray</code>都被声明为字符串数组。数组的元素也可以通过<code>[]</code>获取访问：<code>someArray[0]</code>是指第0个元素<code>“Alex”</code>。</p>
<p>上面的例子同时显示，你可以使用<code>[]</code>作为初始值构造数组，空的<code>[]</code>则用来来构造指定类型的空数组。</p>
<pre><code class="lang-javascript"><span class="hljs-keyword">var</span> emptyArray: Double[] = []
<pre><code class="lang-swift">var emptyArray: Double[] = []
</code></pre>
<p>你也可以使用链接起来的多个<code>[]</code>集合来构造多维数组。例如，下例使用三个<code>[]</code>集合来构造三维整型数组：</p>
<pre><code class="lang-javascript"><span class="hljs-keyword">var</span> array3D: Int[][][] = [[[<span class="hljs-number">1</span>, <span class="hljs-number">2</span>], [<span class="hljs-number">3</span>, <span class="hljs-number">4</span>]], [[<span class="hljs-number">5</span>, <span class="hljs-number">6</span>], [<span class="hljs-number">7</span>, <span class="hljs-number">8</span>]]]
<pre><code class="lang-swift">var array3D: Int[][][] = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
</code></pre>
<p>访问一个多维数组的元素时，最左边的下标指向最外层数组的相应位置元素。接下来往右的下标指向第一层嵌入的相应位置元素，依次类推。这就意味着，在上面的例子中，<code>array3D[0]</code>是指<code>[[1, 2], [3, 4]]</code>，<code>array3D[0][1]</code>是指<code>[3, 4]</code>，<code>array3D[0][1][1]</code>则是指值<code>4</code>。</p>
<p>关于Swift标准库中<code>Array</code>类型的细节讨论，见章节Arrays。</p>
<blockquote>
<p>数组类型的语法：
<em>array-type</em> → <em>type</em><code>[ ]</code> | <em>array-type</em><code>[ ]</code></p>
<p>数组类型语法<br><em>数组类型</em> → <a href="..\chapter3\03_Types.html#type"><em>类型</em></a> <strong>[</strong> <strong>]</strong> | <a href="..\chapter3\03_Types.html#array_type"><em>数组类型</em></a> <strong>[</strong> <strong>]</strong> </p>
</blockquote>
<p><a name="optional_type"></a></p>
<h2 id="-">可选类型</h2>
<p>Swift定义后缀<code>?</code>来作为标准库中的定义的命名型类型<code>Optional&lt;T&gt;</code>的简写。换句话说，下面两个声明是等价的：</p>
<pre><code class="lang-javascript"><span class="hljs-keyword">var</span> optionalInteger: Int?
<span class="hljs-keyword">var</span> optionalInteger: Optional&lt;Int&gt;
<pre><code class="lang-swift">var optionalInteger: Int?
var optionalInteger: Optional&lt;Int&gt;
</code></pre>
<p>在上述两种情况下，变量<code>optionalInteger</code>都被声明为可选整型类型。注意在类型和<code>?</code>之间没有空格。</p>
<p>类型<code>Optional&lt;T&gt;</code>是一个枚举，有两种形式，<code>None</code>和<code>Some(T)</code>，又来代表可能出现或可能不出现的值。任意类型都可以被显式的声明（或隐式的转换）为可选类型。当声明一个可选类型时，确保使用括号给<code>?</code>提供合适的作用范围。比如说，声明一个整型的可选数组，应写作<code>(Int[])?</code>，写成<code>Int[]?</code>的话则会出错。</p>
<p>如果你在声明或定义可选变量或特性的时候没有提供初始值，它的值则会自动赋成缺省值<code>nil</code>。</p>
<p>可选符合<code>LogicValue</code>协议，因此可以出现在布尔值环境下。此时，如果一个可选类型<code>T?</code>实例包含有类型为<code>T</code>的值（也就是说值为<code>Optional.Some(T)</code>），那么此可选类型就为<code>true</code>，否则为<code>false</code>。</p>
<p>如果一个可选类型的实例包含一个值，那么你就可以使用后缀操作符<code>!</code>来获取该值，正如下面描述的：</p>
<pre><code class="lang-javascript">optionalInteger = <span class="hljs-number">42</span>
optionalInteger! <span class="hljs-comment">// 42</span>
<pre><code class="lang-swift">optionalInteger = 42
optionalInteger! // 42
</code></pre>
<p>使用<code>!</code>操作符获取值为<code>nil</code>的可选项会导致运行错误（runtime error）。</p>
<p>你也可以使用可选链和可选绑定来选择性的执行可选表达式上的操作。如果值为<code>nil</code>，不会执行任何操作因此也就没有运行错误产生。</p>
<p>更多细节以及更多如何使用可选类型的例子，见章节“可选”。</p>
<blockquote>
<p>可选类型语法：
<em>optional-type</em> → <em>type</em>?</p>
<p>可选类型语法<br><em>可选类型</em> → <a href="..\chapter3\03_Types.html#type"><em>类型</em></a> <strong>?</strong> </p>
</blockquote>
<p><a name="implicitly_unwrapped_optional_type"></a></p>
<h2 id="-">隐式解析可选类型</h2>
<p>Swift语言定义后缀<code>!</code>作为标准库中命名类型<code>ImplicitlyUnwrappedOptional&lt;T&gt;</code>的简写。换句话说，下面两个声明等价：</p>
<pre><code class="lang-javascript"><span class="hljs-keyword">var</span> implicitlyUnwrappedString: <span class="hljs-built_in">String</span>!
<span class="hljs-keyword">var</span> implicitlyUnwrappedString: ImplicitlyUnwrappedOptional&lt;<span class="hljs-built_in">String</span>&gt;
<pre><code class="lang-swift">var implicitlyUnwrappedString: String!
var implicitlyUnwrappedString: ImplicitlyUnwrappedOptional&lt;String&gt;
</code></pre>
<p>上述两种情况下，变量<code>implicitlyUnwrappedString</code>被声明为一个隐式解析可选类型的字符串。注意类型与<code>!</code>之间没有空格。</p>
<p>你可以在使用可选的地方同样使用隐式解析可选。比如，你可以将隐式解析可选的值赋给变量、常量和可选特性，反之亦然。</p>
@ -749,47 +736,42 @@ optionalInteger! <span class="hljs-comment">// 42</span>
<p>使用可选链会选择性的执行隐式解析可选表达式上的某一个操作。如果值为<code>nil</code>，就不会执行任何操作，因此也不会产生运行错误。</p>
<p>关于隐式解析可选的更多细节，见章节“隐式解析可选”。</p>
<blockquote>
<p>隐式解析可选的语法：
implicitly-unwrapped-optional-type → type!</p>
<p>隐式解析可选类型(Implicitly Unwrapped Optional Type)语法<br><em>隐式解析可选类型</em> → <a href="..\chapter3\03_Types.html#type"><em>类型</em></a> <strong>!</strong> </p>
</blockquote>
<p><a name="protocol_composition_type"></a></p>
<h2 id="-">协议合成类型</h2>
<p>协议合成类型是一种符合每个协议的指定协议列表类型。协议合成类型可能会用在类型注解和泛型参数中。</p>
<p>协议合成类型的形式如下：</p>
<pre><code class="lang-javascript">protocol&lt;Protocol <span class="hljs-number">1</span>, Procotol <span class="hljs-number">2</span>&gt;
<pre><code class="lang-swift">protocol&lt;Protocol 1, Procotol 2&gt;
</code></pre>
<p>协议合成类型允许你指定一个值，其类型可以适配多个协议的条件，而且不需要定义一个新的命名型协议来继承其它想要适配的各个协议。比如，协议合成类型<code>protocol&lt;Protocol A, Protocol B, Protocol C&gt;</code>等效于一个从<code>Protocol A</code>，<code>Protocol B</code>， <code>Protocol C</code>继承而来的新协议<code>Protocol D</code>，很显然这样做有效率的多，甚至不需引入一个新名字。</p>
<p>协议合成列表中的每项必须是协议名或协议合成类型的类型别名。如果列表为空，它就会指定一个空协议合成列表，这样每个类型都能适配。</p>
<blockquote>
<p>协议合成类型的语法：
<em>protocol-composition-type</em> → <strong>protocol</strong> &lt;<em>protocol-identifier-list[opt]</em>&gt;
<em>protocol-identifier-list</em> → <em>protocol-identifier</em> | <em>protocol-identifier, protocol-identifier-list</em>
<em>protocol-identifier</em> → <em>type-identifier</em></p>
<p>协议合成类型语法<br><em>协议合成类型</em> → <strong>protocol</strong> <strong>&lt;</strong> <a href="..\chapter3\03_Types.html#protocol_identifier_list"><em>协议标识符列表</em></a> <em>可选</em> <strong>&gt;</strong><br><em>协议标识符列表</em> → <a href="..\chapter3\03_Types.html#protocol_identifier"><em>协议标识符</em></a> | <a href="..\chapter3\03_Types.html#protocol_identifier"><em>协议标识符</em></a> <strong>,</strong> <a href="..\chapter3\03_Types.html#protocol_identifier_list"><em>协议标识符列表</em></a><br><em>协议标识符</em> → <a href="..\chapter3\03_Types.html#type_identifier"><em>类型标识</em></a> </p>
</blockquote>
<p><a name="metatype_type"></a></p>
<h2 id="-">元类型</h2>
<p>元类型是指所有类型的类型，包括类、结构体、枚举和协议。</p>
<p>类、结构体或枚举类型的元类型是相应的类型名紧跟<code>.Type</code>。协议类型的元类型——并不是运行时适配该协议的具体类型——是该协议名字紧跟<code>.Protocol</code>。比如，类<code>SomeClass</code>的元类型就是<code>SomeClass.Type</code>，协议<code>SomeProtocol</code>的元类型就是<code>SomeProtocal.Protocol</code>。</p>
<p>你可以使用后缀<code>self</code>表达式来获取类型。比如，<code>SomeClass.self</code>返回<code>SomeClass</code>本身，而不是<code>SomeClass</code>的一个实例。同样，<code>SomeProtocol.self</code>返回<code>SomeProtocol</code>本身，而不是运行时适配<code>SomeProtocol</code>的某个类型的实例。还可以对类型的实例使用<code>dynamicType</code>表达式来获取该实例在运行阶段的类型，如下所示：</p>
<pre><code class="lang-javascript"><span class="hljs-keyword">class</span> SomeBaseClass {
<span class="hljs-keyword">class</span> func printClassName() {
println(<span class="hljs-string">"SomeBaseClass"</span>)
<pre><code class="lang-swift">class SomeBaseClass {
class func printClassName() {
println(&quot;SomeBaseClass&quot;)
}
}
<span class="hljs-keyword">class</span> SomeSubClass: SomeBaseClass {
override <span class="hljs-keyword">class</span> func printClassName() {
println(<span class="hljs-string">"SomeSubClass"</span>)
class SomeSubClass: SomeBaseClass {
override class func printClassName() {
println(&quot;SomeSubClass&quot;)
}
}
<span class="hljs-keyword">let</span> someInstance: SomeBaseClass = SomeSubClass()
<span class="hljs-comment">// someInstance is of type SomeBaseClass at compile time, but</span>
<span class="hljs-comment">// someInstance is of type SomeSubClass at runtime</span>
let someInstance: SomeBaseClass = SomeSubClass()
// someInstance is of type SomeBaseClass at compile time, but
// someInstance is of type SomeSubClass at runtime
someInstance.dynamicType.printClassName()
<span class="hljs-comment">// prints "SomeSubClass</span>
// prints &quot;SomeSubClass
</code></pre>
<blockquote>
<p>元类型的语法：
<em>metatype-type</em> → <em>type</em>.<strong>Type</strong> | <em>type</em>.<strong>Protocol</strong></p>
<p>元(Metatype)类型语法<br><em>元类型</em> → <a href="..\chapter3\03_Types.html#type"><em>类型</em></a> <strong>.</strong> <strong>Type</strong> | <a href="..\chapter3\03_Types.html#type"><em>类型</em></a> <strong>.</strong> <strong>Protocol</strong> x</p>
</blockquote>
<p><a name="type_inheritance_clause"></a></p>
<h2 id="-">类型继承子句</h2>
@ -798,17 +780,15 @@ someInstance.dynamicType.printClassName()
<p>其它命名型类型可能只继承或适配一个协议列表。协议类型可能继承于其它任意数量的协议。当一个协议类型继承于其它协议时，其它协议的条件集合会被集成在一起，然后其它从当前协议继承的任意类型必须适配所有这些条件。</p>
<p>枚举定义中的类型继承子句可以是一个协议列表，或是指定原始值的枚举，一个单独的指定原始值类型的命名型类型。使用类型继承子句来指定原始值类型的枚举定义的例子，见章节“原始值”。</p>
<blockquote>
<p>类型继承子句的语法：
<em>type-inheritance-clause</em> → :<em>type-inheritance-list</em>
<em>type-inheritance-list</em> → <em>type-identifier</em> | <em>type-identifier</em>, <em>type-inheritance-list</em></p>
<p>类型继承子句语法<br><em>类型继承子句</em> → <strong>:</strong> <a href="..\chapter3\03_Types.html#type_inheritance_list"><em>类型继承列表</em></a><br><em>类型继承列表</em> → <a href="..\chapter3\03_Types.html#type_identifier"><em>类型标识</em></a> | <a href="..\chapter3\03_Types.html#type_identifier"><em>类型标识</em></a> <strong>,</strong> <a href="..\chapter3\03_Types.html#type_inheritance_list"><em>类型继承列表</em></a></p>
</blockquote>
<p><a name="type_inference"></a></p>
<h2 id="-">类型推断</h2>
<p>Swift广泛的使用类型推断，从而允许你可以忽略很多变量和表达式的类型或部分类型。比如，对于<code>var x: Int = 0</code>，你可以完全忽略类型而简写成<code>var x = 0</code>——编译器会正确的推断出<code>x</code>的类型<code>Int</code>。类似的，当完整的类型可以从上下文推断出来时，你也可以忽略类型的一部分。比如，如果你写了<code>let dict: Dictionary = [&quot;A&quot;: 1]</code>，编译提也能推断出<code>dict</code>的类型是<code>Dictionary&lt;String, Int&gt;</code>。</p>
<p>在上面的两个例子中，类型信息从表达式树（expression tree）的叶子节点传向根节点。也就是说，<code>var x: Int = 0</code>中<code>x</code>的类型首先根据<code>0</code>的类型进行推断，然后将该类型信息传递到根节点（变量<code>x</code>）。</p>
<p>在Swift中，类型信息也可以反方向流动——从根节点传向叶子节点。在下面的例子中，常量<code>eFloat</code>上的显式类型注解（<code>:Float</code>）导致数字字面量<code>2.71828</code>的类型是<code>Float</code>而非<code>Double</code>。</p>
<pre><code class="lang-javascript"><span class="hljs-keyword">let</span> e = <span class="hljs-number">2.71828</span> <span class="hljs-comment">// The type of e is inferred to be Double.</span>
<span class="hljs-keyword">let</span> eFloat: Float = <span class="hljs-number">2.71828</span> <span class="hljs-comment">// The type of eFloat is Float.</span>
<pre><code class="lang-swift">let e = 2.71828 // The type of e is inferred to be Double.
let eFloat: Float = 2.71828 // The type of eFloat is Float.
</code></pre>
<p>Swift中的类型推断在单独的表达式或语句水平上进行。这意味着所有用于推断类型的信息必须可以从表达式或其某个子表达式的类型检查中获取。</p>

233
chapter3/04_Expressions.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="3.4" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="3.4" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,11 +587,10 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_87">
<section class="normal" id="section-gitbook_563">
<blockquote>
<p>翻译：sg552</p>
<p>校对：numbbbbb</p>
<p>翻译：sg552<br>校对：numbbbbb, stanzhai</p>
</blockquote>
<h1 id="-expressions-">表达式（Expressions）</h1>
<hr>
@ -608,9 +607,7 @@
<p>Swift 中存在四种表达式： 前缀（prefix）表达式，二元（binary）表达式，主要（primary）表达式和后缀（postfix）表达式。表达式可以返回一个值，以及运行某些逻辑（causes a side effect）。</p>
<p>前缀表达式和二元表达式就是对某些表达式使用各种运算符（operators）。 主要表达式是最短小的表达式，它提供了获取（变量的）值的一种途径。 后缀表达式则允许你建立复杂的表达式，例如配合函数调用和成员访问。 每种表达式都在下面有详细论述～</p>
<blockquote>
<p>表达式的语法</p>
<p><em>expression</em> → <em>prefix-expression</em>­<em>binary-expressions(</em>opt)
<em>expression-list</em> → <em>expression</em>­| <em>expression</em>­,­<em>expression-list</em></p>
<p>表达式语法<br><em>表达式</em> → <a href="..\chapter3\04_Expressions.html#prefix_expression"><em>前置表达式</em></a> <a href="..\chapter3\04_Expressions.html#binary_expressions"><em>二元表达式列表</em></a> <em>可选</em><br><em>表达式列表</em> → <a href="..\chapter3\04_Expressions.html#expression"><em>表达式</em></a> | <a href="..\chapter3\04_Expressions.html#expression"><em>表达式</em></a> <strong>,</strong> <a href="..\chapter3\04_Expressions.html#expression_list"><em>表达式列表</em></a> </p>
</blockquote>
<p><a name="prefix_expressions"></a></p>
<h2 id="-prefix-expressions-">前缀表达式（Prefix Expressions）</h2>
@ -627,15 +624,14 @@
<p>对于这些操作符的使用，请参见： Basic Operators and Advanced Operators</p>
<p>作为对上面标准库运算符的补充，你也可以对 某个函数的参数使用 &#39;&amp;&#39;运算符。 更多信息，请参见： &quot;In-Out parameters&quot;.</p>
<blockquote>
<p>前缀表达式的语法</p>
<p><em>prefix-expression</em> → <em>prefix-operator</em> (opt) <em>postfix-expression</em>
<em>prefix-expression</em> → <em>in-out-expression</em>­
<em>in-out-expression</em> → &amp;­<em>identifier</em>­</p>
<p>前置表达式语法<br><em>前置表达式</em> → <a href="LexicalStructure.html#prefix_operator"><em>前置运算符</em></a> <em>可选</em> <a href="..\chapter3\04_Expressions.html#postfix_expression"><em>后置表达式</em></a><br><em>前置表达式</em> → <a href="..\chapter3\04_Expressions.html#in_out_expression"><em>写入写出(in-out)表达式</em></a><br><em>写入写出(in-out)表达式</em> → <strong>&amp;</strong> <a href="LexicalStructure.html#identifier"><em>标识符</em></a> </p>
</blockquote>
<p><a name="binary_expressions"></a></p>
<h2 id="-binary-expressions-">二元表达式（Binary Expressions）</h2>
<p>二元表达式由 &quot;左边参数&quot; + &quot;二元运算符&quot; + &quot;右边参数&quot; 组成, 它有如下的形式：</p>
<p> <code>left-hand argument</code> <code>operator</code> <code>right-hand argument</code></p>
<blockquote>
<p><code>left-hand argument</code> <code>operator</code> <code>right-hand argument</code></p>
</blockquote>
<p>Swift 标准库提供了如下的二元运算符：</p>
<ul>
<li>求幂相关（无结合，优先级160）<ul>
@ -731,55 +727,50 @@
</ul>
<p>关于这些运算符（operators）的更多信息，请参见：Basic Operators and Advanced Operators.</p>
<blockquote>
<blockquote>
<p>注意</p>
<p>在解析时, 一个二元表达式表示为一个一级数组（a flat list）, 这个数组（List）根据运算符的先后顺序，被转换成了一个tree. 例如： 2 + 3 <em> 5 首先被认为是： 2, + , <code>3</code>, </em>, 5. 随后它被转换成 tree （2 + （3 * 5））</p>
<p>注意<br>在解析时, 一个二元表达式表示为一个一级数组（a flat list）, 这个数组（List）根据运算符的先后顺序，被转换成了一个tree. 例如： 2 + 3 <em> 5 首先被认为是： 2, + , <code>3</code>, </em>, 5. 随后它被转换成 tree （2 + （3 * 5））</p>
</blockquote>
<p>二元表达式的语法</p>
<p><em>binary-expression</em> → <em>binary-operator</em>­<em>prefix-expression</em>­
<em>binary-expression</em> → <em>assignment-operator</em>­prefix-expression<em>
</em>binary-expression<em> → </em>conditional-operator<em>­prefix-expression</em>
<em>binary-expression</em> → <em>type-casting-operator</em>­
<em>binary-expression</em>s → <em>binary-expression</em>­<em>binary-expressions</em>(opt)</p>
<p></p>
<blockquote>
<p>二元表达式语法<br><em>二元表达式</em> → <a href="LexicalStructure.html#binary_operator"><em>二元运算符</em></a> <a href="..\chapter3\04_Expressions.html#prefix_expression"><em>前置表达式</em></a><br><em>二元表达式</em> → <a href="..\chapter3\04_Expressions.html#assignment_operator"><em>赋值运算符</em></a> <a href="..\chapter3\04_Expressions.html#prefix_expression"><em>前置表达式</em></a><br><em>二元表达式</em> → <a href="..\chapter3\04_Expressions.html#conditional_operator"><em>条件运算符</em></a> <a href="..\chapter3\04_Expressions.html#prefix_expression"><em>前置表达式</em></a><br><em>二元表达式</em> → <a href="..\chapter3\04_Expressions.html#type_casting_operator"><em>类型转换运算符</em></a><br><em>二元表达式列表</em> → <a href="..\chapter3\04_Expressions.html#binary_expression"><em>二元表达式</em></a> <a href="..\chapter3\04_Expressions.html#binary_expressions"><em>二元表达式列表</em></a> <em>可选</em> </p>
</blockquote>
<p><a name="assignment_operator"></a></p>
<h2 id="-assignment-operator-">赋值表达式（Assignment Operator）</h2>
<p>The assigment operator sets a new value for a given expression. It has the following form:
赋值表达式会对某个给定的表达式赋值。 它有如下的形式；</p>
<blockquote>
<p><code>expression</code> = <code>value</code></p>
</blockquote>
<p>就是把右边的 <em>value</em> 赋值给左边的 <em>expression</em>. 如果左边的<em>expression</em> 需要接收多个参数（是一个tuple ），那么右边必须也是一个具有同样数量参数的tuple. （允许嵌套的tuple）</p>
<pre><code class="lang-swift">(a, _, (b, c)) = (&quot;test&quot;, 9.45, (12, 3))
// a is &quot;test&quot;, b is 12, c is 3, and 9.45 is ignored
</code></pre>
<p>赋值运算符不返回任何值。</p>
<blockquote>
<p>赋值表达式的语法</p>
<p><em>assignment-operator</em> → =­</p>
<p>赋值运算符语法<br><em>赋值运算符</em> → <strong>=</strong> </p>
</blockquote>
<p><a name="ternary_conditional_operator"></a></p>
<h2 id="-ternary-conditional-operator-">三元条件运算符（Ternary Conditional Operator）</h2>
<p>三元条件运算符 是根据条件来获取值。 形式如下：</p>
<pre><code>`condition` ? `expression used if true` : `expression used if false`
</code></pre><p>如果 <code>condition</code> 是true, 那么返回 第一个表达式的值（此时不会调用第二个表达式）， 否则返回第二个表达式的值（此时不会调用第一个表达式）。</p>
<blockquote>
<p><code>condition</code> ? <code>expression used if true</code> : <code>expression used if false</code></p>
</blockquote>
<p>如果 <code>condition</code> 是true, 那么返回 第一个表达式的值（此时不会调用第二个表达式）， 否则返回第二个表达式的值（此时不会调用第一个表达式）。</p>
<p>想看三元条件运算符的例子，请参见： Ternary Conditional Operator.</p>
<blockquote>
<p>三元条件表达式</p>
<p><code>conditional-operator</code> → ?­<code>expression</code>­:­</p>
<p>三元条件运算符语法<br><em>三元条件运算符</em> → <strong>?</strong> <a href="..\chapter3\04_Expressions.html#expression"><em>表达式</em></a> <strong>:</strong> </p>
</blockquote>
<p><a name="type-casting_operators"></a></p>
<h2 id="-type-casting-operators-">类型转换运算符（Type-Casting Operators）</h2>
<p>有两种类型转换操作符： as 和 is. 它们有如下的形式：</p>
<pre><code>`expression` as `type`
`expression` as? `type`
`expression` is `type`
</code></pre><p>as 运算符会把<code>目标表达式</code>转换成指定的<code>类型</code>（specified type），过程如下：</p>
<blockquote>
<p><code>expression</code> as <code>type</code><br><code>expression</code> as? <code>type</code><br><code>expression</code> is <code>type</code> </p>
</blockquote>
<p>as 运算符会把<code>目标表达式</code>转换成指定的<code>类型</code>（specified type），过程如下：</p>
<ul>
<li><p>如果类型转换成功， 那么目标表达式就会返回指定类型的实例（instance）. 例如：把子类（subclass）变成父类（superclass）时.</p>
</li>
<li><p>如果转换失败，则会抛出编译错误（ compile-time error）。</p>
</li>
<li><p>如果上述两个情况都不是（也就是说，编译器在编译时期无法确定转换能否成功，） 那么目标表达式就会变成指定的类型的optional. （is an optional of the specified type ） 然后在运行时，如果转换成功， 目标表达式就会作为 optional的一部分来返回， 否则，目标表达式返回nil. 对应的例子是： 把一个 superclass 转换成一个 subclass.</p>
</li>
<li>如果类型转换成功， 那么目标表达式就会返回指定类型的实例（instance）. 例如：把子类（subclass）变成父类（superclass）时.</li>
<li>如果转换失败，则会抛出编译错误（ compile-time error）。</li>
<li>如果上述两个情况都不是（也就是说，编译器在编译时期无法确定转换能否成功，） 那么目标表达式就会变成指定的类型的optional. （is an optional of the specified type ） 然后在运行时，如果转换成功， 目标表达式就会作为 optional的一部分来返回， 否则，目标表达式返回nil. 对应的例子是： 把一个 superclass 转换成一个 subclass.</li>
</ul>
<pre><code class="lang-swift">class SomeSuperType {}
class SomeType: SomeSuperType {}
@ -802,22 +793,13 @@ let y2: SomeType = x // Type information from an annotation
</code></pre>
<p>关于类型转换的更多内容和例子，请参见： Type Casting.</p>
<blockquote>
<p>类型转换的语法</p>
<p><em>type-casting-operator</em> → is­<em>type</em>­| as­?(opt)­<em>type</em></p>
<p>类型转换运算符(type-casting-operator)语法<br><em>类型转换运算符</em> → <strong>is</strong> <a href="..\chapter3\03_Types.html#type"><em>类型</em></a> | <strong>as</strong> <strong>?</strong> <em>可选</em> <a href="..\chapter3\03_Types.html#type"><em>类型</em></a> </p>
</blockquote>
<p><a name="primary_expressions"></a></p>
<h2 id="-primary-expressions-">主要表达式（Primary Expressions）</h2>
<p><code>主要表达式</code>是最基本的表达式。 它们可以跟 前缀表达式，二元表达式，后缀表达式以及其他主要表达式组合使用。</p>
<h2 id="-primary-expressions-">主表达式（Primary Expressions）</h2>
<p><code>主表达式</code>是最基本的表达式。 它们可以跟 前缀表达式，二元表达式，后缀表达式以及其他主要表达式组合使用。</p>
<blockquote>
<p>主要表达式的语法</p>
<p><em>primary-expression</em> → <em>identifier</em>­<em>generic-argument-clause</em>(opt)
<em>primary-expression</em> → <em>literal-expression</em>­
<em>primary-expression</em> → <em>self-expression</em>­
<em>primary-expression</em> → <em>superclass-expression</em>­
<em>primary-expression</em> → <em>closure-expression</em>­
<em>primary-expression</em> → <em>parenthesized-expression</em>­
<em>primary-expression</em> → <em>implicit-member-expression</em>
<em>primary-expression</em> → <em>wildcard-expression</em></p>
<p>主表达式语法<br><em>主表达式</em> → <a href="LexicalStructure.html#identifier"><em>标识符</em></a> <a href="GenericParametersAndArguments.html#generic_argument_clause"><em>泛型参数子句</em></a> <em>可选</em><br><em>主表达式</em> → <a href="..\chapter3\04_Expressions.html#literal_expression"><em>字面量表达式</em></a><br><em>主表达式</em> → <a href="..\chapter3\04_Expressions.html#self_expression"><em>self表达式</em></a><br><em>主表达式</em> → <a href="..\chapter3\04_Expressions.html#superclass_expression"><em>超类表达式</em></a><br><em>主表达式</em> → <a href="..\chapter3\04_Expressions.html#closure_expression"><em>闭包表达式</em></a><br><em>主表达式</em> → <a href="..\chapter3\04_Expressions.html#parenthesized_expression"><em>圆括号表达式</em></a><br><em>主表达式</em> → <a href="..\chapter3\04_Expressions.html#implicit_member_expression"><em>隐式成员表达式</em></a><br><em>主表达式</em> → <a href="..\chapter3\04_Expressions.html#wildcard_expression"><em>通配符表达式</em></a> </p>
</blockquote>
<h3 id="-literal-expression-">字符型表达式（Literal Expression）</h3>
<p>由这些内容组成：普通的字符（string, number） , 一个字符的字典或者数组，或者下面列表中的特殊字符。</p>
@ -854,31 +836,22 @@ let y2: SomeType = x // Type information from an annotation
</table>
<p>在某个函数（function）中，<code>__FUNCTION__</code> 会返回当前函数的名字。 在某个方法（method）中，它会返回当前方法的名字。 在某个property 的getter/setter中会返回这个属性的名字。 在init/subscript中 只有的特殊成员（member）中会返回这个keyword的名字，在某个文件的顶端（the top level of a file），它返回的是当前module的名字。</p>
<p>一个array literal，是一个有序的值的集合。 它的形式是：</p>
<pre><code>[`value 1`, `value 2`, `...`]
</code></pre><p>数组中的最后一个表达式可以紧跟一个逗号（&#39;,&#39;）. []表示空数组 。 array literal的type是 T[], 这个T就是数组中元素的type. 如果该数组中有多种type, T则是跟这些type的公共supertype最接近的type.（closest common supertype）</p>
<p>一个<code>dictionary literal</code> 是一个包含无序的键值对（key-value pairs）的集合，它的形式是:</p>
<pre><code>[`key 1`: `value 1`, `key 2`: `value 2`, `...`]
</code></pre><p>dictionary 的最后一个表达式可以是一个逗号（&#39;,&#39;）. [:] 表示一个空的dictionary. 它的type是 Dictionary<KeyType, ValueType> （这里KeyType表示 key的type, ValueType表示 value的type） 如果这个dictionary 中包含多种 types, 那么KeyType, Value 则对应着它们的公共supertype最接近的type（ closest common supertype）.</p>
<blockquote>
<p>字符型表达式的语法</p>
<p><em>literal-expression</em> → <em>literal</em>
<em>literal-expression</em> → <em>array-literal</em>­| <em>dictionary-literal</em>­
<em>literal-expression</em> → <em>_<em>FILE_</em></em>­| <em>_<em>LINE_</em></em>­| <em>_<em>COLUMN_</em></em>­| <em>_<em>FUNCTION_</em></em>­
<em>array-literal</em> → [­<em>array-literal-items</em>­opt­]­
<em>array-literal-items</em> → <em>array-literal-item</em>­,­(opt) | ­<em>array-literal-item</em>­,­<em>array-literal-items</em>­
<em>array-literal-item</em> → <em>expression</em>­
<em>dictionary-literal</em> → [­<em>dictionary-literal-items</em>­]­ [­:­]­
<em>dictionary-literal-items</em> → <em>dictionary-literal-item</em>,­(opt)­| <em>dictionary-literal-item</em>­,­<em>dictionary-literal-items</em>­
<em>dictionary-literal-item</em> → <em>expression</em>­:­<em>expression</em>­</p>
<p>[<code>value 1</code>, <code>value 2</code>, <code>...</code>]</p>
</blockquote>
<p>数组中的最后一个表达式可以紧跟一个逗号（&#39;,&#39;）. []表示空数组 。 array literal的type是 T[], 这个T就是数组中元素的type. 如果该数组中有多种type, T则是跟这些type的公共supertype最接近的type.（closest common supertype）</p>
<p>一个<code>dictionary literal</code> 是一个包含无序的键值对（key-value pairs）的集合，它的形式是:</p>
<blockquote>
<p>[<code>key 1</code>: <code>value 1</code>, <code>key 2</code>: <code>value 2</code>, <code>...</code>]</p>
</blockquote>
<p>dictionary 的最后一个表达式可以是一个逗号（&#39;,&#39;）. [:] 表示一个空的dictionary. 它的type是 Dictionary<KeyType, ValueType> （这里KeyType表示 key的type, ValueType表示 value的type） 如果这个dictionary 中包含多种 types, 那么KeyType, Value 则对应着它们的公共supertype最接近的type（ closest common supertype）.</p>
<blockquote>
<p>字面量表达式语法<br><em>字面量表达式</em> → <a href="LexicalStructure.html#literal"><em>字面量</em></a><br><em>字面量表达式</em> → <a href="..\chapter3\04_Expressions.html#array_literal"><em>数组字面量</em></a> | <a href="..\chapter3\04_Expressions.html#dictionary_literal"><em>字典字面量</em></a><br><em>字面量表达式</em> → <strong>&#95;&#95;FILE&#95;&#95;</strong> | <strong>&#95;&#95;LINE&#95;&#95;</strong> | <strong>&#95;&#95;COLUMN&#95;&#95;</strong> | <strong>&#95;&#95;FUNCTION&#95;&#95;</strong><br><em>数组字面量</em> → <strong>[</strong> <a href="..\chapter3\04_Expressions.html#array_literal_items"><em>数组字面量项列表</em></a> <em>可选</em> <strong>]</strong><br><em>数组字面量项列表</em> → <a href="..\chapter3\04_Expressions.html#array_literal_item"><em>数组字面量项</em></a> <strong>,</strong> <em>可选</em> | <a href="..\chapter3\04_Expressions.html#array_literal_item"><em>数组字面量项</em></a> <strong>,</strong> <a href="..\chapter3\04_Expressions.html#array_literal_items"><em>数组字面量项列表</em></a><br><em>数组字面量项</em> → <a href="..\chapter3\04_Expressions.html#expression"><em>表达式</em></a><br><em>字典字面量</em> → <strong>[</strong> <a href="..\chapter3\04_Expressions.html#dictionary_literal_items"><em>字典字面量项列表</em></a> <strong>]</strong> | <strong>[</strong> <strong>:</strong> <strong>]</strong><br><em>字典字面量项列表</em> → <a href="..\chapter3\04_Expressions.html#dictionary_literal_item"><em>字典字面量项</em></a> <strong>,</strong> <em>可选</em> | <a href="..\chapter3\04_Expressions.html#dictionary_literal_item"><em>字典字面量项</em></a> <strong>,</strong> <a href="..\chapter3\04_Expressions.html#dictionary_literal_items"><em>字典字面量项列表</em></a><br><em>字典字面量项</em> → <a href="..\chapter3\04_Expressions.html#expression"><em>表达式</em></a> <strong>:</strong> <a href="..\chapter3\04_Expressions.html#expression"><em>表达式</em></a> </p>
</blockquote>
<h3 id="self-self-expression-">self表达式（Self Expression）</h3>
<p>self表达式是对 当前type 或者当前instance的引用。它的形式如下：</p>
<blockquote>
<p>self
self.<code>member name</code>
self[<code>subscript index</code>]
self（<code>initializer arguments</code>）
self.init（<code>initializer arguments</code>）</p>
<p>self<br>self.<code>member name</code><br>self[<code>subscript index</code>]<br>self（<code>initializer arguments</code>）<br>self.init（<code>initializer arguments</code>） </p>
</blockquote>
<p>如果在 initializer, subscript, instance method中，self等同于当前type的instance. 在一个静态方法（static method）, 类方法（class method）中， self等同于当前的type.</p>
<p>当访问 member（成员变量时）， self 用来区分重名变量（例如函数的参数）. 例如，
@ -899,31 +872,23 @@ self.init（<code>initializer arguments</code>）</p>
}
</code></pre>
<blockquote>
<p>self表达式的语法</p>
<p><em>self-expression</em> → self­
<em>self-expression</em> → self­.­<em>identifier</em>­
<em>self-expression</em> → self­[­<em>expression</em>­]­
<em>self-expression</em> → self­.­init­</p>
<p>Self 表达式语法<br><em>self表达式</em> → <strong>self</strong><br><em>self表达式</em> → <strong>self</strong> <strong>.</strong> <a href="LexicalStructure.html#identifier"><em>标识符</em></a><br><em>self表达式</em> → <strong>self</strong> <strong>[</strong> <a href="..\chapter3\04_Expressions.html#expression"><em>表达式</em></a> <strong>]</strong><br><em>self表达式</em> → <strong>self</strong> <strong>.</strong> <strong>init</strong> </p>
</blockquote>
<h3 id="-superclass-expression-">超类表达式（Superclass Expression）</h3>
<p>超类表达式可以使我们在某个class中访问它的超类. 它有如下形式：</p>
<pre><code>super.`member name`
super[`subscript index`]
super.init（`initializer arguments`）
</code></pre><p>形式1 用来访问超类的某个成员（member）. 形式2 用来访问该超类的 subscript 实现。 形式3 用来访问该超类的 initializer.</p>
<blockquote>
<p>super.<code>member name</code><br>super[<code>subscript index</code>]<br>super.init（<code>initializer arguments</code>） </p>
</blockquote>
<p>形式1 用来访问超类的某个成员（member）. 形式2 用来访问该超类的 subscript 实现。 形式3 用来访问该超类的 initializer.</p>
<p>子类（subclass）可以通过超类（superclass）表达式在它们的 member, subscripting 和 initializers 中来利用它们超类中的某些实现（既有的方法或者逻辑）。</p>
<blockquote>
<p>GRAMMAR OF A SUPERCLASS EXPRESSION</p>
<p><em>superclass-expression</em> → <em>superclass-method-expression</em> | <em>superclass-subscript-expression</em>­| <em>superclass-initializer-expression</em>
<em>superclass-method-expression</em> → super­.­<em>identifier</em>
<em>superclass-subscript-expression</em> → super­[­<em>expression</em>­]­
<em>superclass-initializer-expression</em> → super­.­init­</p>
<p>超类(superclass)表达式语法<br><em>超类表达式</em> → <a href="..\chapter3\04_Expressions.html#superclass_method_expression"><em>超类方法表达式</em></a> | <a href="..\chapter3\04_Expressions.html#超类下标表达式"><em>超类下标表达式</em></a> | <a href="..\chapter3\04_Expressions.html#superclass_initializer_expression"><em>超类构造器表达式</em></a><br><em>超类方法表达式</em> → <strong>super</strong> <strong>.</strong> <a href="LexicalStructure.html#identifier"><em>标识符</em></a><br><em>超类下标表达式</em> → <strong>super</strong> <strong>[</strong> <a href="..\chapter3\04_Expressions.html#expression"><em>表达式</em></a> <strong>]</strong><br><em>超类构造器表达式</em> → <strong>super</strong> <strong>.</strong> <strong>init</strong> </p>
</blockquote>
<h3 id="-closure-expression-">闭包表达式（Closure Expression）</h3>
<p>闭包（closure） 表达式可以建立一个闭包（在其他语言中也叫 lambda, 或者 匿名函数（anonymous function））. 跟函数（function）的声明一样， 闭包（closure）包含了可执行的代码（跟方法主体（statement）类似） 以及接收（capture）的参数。 它的形式如下：</p>
<pre><code class="lang-swift"> { （parameters） -&gt; return type in
statements
}
<pre><code class="lang-swift">{ （parameters） -&gt; return type in
statements
}
</code></pre>
<p>闭包的参数声明形式跟方法中的声明一样, 请参见：Function Declaration.</p>
<p>闭包还有几种特殊的形式, 让使用更加简洁：</p>
@ -960,36 +925,28 @@ myFunction { [weak parent = self.parent] in print（parent!.title） }
</code></pre>
<p>关于闭包表达式的更多信息和例子，请参见： Closure Expressions.</p>
<blockquote>
<p>闭包表达式的语法</p>
<p><em>closure-expression</em> → {­<em>closure-signature</em>­opt­<em>statements</em>­}­
<em>closure-signature</em> → <em>parameter-clause</em>­<em>function-result</em>­(opt)­in­
<em>closure-signature</em> → <em>identifier-list</em>­<em>function-result</em>­(opt)­in­
<em>closure-signature</em> → <em>capture-list</em>­<em>parameter-clause</em>­<em>function-result</em>­(opt)­in­
<em>closure-signature</em> → <em>capture-list</em>­<em>identifier-list</em>­<em>function-result</em>­(opt)­in­
<em>closure-signature</em> → <em>capture-list</em>­in­
<em>capture-list</em> → [­<em>capture-specifier</em>­<em>expression</em>­]­
<em>capture-specifier</em> → weak­| unowned­| unowned（safe）­| unowned（unsafe）­</p>
<p>闭包表达式语法<br><em>闭包表达式</em> → <strong>{</strong> <a href="..\chapter3\04_Expressions.html#closure_signature"><em>闭包签名(Signational)</em></a> <em>可选</em> <a href="..\chapter3\10_Statements.html#statements"><em>多条语句(Statements)</em></a> <strong>}</strong><br><em>闭包签名(Signational)</em> → <a href="..\chapter3\05_Declarations.html#parameter_clause"><em>参数子句</em></a> <a href="..\chapter3\05_Declarations.html#function_result"><em>函数结果</em></a> <em>可选</em> <strong>in</strong><br><em>闭包签名(Signational)</em> → <a href="LexicalStructure.html#identifier_list"><em>标识符列表</em></a> <a href="..\chapter3\05_Declarations.html#function_result"><em>函数结果</em></a> <em>可选</em> <strong>in</strong><br><em>闭包签名(Signational)</em> → <a href="..\chapter3\04_Expressions.html#capture_list"><em>捕获(Capature)列表</em></a> <a href="..\chapter3\05_Declarations.html#parameter_clause"><em>参数子句</em></a> <a href="..\chapter3\05_Declarations.html#function_result"><em>函数结果</em></a> <em>可选</em> <strong>in</strong><br><em>闭包签名(Signational)</em> → <a href="..\chapter3\04_Expressions.html#capture_list"><em>捕获(Capature)列表</em></a> <a href="LexicalStructure.html#identifier_list"><em>标识符列表</em></a> <a href="..\chapter3\05_Declarations.html#function_result"><em>函数结果</em></a> <em>可选</em> <strong>in</strong><br><em>闭包签名(Signational)</em> → <a href="..\chapter3\04_Expressions.html#capture_list"><em>捕获(Capature)列表</em></a> <strong>in</strong><br><em>捕获(Capature)列表</em> → <strong>[</strong> <a href="..\chapter3\04_Expressions.html#capture_specifier"><em>捕获(Capature)说明符</em></a> <a href="..\chapter3\04_Expressions.html#expression"><em>表达式</em></a> <strong>]</strong><br><em>捕获(Capature)说明符</em> → <strong>weak</strong> | <strong>unowned</strong> | <strong>unowned(safe)</strong> | <strong>unowned(unsafe)</strong> </p>
</blockquote>
<h3 id="-implicit-member-expression-">隐式成员表达式（Implicit Member Expression）</h3>
<p>在可以判断出类型（type）的上下文（context）中，隐式成员表达式是访问某个type的member（ 例如 class method, enumeration case） 的简洁方法。 它的形式是：</p>
<blockquote>
<p>.<code>member name</code></p>
</blockquote>
<p>例子：</p>
<pre><code class="lang-swift">var x = MyEnumeration.SomeValue
x = .AnotherValue
</code></pre>
<blockquote>
<p> 隐式成员表达式的语法</p>
<p> <em>implicit-member-expression</em> → .­<em>identifier</em></p>
<p>隐式成员表达式语法<br><em>隐式成员表达式</em> → <strong>.</strong> <a href="..\chapter3\02_Lexical_Structure.html#identifier"><em>标识符</em></a> </p>
</blockquote>
<h3 id="-parenthesized-expression-">圆括号表达式（Parenthesized Expression）</h3>
<p>圆括号表达式由多个子表达式和逗号&#39;,&#39;组成。 每个子表达式前面可以有 identifier x: 这样的可选前缀。形式如下：</p>
<blockquote>
<p>（<code>identifier 1</code>: <code>expression 1</code>, <code>identifier 2</code>: <code>expression 2</code>, <code>...</code>）</p>
</blockquote>
<p>圆括号表达式用来建立tuples ， 然后把它做为参数传递给 function. 如果某个圆括号表达式中只有一个 子表达式，那么它的type就是 子表达式的type。例如： （1）的 type是Int, 而不是（Int）</p>
<blockquote>
<p>圆括号表达式的语法</p>
<p><em>parenthesized-expression</em> → （­<em>expression-element-list</em> (opt)­）­
<em>expression-element-list</em> → <em>expression-element</em>­| <em>expression-element</em>­,­<em>expression-element-list</em>­
<em>expression-element</em> → <em>expression</em>­| <em>identifier</em>­:­<em>expression</em></p>
<p>圆括号表达式(Parenthesized Expression)语法<br><em>圆括号表达式</em> → <strong>(</strong> <a href="..\chapter3\04_Expressions.html#expression_element_list"><em>表达式元素列表</em></a> <em>可选</em> <strong>)</strong><br><em>表达式元素列表</em> → <a href="..\chapter3\04_Expressions.html#expression_element"><em>表达式元素</em></a> | <a href="..\chapter3\04_Expressions.html#expression_element"><em>表达式元素</em></a> <strong>,</strong> <a href="..\chapter3\04_Expressions.html#expression_element_list"><em>表达式元素列表</em></a><br><em>表达式元素</em> → <a href="..\chapter3\04_Expressions.html#expression"><em>表达式</em></a> | <a href="..\chapter3\02_Lexical_Structure.html#identifier"><em>标识符</em></a> <strong>:</strong> <a href="..\chapter3\04_Expressions.html#expression"><em>表达式</em></a> </p>
</blockquote>
<h3 id="-wildcard-expression-">通配符表达式（Wildcard Expression）</h3>
<p>通配符表达式用来忽略传递进来的某个参数。例如：下面的代码中，10被传递给x, 20被忽略（译注：好奇葩的语法。。。）</p>
@ -997,8 +954,7 @@ x = .AnotherValue
// x is 10, 20 is ignored
</code></pre>
<blockquote>
<p>通配符表达式的语法</p>
<p><em>wildcard-expression</em> → _­</p>
<p>通配符表达式语法<br><em>通配符表达式</em> → <strong>_</strong> </p>
</blockquote>
<p><a name="postfix_expressions"></a></p>
<h2 id="-postfix-expressions-">后缀表达式（Postfix Expressions）</h2>
@ -1010,25 +966,19 @@ x = .AnotherValue
</ul>
<p>对于这些操作符的使用，请参见： Basic Operators and Advanced Operators</p>
<blockquote>
<p>后缀表达式的语法</p>
<p><em>postfix-expression</em> → <em>primary-expression</em>
<em>postfix-expression</em> → <em>postfix-expression</em>­<em>postfix-operator</em>
<em>postfix-expression</em> → <em>function-call-expression</em>­
<em>postfix-expression</em> → <em>initializer-expression</em>­
<em>postfix-expression</em> → <em>explicit-member-expression</em>­
<em>postfix-expression</em> → <em>postfix-self-expression</em>­
<em>postfix-expression</em> → <em>dynamic-type-expression</em>­
<em>postfix-expression</em> → <em>subscript-expression</em>­
<em>postfix-expression</em> → <em>forced-value-expression</em>­
<em>postfix-expression</em> → <em>optional-chaining-expression</em>­</p>
<p>后置表达式语法<br><em>后置表达式</em> → <a href="..\chapter3\04_Expressions.html#primary_expression"><em>主表达式</em></a><br><em>后置表达式</em> → <a href="..\chapter3\04_Expressions.html#postfix_expression"><em>后置表达式</em></a> <a href="..\chapter3\02_Lexical_Structure.html#postfix_operator"><em>后置运算符</em></a><br><em>后置表达式</em> → <a href="..\chapter3\04_Expressions.html#function_call_expression"><em>函数调用表达式</em></a><br><em>后置表达式</em> → <a href="..\chapter3\04_Expressions.html#initializer_expression"><em>构造器表达式</em></a><br><em>后置表达式</em> → <a href="..\chapter3\04_Expressions.html#explicit_member_expression"><em>显示成员表达式</em></a><br><em>后置表达式</em> → <a href="..\chapter3\04_Expressions.html#postfix_self_expression"><em>后置self表达式</em></a><br><em>后置表达式</em> → <a href="..\chapter3\04_Expressions.html#dynamic_type_expression"><em>动态类型表达式</em></a><br><em>后置表达式</em> → <a href="..\chapter3\04_Expressions.html#subscript_expression"><em>下标表达式</em></a><br><em>后置表达式</em> → <a href="..\chapter3\04_Expressions.html#forced_value_expression"><em>强制取值(Forced Value)表达式</em></a><br><em>后置表达式</em> → <a href="..\chapter3\04_Expressions.html#optional_chaining_expression"><em>可选链(Optional Chaining)表达式</em></a> </p>
</blockquote>
<h3 id="-function-call-expression-">函数调用表达式（Function Call Expression）</h3>
<p>函数调用表达式由函数名和参数列表组成。它的形式如下：</p>
<blockquote>
<p><code>function name</code>（<code>argument value 1</code>, <code>argument value 2</code>）</p>
</blockquote>
<p>The function name can be any expression whose value is of a function type.
（不用翻译了, 太罗嗦）</p>
<p>如果该function 的声明中指定了参数的名字，那么在调用的时候也必须得写出来. 例如：</p>
<blockquote>
<p><code>function name</code>（<code>argument name 1</code>: <code>argument value 1</code>, <code>argument name 2</code>: <code>argument value 2</code>）</p>
</blockquote>
<p>可以在 函数调用表达式的尾部（最后一个参数之后）加上 一个闭包（closure） ， 该闭包会被目标函数理解并执行。它具有如下两种写法：</p>
<pre><code class="lang-swift">// someFunction takes an integer and a closure as its arguments
someFunction（x, {$0 == 13}）
@ -1040,23 +990,19 @@ myData.someMethod（） {$0 == 13}
myData.someMethod {$0 == 13}
</code></pre>
<blockquote>
<p>GRAMMAR OF A FUNCTION CALL EXPRESSION</p>
<p><em>function-call-expression</em> → <em>postfix-expression</em>­<em>parenthesized-expression</em>
<em>function-call-expression</em> → <em>postfix-expression</em>­<em>parenthesized-expression</em>­(opt)­<em>trailing-closure</em>­
<em>trailing-closure</em> → <em>closure-expression</em>­</p>
<p>函数调用表达式语法<br><em>函数调用表达式</em> → <a href="..\chapter3\04_Expressions.html#postfix_expression"><em>后置表达式</em></a> <a href="..\chapter3\04_Expressions.html#parenthesized_expression"><em>圆括号表达式</em></a><br><em>函数调用表达式</em> → <a href="..\chapter3\04_Expressions.html#postfix_expression"><em>后置表达式</em></a> <a href="..\chapter3\04_Expressions.html#parenthesized_expression"><em>圆括号表达式</em></a> <em>可选</em> <a href="..\chapter3\04_Expressions.html#trailing_closure"><em>后置闭包(Trailing Closure)</em></a><br><em>后置闭包(Trailing Closure)</em> → <a href="..\chapter3\04_Expressions.html#closure_expression"><em>闭包表达式</em></a> </p>
</blockquote>
<h3 id="-initializer-expression-">初始化函数表达式（Initializer Expression）</h3>
<p>Initializer表达式用来给某个Type初始化。 它的形式如下：</p>
<blockquote>
<p><code>expression</code>.init（<code>initializer arguments</code>）</p>
</blockquote>
<p>（Initializer表达式用来给某个Type初始化。） 跟函数（function）不同， initializer 不能返回值。</p>
<pre><code class="lang-swift">var x = SomeClass.someClassFunction // ok
var y = SomeClass.init // error
```swift
可以通过 initializer 表达式来委托调用（delegate to ）到superclass的initializers.
```swift
class SomeSubClass: SomeSuperClass {
</code></pre>
<p>可以通过 initializer 表达式来委托调用（delegate to ）到superclass的initializers.</p>
<pre><code class="lang-swift">class SomeSubClass: SomeSuperClass {
init（） {
// subclass initialization goes here
super.init（）
@ -1064,12 +1010,13 @@ class SomeSubClass: SomeSuperClass {
}
</code></pre>
<blockquote>
<p>initializer表达式的语法</p>
<p><em>initializer-expression</em> → <em>postfix-expression</em>­.­init­</p>
<p>构造器表达式语法<br><em>构造器表达式</em> → <a href="..\chapter3\04_Expressions.html#postfix_expression"><em>后置表达式</em></a> <strong>.</strong> <strong>init</strong> </p>
</blockquote>
<h3 id="-explicit-member-expression-">显式成员表达式（Explicit Member Expression）</h3>
<p>显示成员表达式允许我们访问type, tuple, module的成员变量。它的形式如下：</p>
<blockquote>
<p><code>expression</code>.<code>member name</code></p>
</blockquote>
<p>该member 就是某个type在声明时候所定义（declaration or extension） 的变量, 例如：</p>
<pre><code class="lang-swift">class SomeClass {
var someProperty = 42
@ -1085,24 +1032,24 @@ t.0 = t.1
<p>The members of a module access the top-level declarations of that module.
（不确定：对于某个module的member的调用，只能调用在top-level声明中的member.）</p>
<blockquote>
<p>显示成员表达式的语法</p>
<p><em>explicit-member-expression</em> → <em>postfix-expression</em>­.­<em>decimal-digit</em>­
<em>explicit-member-expression</em> → <em>postfix-expression</em>­.­<em>identifier</em>­<em>generic-argument-clause</em>(opt)</p>
<p>显式成员表达式语法<br><em>显示成员表达式</em> → <a href="..\chapter3\04_Expressions.html#postfix_expression"><em>后置表达式</em></a> <strong>.</strong> <a href="..\chapter3\02_Lexical_Structure.html#decimal_digit"><em>十进制数字</em></a><br><em>显示成员表达式</em> → <a href="..\chapter3\04_Expressions.html#postfix_expression"><em>后置表达式</em></a> <strong>.</strong> <a href="..\chapter3\02_Lexical_Structure.html#identifier"><em>标识符</em></a> <a href="GenericParametersAndArguments.html#generic_argument_clause"><em>泛型参数子句</em></a> <em>可选</em> </p>
</blockquote>
<h3 id="-self-postfix-self-expression-">后缀self表达式（Postfix Self Expression）</h3>
<p>后缀表达式由 某个表达式 + &#39;.self&#39; 组成. 形式如下：</p>
<p><code>expression</code>.self
<code>type</code>.self</p>
<blockquote>
<p><code>expression</code>.self<br><code>type</code>.self </p>
</blockquote>
<p>形式1 表示会返回 expression 的值。例如： x.self 返回 x</p>
<p>形式2：返回对应的type。我们可以用它来动态的获取某个instance的type。</p>
<blockquote>
<p>后缀self表达式的语法</p>
<p><em>postfix-self-expression</em> → <em>postfix-expression</em>­.­self­</p>
<p>后置Self 表达式语法<br><em>后置self表达式</em> → <a href="..\chapter3\04_Expressions.html#postfix_expression"><em>后置表达式</em></a> <strong>.</strong> <strong>self</strong> </p>
</blockquote>
<h3 id="dynamic-dynamic-type-expression-">dynamic表达式（Dynamic Type Expression）</h3>
<p>（因为dynamicType是一个独有的方法，所以这里保留了英文单词，未作翻译, --- 类似与self expression）</p>
<p>dynamicType 表达式由 某个表达式 + &#39;.dynamicType&#39; 组成。</p>
<blockquote>
<p><code>expression</code>.dynamicType</p>
</blockquote>
<p>上面的形式中， expression 不能是某type的名字（当然了，如果我都知道它的名字了还需要动态来获取它吗）。动态类型表达式会返回&quot;运行时&quot;某个instance的type, 具体请看下面的列子：</p>
<pre><code class="lang-swift">class SomeBaseClass {
class func printClassName（） {
@ -1122,29 +1069,32 @@ someInstance.dynamicType.printClassName（）
// prints &quot;SomeSubClass&quot;
</code></pre>
<blockquote>
<p>dynamic type 表达式</p>
<p><em>dynamic-type-expression</em> → <em>postfix-expression</em>­.­dynamicType­</p>
<p>动态类型表达式语法<br><em>动态类型表达式</em> → <a href="..\chapter3\04_Expressions.html#postfix_expression"><em>后置表达式</em></a> <strong>.</strong> <strong>dynamicType</strong> </p>
</blockquote>
<h3 id="-subscript-expression-">下标脚本表达式（Subscript Expression）</h3>
<p>下标脚本表达式提供了通过下标脚本访问getter/setter 的方法。它的形式是：</p>
<blockquote>
<p><code>expression</code>[<code>index expressions</code>]</p>
</blockquote>
<p>可以通过下标脚本表达式通过getter获取某个值，或者通过setter赋予某个值.</p>
<p>关于subscript的声明，请参见： Protocol Subscript Declaration.</p>
<blockquote>
<p>下标脚本表达式的语法</p>
<p><em>subscript-expression</em> → <em>postfix-expression</em>­[­<em>expression-list</em>­]­</p>
<p>附属脚本表达式语法<br><em>附属脚本表达式</em> → <a href="..\chapter3\04_Expressions.html#postfix_expression"><em>后置表达式</em></a> <strong>[</strong> <a href="..\chapter3\04_Expressions.html#expression_list"><em>表达式列表</em></a> <strong>]</strong> </p>
</blockquote>
<h3 id="-forced-value-expression-">强制取值表达式（Forced-Value Expression）</h3>
<p>强制取值表达式用来获取某个目标表达式的值（该目标表达式的值必须不是nil ）。它的形式如下：</p>
<blockquote>
<p><code>expression</code>!</p>
</blockquote>
<p>如果该表达式的值不是nil, 则返回对应的值。 否则，抛出运行时错误（runtime error）。</p>
<blockquote>
<p>强制取值表达式的语法</p>
<p><em>forced-value-expression</em> → <em>postfix-expression</em>­!­</p>
<p>强制取值(Forced Value)语法<br><em>强制取值(Forced Value)表达式</em> → <a href="..\chapter3\04_Expressions.html#postfix_expression"><em>后置表达式</em></a> <strong>!</strong> </p>
</blockquote>
<h3 id="-optional-chaining-expression-">可选链表达式（Optional-Chaining Expression）</h3>
<p>可选链表达式由目标表达式 + &#39;?&#39; 组成，形式如下：</p>
<blockquote>
<p><code>expression</code>?</p>
</blockquote>
<p>后缀&#39;?&#39; 返回目标表达式的值，把它做为可选的参数传递给后续的表达式</p>
<p>如果某个后缀表达式包含了可选链表达式，那么它的执行过程就比较特殊： 首先先判断该可选链表达式的值，如果是 nil, 整个后缀表达式都返回 nil, 如果该可选链的值不是nil, 则正常返回该后缀表达式的值（依次执行它的各个子表达式）。在这两种情况下，该后缀表达式仍然是一个optional type（In either case, the value of the postfix expression is still of an optional type）</p>
<p>如果某个&quot;后缀表达式&quot;的&quot;子表达式&quot;中包含了&quot;可选链表达式&quot;，那么只有最外层的表达式返回的才是一个optional type. 例如，在下面的例子中， 如果c 不是nil, 那么 c?.property.performAction（） 这句代码在执行时，就会先获得c 的property方法，然后调用 performAction（）方法。 然后对于 &quot;c?.property.performAction（）&quot; 这个整体，它的返回值是一个optional type.</p>
@ -1157,8 +1107,7 @@ var result: Bool? = c?.property.performAction（）
}
</code></pre>
<blockquote>
<p>可选链表达式的语法</p>
<p><em>optional-chaining-expression</em> → <em>postfix-expression</em>­?­</p>
<p>可选链表达式语法<br><em>可选链表达式</em> → <a href="..\chapter3\04_Expressions.html#postfix_expression"><em>后置表达式</em></a> <strong>?</strong> </p>
</blockquote>

296
chapter3/05_Declarations.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="3.6" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="3.6" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,11 +587,10 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_91">
<section class="normal" id="section-gitbook_565">
<blockquote>
<p>翻译：marsprince</p>
<p>校对：numbbbbb, stanzhai</p>
<p>翻译：marsprince<br>校对：numbbbbb, stanzhai </p>
</blockquote>
<h1 id="-">声明</h1>
<hr>
@ -632,10 +631,10 @@
<p><a name="code_blocks"></a></p>
<h2 id="-">代码块</h2>
<p>代码块用来将一些声明和控制结构的语句组织在一起。它有如下的形式：</p>
<pre><code>{
`statements`
}
</code></pre><p>代码块中的语句包括声明，表达式和各种其他类型的语句，它们按照在源码中的出现顺序被依次执行。</p>
<blockquote>
<p>{<br> <code>statements</code><br>} </p>
</blockquote>
<p>代码块中的语句包括声明，表达式和各种其他类型的语句，它们按照在源码中的出现顺序被依次执行。</p>
<blockquote>
<p>代码块语法<br><em>代码块</em> → <strong>{</strong> <a href="..\chapter3\10_Statements.html#statements"><em>多条语句(Statements)</em></a> <em>可选</em> <strong>}</strong> </p>
</blockquote>
@ -643,30 +642,39 @@
<h2 id="-">引入声明</h2>
<p>引入声明使你可以使用在其他文件中声明的内容。引入语句的基本形式是引入整个代码模块；它由import关键字开始，后面
紧跟一个模块名：</p>
<pre><code>import module
</code></pre><p>你可以提供更多的细节来限制引入的符号，如声明一个特殊的子模块或者在一个模块或子模块中做特殊的声明。（待改进）
<blockquote>
<p>import <code>module</code></p>
</blockquote>
<p>你可以提供更多的细节来限制引入的符号，如声明一个特殊的子模块或者在一个模块或子模块中做特殊的声明。（待改进）
当你使用了这些细节后，在当前的程序汇总只有引入的符号是可用的（并不是声明的整个模块）。</p>
<pre><code>import import kind module.symbol name
import module.submodule
</code></pre><blockquote>
<blockquote>
<p>import <code>import kind</code> <code>module</code>.<code>symbol name</code><br>import <code>module</code>.<code>submodule</code> </p>
</blockquote>
<p></p>
<blockquote>
<p>导入(Import)声明语法<br><em>导入声明</em> → <a href="..\chapter3\06_Attributes.html#attributes"><em>特性(Attributes)列表</em></a> <em>可选</em> <strong>import</strong> <a href="..\chapter3\05_Declarations.html#import_kind"><em>导入类型</em></a> <em>可选</em> <a href="..\chapter3\05_Declarations.html#import_path"><em>导入路径</em></a><br><em>导入类型</em> → <strong>typealias</strong> | <strong>struct</strong> | <strong>class</strong> | <strong>enum</strong> | <strong>protocol</strong> | <strong>var</strong> | <strong>func</strong><br><em>导入路径</em> → <a href="..\chapter3\05_Declarations.html#import_path_identifier"><em>导入路径标识符</em></a> | <a href="..\chapter3\05_Declarations.html#import_path_identifier"><em>导入路径标识符</em></a> <strong>.</strong> <a href="..\chapter3\05_Declarations.html#import_path"><em>导入路径</em></a><br><em>导入路径标识符</em> → <a href="LexicalStructure.html#identifier"><em>标识符</em></a> | <a href="LexicalStructure.html#operator"><em>运算符</em></a> </p>
</blockquote>
<p><a name="constant_declaration"></a></p>
<h2 id="-">常量声明</h2>
<p>常量声明可以在你的程序里命名一个常量。常量以关键词let来声明，遵循如下的格式:</p>
<pre><code>let constant name: type = expression
</code></pre><p>当常量的值被给定后，常量就将常量名称和表达式初始值不变的结合在了一起，而且不能更改。
<blockquote>
<p>let <code>constant name</code>: <code>type</code> = <code>expression</code></p>
</blockquote>
<p>当常量的值被给定后，常量就将常量名称和表达式初始值不变的结合在了一起，而且不能更改。
这意味着如果常量以类的形式被初始化，类本身的内容是可以改变的，但是常量和类之间的结合关系是不能改变的。
当一个常量被声明为全局变量，它必须被给定一个初始值。当一个常量在类或者结构体中被声明时，它被认为是一个常量
属性。常量并不是可计算的属性，因此不包含getters和setters。（译者注：getters和setters不知道怎么翻译，待改进）</p>
<p>如果常量名是一个元祖形式，元祖中的每一项初始化表达式中都要有对应的值</p>
<pre><code>let (firstNumber, secondNumber) = (10, 42)
</code></pre><p>在上例中，firstNumber是一个值为10的常量，secnodeName是一个值为42的常量。所有常量都可以独立的使用：</p>
<pre><code>println(&quot;The first number is \(firstNumber).&quot;)
<pre><code class="lang-swift">let (firstNumber, secondNumber) = (10, 42)
</code></pre>
<p>在上例中，firstNumber是一个值为10的常量，secnodeName是一个值为42的常量。所有常量都可以独立的使用：</p>
<pre><code class="lang-swift">println(&quot;The first number is \(firstNumber).&quot;)
// prints &quot;The first number is 10.&quot;
println(&quot;The second number is \(secondNumber).&quot;)
// prints &quot;The second number is 42.&quot;
</code></pre><p>类型注释（:type）在常量声明中是一个可选项，它可以用来描述在类型推断（type inference）中找到的类型。</p>
</code></pre>
<p>类型注释（:type）在常量声明中是一个可选项，它可以用来描述在类型推断（type inference）中找到的类型。</p>
<p>声明一个静态常量要使用关键字static。静态属性在类型属性（type propetries）中有介绍。</p>
<p>如果还想获得更多关于常量的信息或者想在使用中获得帮助，请查看常量和变量（constants and variables）,
存储属性（stored properties）等节。</p>
@ -679,28 +687,24 @@ println(&quot;The second number is \(secondNumber).&quot;)
变量和属性，存储变量和属性监视，和静态变量属性，有着不同的声明形式。（待改进）
所使用的声明形式取决于变量所声明的范围和你打算声明的变量类型。</p>
<blockquote>
<p>注意：</p>
<p>你也可以在协议声明的上下文声明属性，详情参见类型属性声明。</p>
<p>注意：<br>你也可以在协议声明的上下文声明属性，详情参见类型属性声明。</p>
</blockquote>
<h3 id="-">存储型变量和存储型属性</h3>
<p>下面的形式声明了一个存储型变量或存储型变量属性</p>
<pre><code>var variable name: type = expression
</code></pre><p>你可以在全局，函数内，或者在类和结构体的声明(context)中使用这种形式来声明一个变量。当变量以这种形式
<blockquote>
<p>var <code>variable name</code>: <code>type</code> = <code>expression</code></p>
</blockquote>
<p>你可以在全局，函数内，或者在类和结构体的声明(context)中使用这种形式来声明一个变量。当变量以这种形式
在全局或者一个函数内被声明时，它代表一个存储型变量。当它在类或者结构体中被声明时，它代表一个存储型变量属性。</p>
<p>构造器表达式可以被</p>
<p>和常量声明相比，如果变量名是一个元祖类型，元祖的每一项的名字都要和初始化表达式一致。</p>
<p>正如名字一样，存储型变量的值或存储型变量属性存储在内存中。</p>
<h3 id="-">计算型变量和计算型属性</h3>
<p>如下形式声明一个一个存储型变量或存储型属性：</p>
<pre><code>var variable name: type {
get {
statements
}
set(setter name) {
statements
}
}
</code></pre><p>你可以在全局，函数体内或者类，结构体，枚举，扩展声明的上下文中使用这种形式的声明。
<blockquote>
<p>var <code>variable name</code>: <code>type</code> {<br>get {<br> <code>statements</code><br>}<br>set(<code>setter name</code>) {<br> <code>statements</code><br>}<br>} </p>
</blockquote>
<p>你可以在全局，函数体内或者类，结构体，枚举，扩展声明的上下文中使用这种形式的声明。
当变量以这种形式在全局或者一个函数内被声明时，它代表一个计算型变量。当它在类，结构体，枚举，扩展声明的上下文
中中被声明时，它代表一个计算型变量属性。</p>
<p>getter用来读取变量值，setter用来写入变量值。setter子句是可选择的，只有getter是必需的，你可以将这些语句
@ -712,15 +716,10 @@ setter的初始名为newValue，正如在seter声明速记(shorthand setter decl
<p>获得更多信息，查看更多关于计算型属性的例子，请查看计算型属性(computed properties)一节。</p>
<h3 id="-">存储型变量监视器和属性监视器</h3>
<p>你可以用willset和didset监视器来声明一个存储型变量或属性。一个包含监视器的存储型变量或属性按如下的形式声明：</p>
<pre><code>var variable name: type = expression {
willSet(setter name) {
statements
}
didSet(setter name {
statements
}
}
</code></pre><p>你可以在全局，函数体内或者类，结构体，枚举，扩展声明的上下文中使用这种形式的声明。
<blockquote>
<p>var <code>variable name</code>: <code>type</code> = expression {<br>willSet(setter name) {<br> <code>statements</code><br>}<br>didSet(<code>setter name</code>) {<br> <code>statements</code><br>}<br>} </p>
</blockquote>
<p>你可以在全局，函数体内或者类，结构体，枚举，扩展声明的上下文中使用这种形式的声明。
当变量以这种形式在全局或者一个函数内被声明时，监视器代表一个存储型变量监视器；
当它在类，结构体，枚举，扩展声明的上下文中被声明时，监视器代表属性监视器。</p>
<p>你可以为适合的监视器添加任何存储型属性。你也可以通过重写子类属性的方式为适合的监视器添加任何继承的属性
@ -746,8 +745,10 @@ willset监视器初始名为newvalue，didset监视器初始名为oldvalue。</p
<h2 id="-">类型的别名声明</h2>
<p>类型别名的声明可以在你的程序里为一个已存在的类型声明一个别名。类型的别名声明以关键字typealias开始，遵循如下的
形式：</p>
<pre><code>typealias name = existing type
</code></pre><p>当一个类型被别名被声明后，你可以在你程序的任何地方使用别名来代替已存在的类型。已存在的类型可以是已经被命名的
<blockquote>
<p><code>typealias name</code> = <code>existing type</code></p>
</blockquote>
<p>当一个类型被别名被声明后，你可以在你程序的任何地方使用别名来代替已存在的类型。已存在的类型可以是已经被命名的
类型或者是混合类型。类型的别名不产生新的类型，它只是简单的和已存在的类型做名称替换。</p>
<p>查看更多Protocol Associated Type Declaration.</p>
<blockquote>
@ -757,14 +758,14 @@ willset监视器初始名为newvalue，didset监视器初始名为oldvalue。</p
<h2 id="-">函数声明</h2>
<p>你可以使用函数声明在你的程序里引入新的函数。函数可以在类的上下文，结构体，枚举，或者作为方法的协议中被声明。
函数声明使用关键字func，遵循如下的形式：</p>
<pre><code>func function name(parameters) -&gt; return type {
statements
}
</code></pre><p>如果函数不返回任何值，返回类型可以被忽略，如下所示：</p>
<pre><code>func function name(parameters) {
statements
}
</code></pre><p>每个参数的类型都要标明，它们不能被推断出来。初始时函数的参数是常值。在这些参数前面添加var使它们成为变量，
<blockquote>
<p>func <code>function name</code>(<code>parameters</code>) -&gt; <code>return type</code> {<br> <code>statements</code><br>} </p>
</blockquote>
<p>如果函数不返回任何值，返回类型可以被忽略，如下所示：</p>
<blockquote>
<p>func <code>function name</code>(<code>parameters</code>) {<br> <code>statements</code><br>} </p>
</blockquote>
<p>每个参数的类型都要标明，它们不能被推断出来。初始时函数的参数是常值。在这些参数前面添加var使它们成为变量，
作用域内任何对变量的改变只在函数体内有效，或者用inout使的这些改变可以在调用域内生效。
更多关于in-out参数的讨论，参见in-out参数(in-out parameters)</p>
<p>函数可以使用元组类型作为返回值来返回多个变量。</p>
@ -772,36 +773,39 @@ willset监视器初始名为newvalue，didset监视器初始名为oldvalue。</p
<h3 id="-">参数名</h3>
<p>函数的参数是一个以逗号分隔的列表 。函数调用是的变量顺序必须和函数声明时的参数顺序一致。
最简单的参数列表有着如下的形式：</p>
<pre><code>parameter name: parameter type
</code></pre><p>对于函数参数来讲，参数名在函数体内被使用，而不是在函数调用时使用。对于方法参数，参数名在函数体内被使用，
<blockquote>
<p><code>parameter name</code>: <code>parameter type</code></p>
</blockquote>
<p>对于函数参数来讲，参数名在函数体内被使用，而不是在函数调用时使用。对于方法参数，参数名在函数体内被使用，
同时也在方法被调用时作为标签被使用。该方法的第一个参数名仅仅在函数体内被使用，就像函数的参数一样，举例来讲：</p>
<pre><code>func f(x: Int, y: String) -&gt; String {
<pre><code class="lang-swift">func f(x: Int, y: String) -&gt; String {
return y + String(x)
}
f(7, &quot;hello&quot;) // x and y have no name
class C {
</code></pre>
<pre><code class="lang-swift">class C {
func f(x: Int, y: String) -&gt; String {
return y + String(x)
}
}
let c = C()
c.f(7, y: &quot;hello&quot;) // x没有名称，y有名称
</code></pre><p>你可以按如下的形式，重写参数名被使用的过程：</p>
<pre><code>external parameter name local parameter name: parameter type
#parameter name: parameter type
_ local parameter name: parameter type
</code></pre><p>在本地参数前命名的第二名称(second name)使得参数有一个扩展名。且不同于本地的参数名。
</code></pre>
<p>你可以按如下的形式，重写参数名被使用的过程：</p>
<blockquote>
<p><code>external parameter name</code> <code>local parameter name</code>: <code>parameter type</code><br>&#35;<code>parameter name</code>: <code>parameter type</code><br>_ <code>local parameter name</code>: <code>parameter type</code> </p>
</blockquote>
<p>在本地参数前命名的第二名称(second name)使得参数有一个扩展名。且不同于本地的参数名。
扩展参数名在函数被调用时必须被使用。对应的参数在方法或函数被调用时必须有扩展名 。</p>
<p>在参数名前所写的哈希符号(#)代表着这个参数名可以同时作为外部或本体参数名来使用。等同于书写两次本地参数名。
在函数或方法调用时，与其对应的语句必须包含这个名字。</p>
<p>本地参数名前的强调字符(_)使参数在函数被调用时没有名称。在函数或方法调用时，与其对应的语句必须没有名字。</p>
<h3 id="-">特殊类型的参数</h3>
<p>参数可以被忽略，值可以是变化的，并且提供一个初始值，这种方法有着如下的形式：</p>
<pre><code>_ : &lt;#parameter type#.
parameter name: parameter type...
parameter name: parameter type = default argument value
</code></pre><p>以强调符(_)命名的参数明确的在函数体内不能被访问。</p>
<blockquote>
<p>_ : &lt;#parameter type#.<br><code>parameter name</code>: <code>parameter type</code>...<br><code>parameter name</code>: <code>parameter type</code> = <code>default argument value</code> </p>
</blockquote>
<p>以强调符(_)命名的参数明确的在函数体内不能被访问。</p>
<p>一个以基础类型名的参数，如果紧跟着三个点(...)，被理解为是可变参数。一个函数至多可以拥有一个可变参数，
且必须是最后一个参数。可变参数被作为该基本类型名的数组来看待。举例来讲，可变参数int...被看做是int[]。
查看可变参数的使用例子，详见可变参数(variadic parameters)一节。</p>
@ -815,11 +819,11 @@ f()和f(x:7)都是只有一个变量x的函数的有效调用，但是f(7)是非
<p>和类型相关而不是和类型实例相关的方法必须在static声明的结构以或枚举内，亦或是以class关键字定义的类内。</p>
<h3 id="-">柯里化函数和方法</h3>
<p>柯里化函数或方法有着如下的形式：</p>
<pre><code>func function name(parameters)(parameters) -&gt; return type {
statements
}
</code></pre><p>以这种形式定义的函数的返回值是另一个函数。举例来说，下面的两个声明时等价的:</p>
<pre><code>func addTwoNumbers(a: Int)(b: Int) -&gt; Int {
<blockquote>
<p>func <code>function name</code>(<code>parameters</code>)(<code>parameters</code>) -&gt; <code>return type</code> {<br> <code>statements</code><br>} </p>
</blockquote>
<p>以这种形式定义的函数的返回值是另一个函数。举例来说，下面的两个声明时等价的:</p>
<pre><code class="lang-swift">func addTwoNumbers(a: Int)(b: Int) -&gt; Int {
return a + b
}
func addTwoNumbers(a: Int) -&gt; (Int -&gt; Int) {
@ -828,9 +832,10 @@ func addTwoNumbers(a: Int) -&gt; (Int -&gt; Int) {
}
return addTheSecondNumber
}
addTwoNumbers(4)(5) // Returns 9
</code></pre><p>多级柯里化应用如下</p>
</code></pre>
<pre><code class="lang-swift">addTwoNumbers(4)(5) // Returns 9
</code></pre>
<p>多级柯里化应用如下</p>
<blockquote>
<p>函数声明语法<br><em>函数声明</em> → <a href="..\chapter3\05_Declarations.html#function_head"><em>函数头</em></a> <a href="..\chapter3\05_Declarations.html#function_name"><em>函数名</em></a> <a href="GenericParametersAndArguments.html#generic_parameter_clause"><em>泛型参数子句</em></a> <em>可选</em> <a href="..\chapter3\05_Declarations.html#function_signature"><em>函数签名(Signature)</em></a> <a href="..\chapter3\05_Declarations.html#function_body"><em>函数体</em></a><br><em>函数头</em> → <a href="..\chapter3\06_Attributes.html#attributes"><em>特性(Attributes)列表</em></a> <em>可选</em> <a href="..\chapter3\05_Declarations.html#declaration_specifiers"><em>声明描述符(Specifiers)列表</em></a> <em>可选</em> <strong>func</strong><br><em>函数名</em> → <a href="LexicalStructure.html#identifier"><em>标识符</em></a> | <a href="LexicalStructure.html#operator"><em>运算符</em></a><br><em>函数签名(Signature)</em> → <a href="..\chapter3\05_Declarations.html#parameter_clauses"><em>parameter-clauses</em></a> <a href="..\chapter3\05_Declarations.html#function_result"><em>函数结果</em></a> <em>可选</em><br><em>函数结果</em> → <strong>-&gt;</strong> <a href="..\chapter3\06_Attributes.html#attributes"><em>特性(Attributes)列表</em></a> <em>可选</em> <a href="..\chapter3\03_Types.html#type"><em>类型</em></a><br><em>函数体</em> → <a href="..\chapter3\05_Declarations.html#code_block"><em>代码块</em></a><br><em>parameter-clauses</em> → <a href="..\chapter3\05_Declarations.html#parameter_clause"><em>参数子句</em></a> <a href="..\chapter3\05_Declarations.html#parameter_clauses"><em>parameter-clauses</em></a> <em>可选</em><br><em>参数子句</em> → <strong>(</strong> <strong>)</strong> | <strong>(</strong> <a href="..\chapter3\05_Declarations.html#parameter_list"><em>参数列表</em></a> <strong>...</strong> <em>可选</em> <strong>)</strong><br><em>参数列表</em> → <a href="..\chapter3\05_Declarations.html#parameter"><em>参数</em></a> | <a href="..\chapter3\05_Declarations.html#parameter"><em>参数</em></a> <strong>,</strong> <a href="..\chapter3\05_Declarations.html#parameter_list"><em>参数列表</em></a><br><em>参数</em> → <strong>inout</strong> <em>可选</em> <strong>let</strong> <em>可选</em> <strong>#</strong> <em>可选</em> <a href="..\chapter3\05_Declarations.html#parameter_name"><em>参数名</em></a> <a href="..\chapter3\05_Declarations.html#local_parameter_name"><em>本地参数名</em></a> <em>可选</em> <a href="..\chapter3\03_Types.html#type_annotation"><em>类型注解</em></a> <a href="..\chapter3\05_Declarations.html#default_argument_clause"><em>默认参数子句</em></a> <em>可选</em><br><em>参数</em> → <strong>inout</strong> <em>可选</em> <strong>var</strong> <strong>#</strong> <em>可选</em> <a href="..\chapter3\05_Declarations.html#parameter_name"><em>参数名</em></a> <a href="..\chapter3\05_Declarations.html#local_parameter_name"><em>本地参数名</em></a> <em>可选</em> <a href="..\chapter3\03_Types.html#type_annotation"><em>类型注解</em></a> <a href="..\chapter3\05_Declarations.html#default_argument_clause"><em>默认参数子句</em></a> <em>可选</em><br><em>参数</em> → <a href="..\chapter3\06_Attributes.html#attributes"><em>特性(Attributes)列表</em></a> <em>可选</em> <a href="..\chapter3\03_Types.html#type"><em>类型</em></a><br><em>参数名</em> → <a href="LexicalStructure.html#identifier"><em>标识符</em></a> | <strong>_</strong><br><em>本地参数名</em> → <a href="LexicalStructure.html#identifier"><em>标识符</em></a> | <strong>_</strong><br><em>默认参数子句</em> → <strong>=</strong> <a href="..\chapter3\04_Expressions.html#expression"><em>表达式</em></a> </p>
</blockquote>
@ -847,29 +852,28 @@ addTwoNumbers(4)(5) // Returns 9
<p>你可以扩展枚举类型，正如在扩展名声明(Extension Declaration)中讨论的一样。</p>
<h3 id="-">任意事件类型的枚举</h3>
<p>如下的形式声明了一个包含任意类型枚举时间的枚举变量</p>
<pre><code>enum enumeration name {
case enumeration case 1
case enumeration case 2(associated value types)
}
</code></pre><p>这种形式的枚举声明在其他语言中有时被叫做可识别联合(discrinminated)。</p>
<blockquote>
<p>enum <code>enumeration name</code> {<br> case <code>enumeration case 1</code><br> case <code>enumeration case 2</code>(<code>associated value types</code>)<br>} </p>
</blockquote>
<p>这种形式的枚举声明在其他语言中有时被叫做可识别联合(discrinminated)。</p>
<p>这种形式中，每一个事件块由关键字case开始，后面紧接着一个或多个以逗号分隔的枚举事件。每一个事件名必须是
独一无二的。每一个事件也可以指定它所存储的指定类型的值，这些类型在关联值类型的元祖里被指定，立即书写在事件
名后。获得更多关于关联值类型的信息和例子，请查看关联值(associated values)一节。</p>
<h3 id="-">使用原始事件值的枚举</h3>
<p>以下的形式声明了一个包含相同基础类型的枚举事件的枚举：</p>
<pre><code>enum enumeration name: raw value type {
case enumeration case 1 = raw value 1
case enumeration case 2 = raw value 2
}
</code></pre><p>在这种形式中，每一个事件块由case关键字开始，后面紧接着一个或多个以逗号分隔的枚举事件。和第一种形式的枚举
<blockquote>
<p>enum <code>enumeration name</code>: <code>raw value type</code> {<br> case <code>enumeration case 1</code> = <code>raw value 1</code><br> case <code>enumeration case 2</code> = <code>raw value 2</code><br>} </p>
</blockquote>
<p>在这种形式中，每一个事件块由case关键字开始，后面紧接着一个或多个以逗号分隔的枚举事件。和第一种形式的枚举
事件不同，这种形式的枚举事件包含一个同类型的基础值，叫做原始值(raw value)。这些值的类型在原始值类型(raw value type)
中被指定，必须是字面上的整数，浮点数，字符或者字符串。</p>
<p>每一个事件必须有唯一的名字，必须有一个唯一的初始值。如果初始值类型被指定为int，则不必为事件显式的指定值，
它们会隐式的被标为值0,1,2等。每一个没有被赋值的Int类型时间会隐式的赋予一个初始值，它们是自动递增的。</p>
<pre><code>num ExampleEnum: Int {
<pre><code class="lang-swift">num ExampleEnum: Int {
case A, B, C = 5, D
}
</code></pre><p>在上面的例子中，ExampleEnum.A的值是0，ExampleEnum.B的值是。因为ExampleEnum.C的值被显式的设定为5，因此
</code></pre>
<p>在上面的例子中，ExampleEnum.A的值是0，ExampleEnum.B的值是。因为ExampleEnum.C的值被显式的设定为5，因此
ExampleEnum.D的值会自动增长为6.</p>
<p>枚举事件的初始值可以调用方法roRaw获得，如ExampleEnum.B.toRaw()。你也可以通过调用fromRaw方法来使用初始值找到
其对应的事件，并返回一个可选的事件。查看更多信息和获取初始值类型事件的信息，参阅初始值(raw values)。</p>
@ -884,10 +888,10 @@ ExampleEnum.D的值会自动增长为6.</p>
<p><a name="structure_declaration"></a></p>
<h2 id="-">结构体声明</h2>
<p>使用结构体声明可以在你的程序里引入一个结构体类型。结构体声明使用struct关键字，遵循如下的形式：</p>
<pre><code>struct structure name: adopted protocols {
declarations
}
</code></pre><p>结构体内包含零或多个声明。这些声明可以包括存储型和计算型属性，静态属性，实例方法，静态方法，构造器，
<blockquote>
<p>struct <code>structure name</code>: <code>adopted protocols</code> {<br> <code>declarations</code><br>} </p>
</blockquote>
<p>结构体内包含零或多个声明。这些声明可以包括存储型和计算型属性，静态属性，实例方法，静态方法，构造器，
类型别名，甚至其他结构体，类，和枚举声明。结构体声明不能包含析构器或者协议声明。详细讨论和包含多种结构体
声明的实例，参见类和结构体一节。</p>
<p>结构体可以包含任意数量的协议，但是不能继承自类，枚举或者其他结构体。</p>
@ -906,10 +910,10 @@ ExampleEnum.D的值会自动增长为6.</p>
<p><a name="class_declaration"></a></p>
<h2 id="-">类声明</h2>
<p>你可以在你的程序中使用类声明来引入一个类。类声明使用关键字class，遵循如下的形式：</p>
<pre><code>class class name: superclass, adopted protocols {
declarations
}
</code></pre><p>一个类内包含零或多个声明。这些声明可以包括存储型和计算型属性，实例方法，类方法，构造器，单独的析构器方法，
<blockquote>
<p>class <code>class name</code>: <code>superclass</code>, <code>adopted protocols</code> {<br> <code>declarations</code><br>} </p>
</blockquote>
<p>一个类内包含零或多个声明。这些声明可以包括存储型和计算型属性，实例方法，类方法，构造器，单独的析构器方法，
类型别名，甚至其他结构体，类，和枚举声明。类声明不能包含协议声明。详细讨论和包含多种类声明的实例，参见类和
结构体一节。</p>
<p>一个类只能继承一个父类，超类，但是可以包含任意数量的协议。这些超类第一次在type-inheritance-clause出现，遵循任意协议。</p>
@ -920,8 +924,10 @@ ExampleEnum.D的值会自动增长为6.</p>
<p>虽然超类的属性和方法声明可以被当前类继承，但是超类声明的指定构造器却不能。这意味着，如果当前类重写了超类
的所有指定构造器，它就继承了超类的方便构造器。Swift的类并不是继承自一个全局基础类。</p>
<p>有两种方法来创建已声明的类的实例：</p>
<p>-调用类的一个构造器，参见构造器(initializers)。</p>
<p>-如果没有声明构造器，而且类的所有属性都被赋予了初始值，调用类的默认构造器，参见默认构造器(default initializers).</p>
<ul>
<li>调用类的一个构造器，参见构造器(initializers)。</li>
<li>如果没有声明构造器，而且类的所有属性都被赋予了初始值，调用类的默认构造器，参见默认构造器(default initializers).</li>
</ul>
<p>类实例属性可以用点(.)来获得，详情参见获得属性(Accessing Properties)一节。</p>
<p>类是引用类型；当被赋予常量或变量，函数调用时，类的实例是被引用，而不是复制。获得更多关于引用类型的信息，
结构体和枚举都是值类型(Structures and Enumerations Are Value Types)一节。</p>
@ -932,22 +938,19 @@ ExampleEnum.D的值会自动增长为6.</p>
<p><a name="protocol_declaration"></a></p>
<h2 id="-translated-by-">协议声明(translated by 小一)</h2>
<p>一个协议声明为你的程序引入一个命名了的协议类型。协议声明使用 <code>protocol</code> 关键词来进行声明并有下面这样的形式：</p>
<pre><code class="lang-javascript">protocol protocol name: inherited protocols {
protocol member declarations
}
</code></pre>
<blockquote>
<p>protocol <code>protocol name</code>: <code>inherited protocols</code> {<br> <code>protocol member declarations</code><br>} </p>
</blockquote>
<p>协议的主体包含零或多个协议成员声明，这些成员描述了任何采用该协议必须满足的一致性要求。特别的，一个协议可以声明必须实现某些属性、方法、初始化程序及下标脚本的一致性类型。协议也可以声明专用种类的类型别名，叫做关联类型，它可以指定协议的不同声明之间的关系。协议成员声明会在下面的详情里进行讨论。</p>
<p>协议类型可以从很多其它协议那继承。当一个协议类型从其它协议那继承的时候，来自其它协议的所有要求就集合了，而且从当前协议继承的任何类型必须符合所有的这些要求。对于如何使用协议继承的例子，查看<a href="../chapter2/21_Protocols.html#protocol_inheritance">协议继承</a></p>
<blockquote>
<p>注意：</p>
<p>你也可以使用协议合成类型集合多个协议的一致性要求，详情参见<a href="../chapter3/03_Types.html#protocol_composition_type">协议合成类型</a>和<a href="../chapter2/21_Protocols.html#protocol_composition">协议合成</a></p>
<p>注意：<br>你也可以使用协议合成类型集合多个协议的一致性要求，详情参见<a href="../chapter3/03_Types.html#protocol_composition_type">协议合成类型</a>和<a href="../chapter2/21_Protocols.html#protocol_composition">协议合成</a></p>
</blockquote>
<p>你可以通过采用在类型的扩展声明中的协议来为之前声明的类型添加协议一致性。在扩展中你必须实现所有采用协议的要求。如果该类型已经实现了所有的要求，你可以让这个扩展声明的主题留空。</p>
<p>默认地，符合某一个协议的类型必须实现所有声明在协议中的属性、方法和下标脚本。也就是说，你可以用<code>optional</code>属性标注这些协议成员声明以指定它们的一致性类型实现是可选的。<code>optional</code>属性仅仅可以用于使用<code>objc</code>属性标记过的协议。这样的结果就是仅仅类类型可以采用并符合包含可选成员要求的协议。更多关于如何使用<code>optional</code>属性的信息及如何访问可选协议成员的指导——比如当你不能肯定是否一致性的类型实现了它们——参见<a href="../chapter2/21_Protocols.html#optional_protocol_requirements">可选协议要求</a></p>
<p>为了限制协议的采用仅仅针对类类型，需要使用<code>class_protocol</code>属性标记整个协议声明。任意继承自标记有<code>class_protocol</code>属性协议的协议都可以智能地仅能被类类型采用。</p>
<blockquote>
<p>注意：</p>
<p>如果协议已经用<code>object</code>属性标记了，<code>class_protocol</code>属性就隐性地应用于该协议；没有必要再明确地使用<code>class_protocol</code>属性来标记该协议了。</p>
<p>注意：<br>如果协议已经用<code>object</code>属性标记了，<code>class_protocol</code>属性就隐性地应用于该协议；没有必要再明确地使用<code>class_protocol</code>属性来标记该协议了。</p>
</blockquote>
<p>协议是命名的类型，因此它们可以以另一个命名类型出现在你代码的所有地方，就像<a href="../chapter2/21_Protocols.html#protocols_as_types">协议类型</a>里讨论的那样。然而你不能构造一个协议的实例，因为协议实际上不提供它们指定的要求的实现。</p>
<p>你可以使用协议来声明一个类的代理的方法或者应该实现的结构，就像<a href="../chapter2/21_Protocols.html#delegation">委托(代理)模式</a>描述的那样。</p>
@ -957,8 +960,10 @@ ExampleEnum.D的值会自动增长为6.</p>
<p><a name="protocol_property_declaration"></a></p>
<h3 id="-">协议属性声明</h3>
<p>协议声明了一致性类型必须在协议声明的主体里通过引入一个协议属性声明来实现一个属性。协议属性声明有一种特殊的类型声明形式：</p>
<pre><code>var property name: type { get set }
</code></pre><p>同其它协议成员声明一样，这些属性声明仅仅针对符合该协议的类型声明了<code>getter</code>和<code>setter</code>要求。结果就是你不需要在协议里它被声明的地方实现<code>getter</code>和<code>setter</code>。</p>
<blockquote>
<p>var <code>property name</code>: <code>type</code> { get set }</p>
</blockquote>
<p>同其它协议成员声明一样，这些属性声明仅仅针对符合该协议的类型声明了<code>getter</code>和<code>setter</code>要求。结果就是你不需要在协议里它被声明的地方实现<code>getter</code>和<code>setter</code>。</p>
<p><code>getter</code>和<code>setter</code>要求可以通过一致性类型以各种方式满足。如果属性声明包含<code>get</code>和<code>set</code>关键词，一致性类型就可以用可读写（实现了<code>getter</code>和<code>setter</code>）的存储型变量属性或计算型属性，但是属性不能以常量属性或只读计算型属性实现。如果属性声明仅仅包含<code>get</code>关键词的话，它可以作为任意类型的属性被实现。比如说实现了协议的属性要求的一致性类型，参见<a href="../chapter2/21_Protocols.html#property_requirements">属性要求</a></p>
<p>更多参见<a href="../chapter3/05_Declarations.html#variable_declaration">变量声明</a></p>
<blockquote>
@ -985,8 +990,10 @@ ExampleEnum.D的值会自动增长为6.</p>
<h3 id="-">协议下标脚本声明</h3>
<p>协议声明了一致性类型必须在协议声明的主体里通过引入一个协议下标脚本声明来实现一个下标脚本。协议属性声明
对下标脚本声明有一个特殊的形式：</p>
<pre><code>subscript (parameters) -&gt; return type { get set }
</code></pre><p>下标脚本声明只为和协议一致的类型声明了必需的最小数量的的getter和setter。如果下标脚本申明包含get和set关键字，
<blockquote>
<p>subscript (<code>parameters</code>) -&gt; <code>return type</code> { get set }</p>
</blockquote>
<p>下标脚本声明只为和协议一致的类型声明了必需的最小数量的的getter和setter。如果下标脚本申明包含get和set关键字，
一致的类型也必须有一个getter和setter语句。如果下标脚本声明值包含get关键字，一致的类型必须至少包含一个
getter语句，可以选择是否包含setter语句。</p>
<p>更多参阅下标脚本声明。</p>
@ -1006,19 +1013,19 @@ getter语句，可以选择是否包含setter语句。</p>
<p>结构体，枚举，类可以有任意数量的构造器，但是类的构造器的规则和行为是不一样的。不像结构体和枚举那样，类
有两种结构体，designed initializers 和convenience initializers，参见构造器一节。</p>
<p>如下的形式声明了结构体，枚举和类的指定构造器：</p>
<pre><code>init(parameters) {
statements
}
</code></pre><p>类的指定构造器将类的所有属性直接初始化。如果类有超类，它不能调用该类的其他构造器,它只能调用超类的一个
<blockquote>
<p>init(<code>parameters</code>) {<br> <code>statements</code><br>} </p>
</blockquote>
<p>类的指定构造器将类的所有属性直接初始化。如果类有超类，它不能调用该类的其他构造器,它只能调用超类的一个
指定构造器。如果该类从它的超类处继承了任何属性，这些属性在当前类内被赋值或修饰时，必须带哦用一个超类的
指定构造器。</p>
<p>指定构造器可以在类声明的上下文中声明，因此它不能用扩展声明的方法加入一个类中。</p>
<p>结构体和枚举的构造器可以带哦用其他的已声明的构造器，来委托其中一个火全部进行初始化过程。</p>
<p>以关键字convenience来声明一个类的便利构造器：</p>
<pre><code>convenience init(parameters) {
statements
}
</code></pre><p>便利构造器可以将初始化过程委托给另一个便利构造器或类的一个指定构造器。这意味着，类的初始化过程必须
<blockquote>
<p>convenience init(<code>parameters</code>) {<br> <code>statements</code><br>} </p>
</blockquote>
<p>便利构造器可以将初始化过程委托给另一个便利构造器或类的一个指定构造器。这意味着，类的初始化过程必须
以一个将所有类属性完全初始化的指定构造器的调用作为结束。便利构造器不能调用超类的构造器。</p>
<p>你可以使用requierd关键字，将便利构造器和指定构造器标记为每个子类的构造器都必须拥有的。因为指定构造器
不被子类继承，它们必须被立即执行。当子类直接执行所有超类的指定构造器(或使用便利构造器重写指定构造器)时，
@ -1031,10 +1038,10 @@ overrride关键字。</p>
<p><a name="deinitializer_declaration"></a></p>
<h2 id="-">析构声明</h2>
<p>析构声明为类声明了一个析构器。析构器没有参数，遵循如下的格式：</p>
<pre><code>deinit {
statements
}
</code></pre><p>当类没有任何语句时将要被释放时，析构器会自动的被调用。析构器在类的声明体内只能被声明一次——但是不能在
<blockquote>
<p>deinit {<br> <code>statements</code><br>} </p>
</blockquote>
<p>当类没有任何语句时将要被释放时，析构器会自动的被调用。析构器在类的声明体内只能被声明一次——但是不能在
类的扩展声明内，每个类最多只能有一个。</p>
<p>子类继承了它的超类的析构器，在子类将要被释放时隐式的调用。子类在所有析构器被执行完毕前不会被释放。</p>
<p>析构器不会被直接调用。</p>
@ -1045,10 +1052,10 @@ overrride关键字。</p>
<p><a name="extension_declaration"></a></p>
<h2 id="-">扩展声明</h2>
<p>扩展声明用于扩展一个现存的类，结构体，枚举的行为。扩展声明以关键字extension开始，遵循如下的规则：</p>
<pre><code>extension type: adopted protocols {
declarations
}
</code></pre><p>一个扩展声明体包括零个或多个声明。这些声明可以包括计算型属性，计算型静态属性，实例方法，静态和类方法，构造器，
<blockquote>
<p>extension <code>type</code>: <code>adopted protocols</code> {<br> <code>declarations</code><br>} </p>
</blockquote>
<p>一个扩展声明体包括零个或多个声明。这些声明可以包括计算型属性，计算型静态属性，实例方法，静态和类方法，构造器，
下标脚本声明，甚至其他结构体，类，和枚举声明。扩展声明不能包含析构器，协议声明，存储型属性，属性监测器或其他
的扩展属性。详细讨论和查看包含多种扩展声明的实例，参见扩展一节。</p>
<p>扩展声明可以向现存的类，结构体，枚举内添加一致的协议。扩展声明不能向一个类中添加继承的类，因此
@ -1061,37 +1068,11 @@ type-inheritance-clause是一个只包含协议列表的扩展声明。</p>
</blockquote>
<p><a name="subscript_declaration"></a></p>
<h2 id="-translated-by-">下标脚本声明(translated by 林)</h2>
<p>&lt;&lt;&lt;&lt;&lt;&lt;&lt; HEAD
附属脚本用于向特定类型添加附属脚本支持，通常为访问集合，列表和序列的元素时提供语法便利。附属脚本声明使用关键字<code>subscript</code>，声明形式如下：</p>
<p>附属脚本用于向特定类型添加附属脚本支持，通常为访问集合，列表和序列的元素时提供语法便利。附属脚本声明使用关键字<code>subscript</code>，声明形式如下：</p>
<blockquote>
<p>subscript (<code>parameter</code>) -&gt; (return type){<br> get{<br> <code>statements</code><br> }<br> set(<code>setter name</code>){<br> <code>statements</code><br> }<br>} </p>
</blockquote>
<h1 id="-">附属脚本声明只能在类，结构体，枚举，扩展和协议声明的上下文进行声明。</h1>
<p>下标脚本用于向特定类型添加下标脚本支持，通常为访问集合，列表和序列的元素时提供语法便利。下标脚本声明使用关键字<code>subscript</code>，声明形式如下：</p>
<blockquote>
<p>subscript (<code>parameter</code>) -&gt; (return type){
get{
<code>statements</code>
}
set(<code>setter name</code>){
<code>statements</code>
}
}
下标脚本声明只能在类，结构体，枚举，扩展和协议声明的上下文进行声明。</p>
<blockquote>
<blockquote>
<blockquote>
<blockquote>
<blockquote>
<blockquote>
<p>a516af6a531a104ec88da0d236ecf389a5ec72af</p>
</blockquote>
</blockquote>
</blockquote>
</blockquote>
</blockquote>
</blockquote>
<p>subscript (<code>parameter</code>) -&gt; (return type){<br> get{<br> <code>statements</code><br> }<br> set(<code>setter name</code>){<br> <code>statements</code><br> }<br>} </p>
</blockquote>
<p>附属脚本声明只能在类，结构体，枚举，扩展和协议声明的上下文进行声明。</p>
<p><em>变量(parameters)</em>指定一个或多个用于在相关类型的下标脚本中访问元素的索引（例如，表达式<code>object[i]</code>中的<code>i</code>）。尽管用于元素访问的索引可以是任意类型的，但是每个变量必须包含一个用于指定每种索引类型的类型标注。<em>返回类型(return type)</em>指定被访问的元素的类型。</p>
<p>和计算性属性一样，下标脚本声明支持对访问元素的读写操作。getter用于读取值，setter用于写入值。setter子句是可选的，当仅需要一个getter子句时，可以将二者都忽略且直接返回请求的值即可。也就是说，如果使用了setter子句，就必须使用getter子句。</p>
<p>setter的名字和封闭的括号是可选的。如果使用了setter名称，它会被当做传给setter的变量的名称。如果不使用setter名称，那么传给setter的变量的名称默认是<code>value</code>。setter名称的类型必须与<em>返回类型(return type)</em>的类型相同。</p>
@ -1099,7 +1080,7 @@ type-inheritance-clause是一个只包含协议列表的扩展声明。</p>
<p>同样可以在协议声明的上下文中声明下标脚本，<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/doc/uid/TP40014097-CH34-XID_619" target="_blank">Protocol Subscript Declaration</a>中有所描述。</p>
<p>更多关于下标脚本和下标脚本声明的例子，请参考<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Subscripts.html#//apple_ref/doc/uid/TP40014097-CH16-XID_393" target="_blank">Subscripts</a>。</p>
<blockquote>
<p>附属脚本声明语法<br><em>附属脚本声明</em> → <a href="..\chapter3\05_Declarations.html#subscript_head"><em>附属脚本头(Head)</em></a> <a href="..\chapter3\05_Declarations.html#subscript_result"><em>附属脚本结果(Result)</em></a> <a href="..\chapter3\05_Declarations.html#code_block"><em>代码块</em></a><br><em>附属脚本声明</em> → <a href="..\chapter3\05_Declarations.html#subscript_head"><em>附属脚本头(Head)</em></a> <a href="..\chapter3\05_Declarations.html#subscript_result"><em>附属脚本结果(Result)</em></a> <a href="..\chapter3\05_Declarations.html#getter_setter_block"><em>getter-setter块</em></a><br><em>附属脚本声明</em> → <a href="..\chapter3\05_Declarations.html#subscript_head"><em>附属脚本头(Head)</em></a> <a href="..\chapter3\05_Declarations.html#subscript_result"><em>附属脚本结果(Result)</em></a> <a href="..\chapter3\05_Declarations.html#getter_setter_keyword_block"><em>getter-setter关键字(Keyword)块</em></a><br><em>附属脚本头(Head)</em> → <a href="..\chapter3\06_Attributes.html#attributes"><em>特性(Attributes)列表</em></a> <em>可选</em> <strong>subscript</strong> <a href="..\chapter3\05_Declarations.html#parameter_clause"><em>参数子句</em></a><br><em>附属脚本结果(Result)</em> → <strong>-&gt;</strong> <a href="..\chapter3\06_Attributes.html#attributes"><em>特性(Attributes)列表</em></a> <em>可选</em> <a href="..\chapter3\03_Types.html#type"><em>类型</em></a> </p>
<p>附属脚本声明语法<br><em>附属脚本声明</em> → <a href="..\chapter3\05_Declarations.html#subscript_head"><em>附属脚本头(Head)</em></a> <a href="..\chapter3\05_Declarations.html#subscript_result"><em>附属脚本结果(Result)</em></a> <a href="..\chapter3\05_Declarations.html#code_block"><em>代码块</em></a><br><em>附属脚本声明</em> → <a href="..\chapter3\05_Declarations.html#subscript_head"><em>附属脚本头(Head)</em></a> <a href="..\chapter3\05_Declarations.html#subscript_result"><em>附属脚本结果(Result)</em></a> <a href="..\chapter3\05_Declarations.html#getter_setter_block"><em>getter-setter块</em></a><br><em>附属脚本声明</em> → <a href="..\chapter3\05_Declarations.html#subscript_head"><em>附属脚本头(Head)</em></a> <a href="..\chapter3\05_Declarations.html#subscript_result"><em>附属脚本结果(Result)</em></a> <a href="..\chapter3\05_Declarations.html#getter_setter_keyword_block"><em>getter-setter关键字(Keyword)块</em></a><br><em>附属脚本头(Head)</em> → <a href="..\chapter3\06_Attributes.html#attributes"><em>特性(Attributes)列表</em></a> <em>可选</em> <strong>subscript</strong> <a href="..\chapter3\05_Declarations.html#parameter_clause"><em>参数子句</em></a><br><em>附属脚本结果(Result)</em> → <strong>-&gt;</strong> <a href="..\chapter3\06_Attributes.html#attributes"><em>特性(Attributes)列表</em></a> <em>可选</em> <a href="..\chapter3\03_Types.html#type"><em>类型</em></a> </p>
</blockquote>
<p><a name="operator_declaration"></a></p>
<h2 id="-translated-by-">运算符声明(translated by 林)</h2>
@ -1108,10 +1089,7 @@ type-inheritance-clause是一个只包含协议列表的扩展声明。</p>
运算符声明有三种基本形式，每种缀性各一种。运算符的缀性通过在<code>operator</code>和运算符之间添加上下文关键字<code>infix</code>，<code>prefix</code>或<code>postfix</code>来指定。每种形式中，运算符的名字只能包含<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/doc/uid/TP40014097-CH30-XID_871" target="_blank">Operators</a>中定义的运算符字符。</p>
<p>下面的这种形式声明了一个新的中缀运算符：</p>
<blockquote>
<p>operator infix <code>operator name</code>{
precedence <code>precedence level</code>
associativity <code>associativity</code>
}</p>
<p>operator infix <code>operator name</code>{<br> previewprecedence <code>precedence level</code><br> associativity <code>associativity</code><br>} </p>
</blockquote>
<p><em>中缀</em>运算符是二元运算符，它可以被置于两个操作数之间，比如表达式<code>1 + 2</code> 中的加法运算符(<code>+</code>)。</p>
<p>中缀运算符可以可选地指定优先级，结合性，或两者同时指定。</p>
@ -1121,13 +1099,13 @@ type-inheritance-clause是一个只包含协议列表的扩展声明。</p>
<p>声明时不指定任何优先级或结合性的中缀运算符，它们的优先级会被初始化为100，结合性被初始化为<code>none</code>。</p>
<p>下面的这种形式声明了一个新的前缀运算符：</p>
<blockquote>
<p>operator prefix <code>operator name</code>{}</p>
<p>operator prefix <code>operator name</code>{} </p>
</blockquote>
<p>紧跟在操作数前边的<em>前缀运算符(prefix operator)</em>是一元运算符，例如表达式<code>++i</code>中的前缀递增运算符(<code>++</code>)。</p>
<p>前缀运算符的声明中不指定优先级。前缀运算符是非结合的。</p>
<p>下面的这种形式声明了一个新的后缀运算符：</p>
<blockquote>
<p>operator postfix <code>operator name</code>{}</p>
<p>operator postfix <code>operator name</code>{} </p>
</blockquote>
<p>紧跟在操作数后边的<em>后缀运算符(postfix operator)</em>是一元运算符，例如表达式<code>i++</code>中的前缀递增运算符(<code>++</code>)。</p>
<p>和前缀运算符一样，后缀运算符的声明中不指定优先级。后缀运算符是非结合的。</p>

4
chapter3/06_Attributes.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="3.7" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="3.7" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,7 +587,7 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_81">
<section class="normal" id="section-gitbook_557">
<blockquote>
<p>翻译：Hawstein</p>

4
chapter3/07_Patterns.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="3.8" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="3.8" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,7 +587,7 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_93">
<section class="normal" id="section-gitbook_569">
<blockquote>
<p>翻译：honghaoz</p>

4
chapter3/08_Generic_Parameters_and_Arguments.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="3.9" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="3.9" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,7 +587,7 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_95">
<section class="normal" id="section-gitbook_571">
<blockquote>
<p>翻译：fd5788</p>

76
chapter3/09_Summary_of_the_Grammar.html
View File

File diff suppressed because one or more lines are too long

4
chapter3/10_Statements.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="3.5" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="3.5" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,7 +587,7 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_97">
<section class="normal" id="section-gitbook_576">
<blockquote>
<p>翻译：coverxit</p>

2
chapter3/chapter3.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="3" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="3" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>