Solidity合约类型 - 区块链技术 - BitMere

Solidity 是一种静态类型语言，这意味着每个变量（状态变量和局部变量）都需要在编译时指定变量的类型（或至少可以推导出变量类型——参考下文的类型判断）。
Solidity 提供了几种基本类型，可以用来组合出复杂类型。
除此之外，类型之间可以在包含运算符号的表达式中进行交互。
关于各种运算符号，可以参考操作符优先级。
值类型
以下类型也称为值类型，因为这些类型的变量将始终按值来传递。
也就是说，当这些变量被用作函数参数或者用在赋值语句中时，总会进行值拷贝。
布尔类型
bool ：可能的取值为字面常数值 true 和 false 。
运算符：

! （逻辑非）

&& （逻辑与， “and” ）

|| （逻辑或， “or” ）

== （等于）

!= （不等于）

运算符 || 和 && 都遵循同样的短路（ short-circuiting ）规则。就是说在表达式 f(x) || g(y) 中，
如果 f(x) 的值为 true ，那么 g(y) 就不会被执行，即使会出现一些副作用。
整型
int / uint ：分别表示有符号和无符号的不同位数的整型变量。
支持关键字 uint8 到 uint256 （无符号，从 8 位到 256 位）以及 int8 到 int256，以 8 位为步长递增。
uint 和 int 分别是 uint256 和 int256 的别名。
运算符：

比较运算符： <= ， < ， == ， != ， >= ， > （返回布尔值）

位运算符： & ， | ， ^ （异或）， ~ （位取反）

算数运算符： + ， - ，一元运算 - ，一元运算 + ， * ， / ， % （取余）， ** （幂）， << （左移位）， >> （右移位）

除法总是会截断的（仅被编译为 EVM 中的 DIV 操作码），
但如果操作数都是 :ref:字面常数（literals）<rational_literals> （或者字面常数表达式），则不会截断。
除以零或者模零运算都会引发运行时异常。
移位运算的结果取决于运算符左边的类型。
表达式 x << y 与 x * 2**y 是等价的，
x >> y 与 x / 2**y 是等价的。这意味对一个负数进行移位会导致其符号消失。
按负数位移动会引发运行时异常。
… warning::
由有符号整数类型负值右移所产生的结果跟其它语言中所产生的结果是不同的。
在 Solidity 中，右移和除是等价的，因此对一个负数进行右移操作会导致向 0 的取整（截断）。
而在其它语言中，对负数进行右移类似于（向负无穷）取整。
定长浮点型
… warning::
Solidity 还没有完全支持定长浮点型。可以声明定长浮点型的变量，但不能给它们赋值或把它们赋值给其他变量。。
fixed / ufixed：表示各种大小的有符号和无符号的定长浮点型。
在关键字 ufixedMxN 和 fixedMxN 中，M 表示该类型占用的位数，N 表示可用的小数位数。
M 必须能整除 8，即 8 到 256 位。
N 则可以是从 0 到 80 之间的任意数。
ufixed 和 fixed 分别是 ufixed128x19 和 fixed128x19 的别名。
运算符：

比较运算符：<=， <， ==， !=， >=， > （返回值是布尔型）

算术运算符：+， -，一元运算 -，一元运算 +， *， /， % （取余数）

… note::
浮点型（在许多语言中的 float 和 double 类型，更准确地说是 IEEE 754 类型）和定长浮点型之间最大的不同点是，
在前者中整数部分和小数部分（小数点后的部分）需要的位数是灵活可变的，而后者中这两部分的长度受到严格的规定。
一般来说，在浮点型中，几乎整个空间都用来表示数字，但只有少数的位来表示小数点的位置。
地址类型
address：地址类型存储一个 20 字节的值（以太坊地址的大小）。
地址类型也有成员变量，并作为所有合约的基础。
运算符：

<=， <， ==， !=， >= 和 >

… note::
从 0.5.0 版本开始，合约不会从地址类型派生，但仍然可以显式地转换成地址类型。
… _members-of-addresses:
地址类型成员变量
^^^^^^^^^^^^^^^^

balance 和 transfer

快速参考，请见 :ref:address_related。
可以使用 balance 属性来查询一个地址的余额，
也可以使用 transfer 函数向一个地址发送 |ether| （以 wei 为单位）：
address x = 0x123;
address myAddress = this;
if (x.balance < 10 && myAddress.balance >= 10) x.transfer(10);
… note::
如果 x 是一个合约地址，它的代码（更具体来说是它的 fallback 函数，如果有的话）会跟 transfer 函数调用一起执行（这是 EVM 的一个特性，无法阻止）。
如果在执行过程中用光了 gas 或者因为任何原因执行失败，|ether| 交易会被打回，当前的合约也会在终止的同时抛出异常。

send

send 是 transfer 的低级版本。如果执行失败，当前的合约不会因为异常而终止，但 send 会返回 false。
… warning::
在使用 send 的时候会有些风险：如果调用栈深度是 1024 会导致发送失败（这总是可以被调用者强制），如果接收者用光了 gas 也会导致发送失败。
所以为了保证 |ether| 发送的安全，一定要检查 send 的返回值，使用 transfer 或者更好的办法：
使用一种接收者可以取回资金的模式。

call， callcode 和 delegatecall

此外，为了与不符合 |ABI| 的合约交互，于是就有了可以接受任意类型任意数量参数的 call 函数。
这些参数会被打包到以 32 字节为单位的连续区域中存放。
其中一个例外是当第一个参数被编码成正好 4 个字节的情况。
在这种情况下，这个参数后边不会填充后续参数编码，以允许使用函数签名。
address nameReg = 0x72ba7d8e73fe8eb666ea66babc8116a41bfb10e2;
nameReg.call("register", "MyName");
nameReg.call(bytes4(keccak256("fun(uint256)")), a);
call 返回的布尔值表明了被调用的函数已经执行完毕（true）或者引发了一个 EVM 异常（false）。
无法访问返回的真实数据（为此我们需要事先知道编码和大小）。
可以使用 .gas() |modifier| 调整提供的 gas 数量
namReg.call.gas(1000000)("register", "MyName");
类似地，也能控制提供的 |ether| 的值 ::
nameReg.call.value(1 ether)("register", "MyName");
最后一点，这些 |modifier| 可以联合使用。每个修改器出现的顺序不重要
nameReg.call.gas(1000000).value(1 ether)("register", "MyName");
目前还不能在重载函数中使用 gas 或者 value |modifier| 。
一种解决方案是给 gas 和值引入一个特例，并重新检查它们是否在重载的地方出现。
类似地，也可以使用 delegatecall：
区别在于只使用给定地址的代码，其它属性（存储，余额，……）都取自当前合约。
delegatecall 的目的是使用存储在另外一个合约中的库代码。
用户必须确保两个合约中的存储结构都适用于 delegatecall。
在 homestead 版本之前，只有一个功能类似但作用有限的 callcode 的函数可用，但它不能获取委托方的 msg.sender 和 msg.value。
这三个函数 call， delegatecall 和 callcode 都是非常低级的函数，应该只把它们当作最后一招来使用，因为它们破坏了 Solidity 的类型安全性。
… note::
所有合约都继承了地址（address）的成员变量，因此可以使用 this.balance 查询当前合约的余额。
… note::
不鼓励使用 callcode，在未来也会将其移除。
… warning::
这三个函数都属于低级函数，需要谨慎使用。
具体来说，任何未知的合约都可能是恶意的。
你在调用一个合约的同时就将控制权交给了它，它可以反过来调用你的合约，
因此，当调用返回时要为你的状态变量的改变做好准备。
定长字节数组
关键字有：bytes1， bytes2， bytes3， …， bytes32。byte 是 bytes1 的别名。
运算符：

比较运算符：<=， <， ==， !=， >=， > （返回布尔型）

位运算符： &， |， ^ （按位异或）， ~ （按位取反）， << （左移位）， >> （右移位）

索引访问：如果 x 是 bytesI 类型，那么 x[k] （其中 0 <= k < I）返回第 k 个字节（只读）。

该类型可以和作为右操作数的任何整数类型进行移位运算（但返回结果的类型和左操作数类型相同），右操作数表示需要移动的位数。
进行负数位移运算会引发运行时异常。
成员变量：

.length 表示这个字节数组的长度（只读）.

… note::
可以将 byte[] 当作字节数组使用，但这种方式非常浪费存储空间，准确来说，是在传入调用时，每个元素会浪费 31 字节。
更好地做法是使用 bytes。
变长字节数组
bytes:
变长字节数组，参见 :ref:arrays。它并不是值类型。
string:
变长 UTF-8 编码字符串类型，参见 :ref:arrays。并不是值类型。
地址字面常数（Address Literals）
比如像 0xdCad3a6d3569DF655070DEd06cb7A1b2Ccd1D3AF 这样的通过了地址校验和测试的十六进制字面常数属于 address 类型。
长度在 39 到 41 个数字的，没有通过校验和测试而产生了一个警告的十六进制字面常数视为正常的有理数字面常数。
… note::
混合大小写的地址校验和格式定义在 EIP-55 <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-55.md>_ 中。
有理数和整数字面常数
整数字面常数由范围在 0-9 的一串数字组成，表现成十进制。
例如，69 表示数字 69。
Solidity 中是没有八进制的，因此前置 0 是无效的。
十进制小数字面常数带有一个 .，至少在其一边会有一个数字。
比如：1.，.1，和 1.3。
科学符号也是支持的，尽管指数必须是整数，但底数可以是小数。
比如：2e10， -2e10， 2e-10， 2.5e1。
数值字面常数表达式本身支持任意精度，除非它们被转换成了非字面常数类型（也就是说，当它们出现在非字面常数表达式中时就会发生转换）。
这意味着在数值常量表达式中, 计算不会溢出而除法也不会截断。
例如， (2**800 + 1) - 2**800 的结果是字面常数 1 （属于 uint8 类型），尽管计算的中间结果已经超过了 |evm| 的机器字长度。
此外， .5 * 8 的结果是整型 4 （尽管有非整型参与了计算）。
只要操作数是整型，任意整型支持的运算符都可以被运用在数值字面常数表达式中。
如果两个中的任一个数是小数，则不允许进行位运算。如果指数是小数的话，也不支持幂运算（因为这样可能会得到一个无理数）。
… note::
Solidity 对每个有理数都有对应的数值字面常数类型。
整数字面常数和有理数字面常数都属于数值字面常数类型。
除此之外，所有的数值字面常数表达式（即只包含数值字面常数和运算符的表达式）都属于数值字面常数类型。
因此数值字面常数表达式 1 + 2 和 2 + 1 的结果跟有理数三的数值字面常数类型相同。
… warning::
在早期版本中，整数字面常数的除法也会截断，但在现在的版本中，会将结果转换成一个有理数。即 5 / 2 并不等于 2，而是等于 2.5。
… note::
数值字面常数表达式只要在非字面常数表达式中使用就会转换成非字面常数类型。
在下面的例子中，尽管我们知道 b 的值是一个整数，但 2.5 + a 这部分表达式并不进行类型检查，因此编译不能通过。
uint128 a = 1;
uint128 b = 2.5 + a + 0.5;
字符串字面常数
字符串字面常数是指由双引号或单引号引起来的字符串（"foo" 或者 'bar'）。
不像在 C 语言中那样带有结束符；"foo" 相当于 3 个字节而不是 4 个。
和整数字面常数一样，字符串字面常数的类型也可以发生改变，但它们可以隐式地转换成 bytes1，……，bytes32，如果合适的话，还可以转换成 bytes 以及 string。
字符串字面常数支持转义字符，例如 \n，\xNN 和 \uNNNN。\xNN 表示一个 16 进制值，最终转换成合适的字节，
而 \uNNNN 表示 Unicode 编码值，最终会转换为 UTF-8 的序列。
十六进制字面常数
十六进制字面常数以关键字 hex 打头，后面紧跟着用单引号或双引号引起来的字符串（例如，hex"001122FF"）。
字符串的内容必须是一个十六进制的字符串，它们的值将使用二进制表示。
十六进制字面常数跟字符串字面常数很类似，具有相同的转换规则。
枚举类型
pragma solidity ^0.4.16;
contract test {
enum ActionChoices { GoLeft, GoRight, GoStraight, SitStill }
ActionChoices choice;
ActionChoices constant defaultChoice = ActionChoices.GoStraight;
function setGoStraight() public {
      choice = ActionChoices.GoStraight;
}
// 由于枚举类型不属于 |ABI| 的一部分，因此对于所有来自 Solidity 外部的调用，
// "getChoice" 的签名会自动被改成 "getChoice() returns (uint8)"。
// 整数类型的大小已经足够存储所有枚举类型的值，随着值的个数增加，
// 可以逐渐使用 `uint16` 或更大的整数类型。
function getChoice() public view returns (ActionChoices) {
      return choice;
}
function getDefaultChoice() public pure returns (uint) {
      return uint(defaultChoice);
}
}
函数类型
函数类型是一种表示函数的类型。可以将一个函数赋值给另一个函数类型的变量，也可以将一个函数作为参数进行传递，还能在函数调用中返回函数类型变量。
函数类型有两类：- 内部（internal）函数和外部（external）函数：
内部函数只能在当前合约内被调用（更具体来说，在当前代码块内，包括内部库函数和继承的函数中），因为它们不能在当前合约上下文的外部被执行。
调用一个内部函数是通过跳转到它的入口标签来实现的，就像在当前合约的内部调用一个函数。
外部函数由一个地址和一个函数签名组成，可以通过外部函数调用传递或者返回。
函数类型表示成如下的形式
function (<parameter types>) {internal|external} [pure|constant|view|payable] [returns (<return types>)]
与参数类型相反，返回类型不能为空 —— 如果函数类型不需要返回，则需要删除整个 returns (<return types>) 部分。
函数类型默认是内部函数，因此不需要声明 internal 关键字。
与此相反的是，合约中的函数本身默认是 public 的，只有当它被当做类型名称时，默认才是内部函数。
有两种方法可以访问当前合约中的函数：一种是直接使用它的名字，f ，另一种是使用 this.f 。
前者适用于内部函数，后者适用于外部函数。
如果当函数类型的变量还没有初始化时就调用它的话会引发一个异常。
如果在一个函数被 delete 之后调用它也会发生相同的情况。
如果外部函数类型在 Solidity 的上下文环境以外的地方使用，它们会被视为 function 类型。
该类型将函数地址紧跟其函数标识一起编码为一个 bytes24 类型。。
请注意，当前合约的 public 函数既可以被当作内部函数也可以被当作外部函数使用。
如果想将一个函数当作内部函数使用，就用 f 调用，如果想将其当作外部函数，使用 this.f 。
除此之外，public（或 external）函数也有一个特殊的成员变量称作 selector，可以返回 :ref:ABI 函数选择器 <abi_function_selector>
pragma solidity ^0.4.16;
contract Selector {
  function f() public view returns (bytes4) {
return this.f.selector;
  }
}
如果使用内部函数类型的例子
pragma solidity ^0.4.16;
library ArrayUtils {
  // 内部函数可以在内部库函数中使用，
  // 因为它们会成为同一代码上下文的一部分
  function map(uint[] memory self, function (uint) pure returns (uint) f)
internal
pure
returns (uint[] memory r)
  {
r = new uint[](self.length);
for (uint i = 0; i < self.length; i++) {
   r = f(self);, E& w9 C/ k+ ], h8 }. R
}
- Q! Q! j: d+ Z) u3 |1 ]7 u  }
$ g4 n: J% w4 r- p+ y! d  function reduce(; f0 h+ v! d" r4 m$ d; l' `
uint[] memory self,
9 l; y; m5 D$ ^; l1 e8 m# f7 V function (uint, uint) pure returns (uint) f* B) }! e9 [# R  w0 Q% E
  )8 D# y' l+ |- ~) W8 @3 m
internal
5 ~+ j! r) _1 a* o% W; S& c pure( O6 ?' Y  s0 v, I$ i
returns (uint r)
$ G# g% @! v5 Z* g+ |5 c  {
: u+ w1 I4 s* u8 d- k; p* s r = self[0];" U4 d6 _, g! Y
for (uint i = 1; i < self.length; i++) {
; V$ p4 C* p3 R  |    r = f(r, self);
+ j3 A8 K; F1 X2 W# w# J }
2 _  T  X6 S* _6 J7 c; Z6 R  }
$ P% c! T' P$ O1 I  X  function range(uint length) internal pure returns (uint[] memory r) {+ Q1 X+ E8 ~6 @; \# I7 D
r = new uint[](length);& y5 F# M& k" a# W  R; ~
for (uint i = 0; i < r.length; i++) {" Z) a" R/ ?" }5 G
   r = i;# x/ D2 I6 I. b8 G5 [3 E" `) a% n( o3 u
}
4 {. Y& V, n% |  }
( s" B  ?) j* c' l0 U}4 [( N# r+ W" d' u  e: T
contract Pyramid {
( h8 L$ x& c* I6 Y' j5 `6 c  using ArrayUtils for *;' W3 o. G) U+ n5 b2 J, _1 c) x0 m" A3 K
  function pyramid(uint l) public pure returns (uint) {+ G. Z8 p5 f4 I6 e) X7 }$ j3 l
return ArrayUtils.range(l).map(square).reduce(sum);/ G! C; ?) Q6 a
  }- k7 \4 p2 z( M2 n& P$ B* |% [
  function square(uint x) internal pure returns (uint) {
( Z/ X. q* s! Q2 u1 Y" [4 G) b% M) ~ return x * x;) H& c# K' x7 J# B' n. ^1 s
  }
; ]2 [1 r: Z9 d+ |  ]  function sum(uint x, uint y) internal pure returns (uint) {
- E9 w7 p$ |) Z) a$ g5 ` return x + y;
/ R7 K: F  x7 X  }: K- W6 B- s+ R8 k- i
}( q; O. Q% n, r- @4 \7 y
另外一个使用外部函数类型的例子
9 v" X4 [/ `, U; p5 X; q+ R1 Q& |pragma solidity ^0.4.11;
# b; T  H2 u. o( m9 scontract Oracle {2 {- V( _( U: |& u( y  G
  struct Request {
5 q( B( W* J. t! i* ]! Q bytes data;
' j/ q) ?  c( ~+ P" ~ function(bytes memory) external callback;
5 q& _$ y" ?( {  [' f5 g( m. j* A  }" X* N2 l. p3 j& v" L7 g
  Request[] requests;4 c- p$ k$ T/ b9 R
  event NewRequest(uint);
/ u+ p5 k5 g* r; g1 |  function query(bytes data, function(bytes memory) external callback) public {
9 n/ o1 [0 K/ t: S2 f requests.push(Request(data, callback));
# z' G6 l8 x& H NewRequest(requests.length - 1);
% P$ v3 G2 d  }4 ?8 k% j& C% }" z  }
8 u) r: m! @/ y1 l/ X' R  function reply(uint requestID, bytes response) public {
0 }  W5 x( h5 V1 s7 H1 z // 这里要验证 reply 来自可信的源2 Q/ q) h: N8 p; R% ?, C) B
requests[requestID].callback(response);4 ?/ r. J. C  _
  }( x; e* n3 v! k( U% U: i. |  L
}
2 q  z8 S8 _& B/ d" s* v# B5 Kcontract OracleUser {6 w: ]% G$ i7 @7 p! Z+ e/ }
  Oracle constant oracle = Oracle(0x1234567); // 已知的合约
; \" A4 c5 U1 Z2 S3 b- {1 o  function buySomething() {$ y5 O7 c  A1 n; h+ }" I5 \. c
oracle.query("USD", this.oracleResponse);" g# p9 e5 B2 Q6 T- O# @
  }" G4 l* v  D# {! _, ~
  function oracleResponse(bytes response) public {
2 V$ H4 n- t( y8 a; S0 F! {, |& z require(msg.sender == address(oracle));  j1 J; }' C+ L6 ]$ ]: p# l- R
// 使用数据
  l% B& V) G6 n4 f  }  H2 I$ N! l2 p( R- Z  m, X
}9 o' |( L! Q( `
… note::  v9 j  |- O2 f7 j# |+ }' Z: Q
Lambda 表达式或者内联函数的引入在计划内，但目前还没支持。) T) d+ q9 J( V( {6 K
引用类型
- h' H; \1 F' y2 k! e. K( Z) k比起之前讨论过的值类型，在处理复杂的类型（即占用的空间超过 256 位的类型）时，我们需要更加谨慎。
: N2 A3 {: t$ ?由于拷贝这些类型变量的开销相当大，我们不得不考虑它的存储位置，是将它们保存在 ** |memory| ** （并不是永久存储）中，- P$ B( m% V. |5 \4 q8 l
还是 ** |storage| ** （保存状态变量的地方）中。3 M9 ?0 n) B! Z9 F6 J) I1 C
数据位置7 ]& y/ {' x, V( P4 p. Q3 S
所有的复杂类型，即数组和结构类型，都有一个额外属性，“数据位置”，说明数据是保存在 |memory| 中还是 |storage| 中。
  ?( `8 {! ]+ S% H! q9 Z根据上下文不同，大多数时候数据有默认的位置，但也可以通过在类型名后增加关键字 storage 或 memory 进行修改。# d/ ~) q/ q) P+ [5 j; w
函数参数（包括返回的参数）的数据位置默认是 memory，
* j4 u7 E/ t' H" \+ Z6 U, m: m& X' }" o局部变量的数据位置默认是 storage，状态变量的数据位置强制是 storage （这是显而易见的）。
6 S9 i+ B+ m9 o4 Q* j0 y, T8 K也存在第三种数据位置， calldata ，这是一块只读的，且不会永久存储的位置，用来存储函数参数。
# O* Y6 m/ J9 h8 [外部函数的参数（非返回参数）的数据位置被强制指定为 calldata ，效果跟 memory 差不多。: M0 c# G3 b8 _9 E6 [
数据位置的指定非常重要，因为它们影响着赋值行为：
) W& \; U! q/ D4 }6 y在 |storage| 和 |memory| 之间两两赋值，或者 |storage| 向状态变量（甚至是从其它状态变量）赋值都会创建一份独立的拷贝。
/ I) O; e$ C. C* Q+ P4 r然而状态变量向局部变量赋值时仅仅传递一个引用，而且这个引用总是指向状态变量，因此后者改变的同时前者也会发生改变。8 E  h5 W2 z5 N; r, m8 J* B4 N
另一方面，从一个 |memory| 存储的引用类型向另一个 |memory| 存储的引用类型赋值并不会创建拷贝。
8 r4 J6 ]: M( s6 v; Z# Tpragma solidity ^0.4.0;
# N( a+ \: y7 o: Z+ K  f' O# Icontract C {
: ?+ O' x8 W! _4 r uint[] x; // x 的数据存储位置是 storage
+ E6 X/ Q, ?+ F // memoryArray 的数据存储位置是 memory
! b4 {  D% e6 w( ?1 @ function f(uint[] memoryArray) public {% i! _4 q1 X/ L7 I/ R9 F1 v
      x = memoryArray; // 将整个数组拷贝到 storage 中，可行
# ]3 }( W1 s8 Q, a8 o6 R       var y = x;  // 分配一个指针（其中 y 的数据存储位置是 storage），可行
! \, i4 [6 F1 _& {* \       y[7]; // 返回第 8 个元素，可行) N! N1 b9 v0 D* Z2 A5 G7 f- D* L4 T
      y.length = 2; // 通过 y 修改 x，可行
2 N. T, t& H+ O5 {$ @# o       delete x; // 清除数组，同时修改 y，可行
; E3 m6 p6 ^0 k6 F5 }% O       // 下面的就不可行了；需要在 storage 中创建新的未命名的临时数组， /* w/ r5 N- J: d2 E1 [" T
      // 但 storage 是“静态”分配的：
/ T: s# U& M3 T% ^) K' \       // y = memoryArray;
0 g6 _7 c$ Q2 l4 `1 B4 B       // 下面这一行也不可行，因为这会“重置”指针，
! F7 Y) |: g$ M; K       // 但并没有可以让它指向的合适的存储位置。7 Q. M9 P) A1 Q5 ]1 ]( e$ q) M1 A
      // delete y;* T. Z3 C8 R- s2 L' U9 m
      / c4 x* w% r/ K2 y
      g(x); // 调用 g 函数，同时移交对 x 的引用
0 ?$ }1 c9 H/ D& f$ a$ _- J$ o       h(x); // 调用 h 函数，同时在 memory 中创建一个独立的临时拷贝
4 R5 m2 z  x9 Y- T9 a# B }, D4 v: J$ H3 m- {7 H
function g(uint[] storage storageArray) internal {}( z1 m6 T$ ?7 v; a- T1 v- b
function h(uint[] memoryArray) public {}' T6 F6 C4 L( q+ ^( d$ p, l' a
}+ f! U: Z5 i  x# c& f
总结9 y1 J) {) D3 G+ n5 Z! D
^^^^^4 j  c  S- p& g! J& W
强制指定的数据位置：
& B  K% B8 ?# \% E

外部函数的参数（不包括返回参数）： calldata

状态变量： storage7 b, C7 z- g u' h

# T/ F! K- o' U8 X. U默认数据位置：
8 i; k4 L( h( h/ Y4 l3 d4 G

函数参数（包括返回参数）： memory

所有其它局部变量： storage
! |' R/ P: T7 x' N
% D7 c& C+ P' ]/ k, i数组+ Q) \2 O  o6 r, t: E
数组可以在声明时指定长度，也可以动态调整大小。; O1 F9 Y% Q8 e; R/ Q) O
对于 |storage| 的数组来说，元素类型可以是任意的（即元素也可以是数组类型，映射类型或者结构体）。
) H( }+ D, `9 X. X) O  K& X对于 |memory| 的数组来说，元素类型不能是映射类型，如果作为 public 函数的参数，它只能是 ABI 类型。, I! `$ s4 V& V$ F- ]% J  |, Z  T4 {
一个元素类型为 T，固定长度为 k 的数组可以声明为 T[k]，而动态数组声明为 T[]。
6 ^; x; |7 s3 p( l* A4 {% I举个例子，一个长度为 5，元素类型为 uint 的动态数组的数组，应声明为 uint[][5] （注意这里跟其它语言比，数组长度的声明位置是反的）。$ Z" B9 a# e/ a( M) W2 B' U) X' v
要访问第三个动态数组的第二个元素，你应该使用 x[2][1]（数组下标是从 0 开始的，且访问数组时的下标顺序与声明时相反，也就是说，x[2] 是从右边减少了一级）。。
. S. W9 X5 ?& t: e% \bytes 和 string 类型的变量是特殊的数组。
0 s6 ^9 A% P# @6 bbytes 类似于 byte[]，但它在 calldata 中会被“紧打包”（译者注：将元素连续地存在一起，不会按每 32 字节一单元的方式来存放）。! \5 `0 b4 {" G' E
string 与 bytes 相同，但（暂时）不允许用长度或索引来访问。( @: G* t0 z" N& P' v5 j9 @
… note::% d/ Z2 J1 F/ w9 N) t2 Z
如果想要访问以字节表示的字符串 s，请使用 bytes(s).length / bytes(s)[7] = 'x';。
( h* ?2 }$ e0 [2 X/ `% a注意这时你访问的是 UTF-8 形式的低级 bytes 类型，而不是单个的字符。
可以将数组标识为 public，从而让 Solidity 创建一个 :ref:getter <visibility-and-getters>。) v4 ?4 }) r' C. `, @% `
之后必须使用数字下标作为参数来访问 getter。) x0 v+ G" B, C& Z; D( D) \9 N4 d
创建内存数组
, X8 y& n$ ?- y% {/ L^^^^^^^^^^^^^$ e7 I7 d: A/ U+ a9 e. V& w
可使用 new 关键字在内存中创建变长数组。3 x, _( w+ t" I, i
与 |storage| 数组相反的是，你不能通过修改成员变量 .length 改变 |memory| 数组的大小。1 _# v3 O, Q2 t
pragma solidity ^0.4.16;
" b- {8 o$ x* l5 P# x, @contract C {& b# j1 s. H1 x, J( ?# P
function f(uint len) public pure {
- V. h% Q' l; ^4 P       uint[] memory a = new uint[](7);7 B2 I* D  @6 n) E
      bytes memory b = new bytes(len);
! c& F9 D* P# x8 c9 W" D7 q' j9 R# a       // 这里我们有 a.length == 7 以及 b.length == len0 r) N9 g! [+ `- o. I
      a[6] = 8;
: O8 l3 u: E) p( N  [ }
0 [2 Z- P; N8 H}
8 _( y' z: O) ?  W0 q数组字面常数 / 内联数组1 U) h* X2 p; q3 o/ b4 u1 ]
^^^^^^^^^^^^^^^^^^^^^^^^^^^^  Q6 n0 C+ ~7 N- ?; \
数组字面常数是写作表达式形式的数组，并且不会立即赋值给变量。7 h& |9 w7 f% S1 V+ C
pragma solidity ^0.4.16;
" L  h/ X. j6 D, [  f( y& Ucontract C {  D1 ~  v- I6 R: b3 ~& [# q
function f() public pure {
% {& X; S- c7 g! F       g([uint(1), 2, 3]);
2 `% f9 X. `7 ?% r& }* q }: Z8 r% e" H( R  W, o& p
function g(uint[3] _data) public pure {, q" L2 @' h% u
      // ...
  ]  o+ V$ o9 o }+ r5 r1 b# e5 N1 t
}% z% M+ v1 M5 S2 {1 d9 [8 Y
数组字面常数是一种定长的 |memory| 数组类型，它的基础类型由其中元素的普通类型决定。3 e3 ~' }* P  U8 q2 H
例如，[1, 2, 3] 的类型是 uint8[3] memory，因为其中的每个字面常数的类型都是 uint8。
1 k9 I" y8 @3 n6 |' `正因为如此，有必要将上面这个例子中的第一个元素转换成 uint 类型。: ]5 {9 X5 m7 B! {( N2 ~( E
目前需要注意的是，定长的 |memory| 数组并不能赋值给变长的 |memory| 数组，下面是个反例：2 @- H. u9 \  G) E
// 这段代码并不能编译。
0 G9 ~, h, k$ t, W+ jpragma solidity ^0.4.0;
! v) A1 H, X- Mcontract C {! c2 ]+ a, w6 G+ E  C
function f() public {
1 {9 O3 X3 z" u! {8 ^+ s       // 这一行引发了一个类型错误，因为 unint[3] memory) ?: q, u  i9 N7 E- G
      // 不能转换成 uint[] memory。: J& r2 G% j9 Y  M
      uint[] x = [uint(1), 3, 4];# |8 Q9 y8 W) |  @! ~4 C, s. K) ^
}
, T7 |% M" C6 G. r- x1 p% E+ b}
. J' o% M) S2 E0 a1 {, d, g已经计划在未来移除这样的限制，但目前数组在 ABI 中传递的问题造成了一些麻烦。
+ C  D% g2 \$ Z7 [成员
  S" f5 O* g4 j; Flength:& p+ T3 O: b0 z6 N& [- e: s3 P
数组有 length 成员变量表示当前数组的长度。# ?9 o9 R; L7 K/ P0 ]
动态数组可以在 |storage| （而不是 |memory| ）中通过改变成员变量 .length 改变数组大小。9 \4 p' W- h9 ~& i
并不能通过访问超出当前数组长度的方式实现自动扩展数组的长度。+ C/ ~' c1 ]0 L' b' x
一经创建，|memory| 数组的大小就是固定的（但却是动态的，也就是说，它依赖于运行时的参数）。
1 y& C+ D& X+ B% a! l' Ypush:: |# f" p& [6 _% H& y
变长的 |storage| 数组以及 bytes 类型（而不是 string 类型）都有一个叫做 push 的成员函数，它用来附加新的元素到数组末尾。
0 W( Z% |: p$ X$ u这个函数将返回新的数组长度。& z1 U( V& h+ m$ W1 \7 D" k( p- O$ c
… warning::
( b' L' `: z7 o, _+ A: z/ N0 a在外部函数中目前还不能使用多维数组。
+ [: }$ u+ q1 E9 D$ ^1 g/ C; b… warning::
* ~' ^# Q/ l9 L# ?: x由于 |evm| 的限制，不能通过外部函数调用返回动态的内容。- {/ R& }1 n- }' p' Q8 t) W& U
例如，如果通过 web3.js 调用 contract C { function f() returns (uint[]) { ... } } 中的 f 函数，它会返回一些内容，但通过 Solidity 不可以。
! ]) g  N0 x/ U目前唯一的变通方法是使用大型的静态数组。6 U. z3 L" r) {. ]6 T; ~1 d; {
pragma solidity ^0.4.16;
5 D! q% Y; y/ Jcontract ArrayContract {
* C) B2 k6 v  z. N' t uint[2**20] m_aLotOfIntegers;
  ]' y+ Z7 U0 O // 注意下面的代码并不是一对动态数组，2 ~1 R2 ^" D" s* d
// 而是一个数组元素为一对变量的动态数组（也就是数组元素为长度为 2 的定长数组的动态数组）。
( n5 w6 w9 j. a2 N  J bool[2][] m_pairsOfFlags;
& p  Z9 s( b* ]( P: Z# r- U4 K // newPairs 存储在 memory 中 —— 函数参数默认的存储位置
# G) s) q  ^9 N9 s9 i% v- z function setAllFlagPairs(bool[2][] newPairs) public {
" B) X9 [* ]. h$ |4 X( W" i4 ~       // 向一个 storage 的数组赋值会替代整个数组2 V( W" i. f" P( q. W6 R: N
      m_pairsOfFlags = newPairs;$ j' q  N6 h" H9 ^
}
" t- L( e# w3 W function setFlagPair(uint index, bool flagA, bool flagB) public {
+ E; @0 F' R& G5 e& M* z5 s/ X       // 访问一个不存在的数组下标会引发一个异常2 D, {8 H. C4 Y0 m( e0 B
      m_pairsOfFlags[index][0] = flagA;, z' J2 j. _% n0 ^+ Y7 u2 w5 ?4 E1 `
      m_pairsOfFlags[index][1] = flagB;
, N9 A$ K9 C, ^/ e5 ]% {% b9 S) l- d0 J }; L' [0 P1 a4 S* X; n- i% w0 b% W2 Y
function changeFlagArraySize(uint newSize) public {
# E" u3 t8 E, Q: t       // 如果 newSize 更小，那么超出的元素会被清除: Z! @7 \/ ^; v0 g
      m_pairsOfFlags.length = newSize;/ b: M" a% J5 \# i. V
}
. F: u( M4 j3 G  M function clear() public {' X: j% q  G$ Q
      // 这些代码会将数组全部清空
2 J# {& f: {5 B" j0 H0 V, V1 f       delete m_pairsOfFlags;
- m- O  u5 ~# n( c4 F       delete m_aLotOfIntegers;
1 }' k1 ^% O3 o       // 这里也是实现同样的功能
: C$ T6 Z& {8 r( c* `$ b% z0 P       m_pairsOfFlags.length = 0;
8 k7 j0 t- b9 l' ?9 [! e1 l7 p }$ W1 Q  w8 t; R: r
bytes m_byteData;
& }7 `6 E0 z- c! ]! B function byteArrays(bytes data) public {
3 [" a; ]9 A: n0 K       // 字节的数组（语言意义中的 byte 的复数 ``bytes``）不一样，因为它们不是填充式存储的，
- h" X1 \- s4 c# U# ^       // 但可以当作和 "uint8[]" 一样对待* a4 _7 P. {# N: i
      m_byteData = data;
% v" C  }0 o7 E; e& A( B; l( Q       m_byteData.length += 7;0 J% x% _0 H, E/ ?1 \
      m_byteData[3] = byte(8);
! A1 Q) z3 }0 d8 G6 j       delete m_byteData[2];7 A( S( ^! Y# [" F# e
}" _: I0 N' ^2 d/ j1 v3 J" K% Y" P
function addFlag(bool[2] flag) public returns (uint) {. W; }4 z' B6 j$ m$ ^" ]
      return m_pairsOfFlags.push(flag);
2 W" n/ a7 O# d3 D8 O }2 }9 z# E+ l7 ^% ~# P+ l$ @
function createMemoryArray(uint size) public pure returns (bytes) {0 c) ]' ]7 w( n
      // 使用 `new` 创建动态 memory 数组：) J. e' a4 I% G, \7 Z. O# }7 h
      uint[2][] memory arrayOfPairs = new uint[2][](size);
' V2 v! W6 g2 _% R; u  ]9 g       // 创建一个动态字节数组：  |! t7 Y9 q& a: ~+ c1 e, b% X
      bytes memory b = new bytes(200);
5 s# i: i6 m9 G       for (uint i = 0; i < b.length; i++)# K0 E/ W; C) \2 Q
         b = byte(i);5 O$ a( a% ]2 |* e& Z! [
      return b;
; V! f3 M- D( W* \2 M- | }
, v1 ]& Y5 X; X6 p: j9 i# I: f, i  X}; K7 `2 m$ I( x' c+ \+ e
结构体1 }* V  Y  W3 g3 d/ Z3 e- N4 p
Solidity 支持通过构造结构体的形式定义新的类型，以下是一个结构体使用的示例：
0 v+ H* C* t. K+ q+ lpragma solidity ^0.4.11;- j, m1 w; E4 X( M
contract CrowdFunding {" t! r2 H; b. A# V; U
// 定义的新类型包含两个属性。
4 W. X5 `! |# g3 `8 A) T3 ~ struct Funder {
6 v. C7 ?# `2 Z6 R3 ?5 c       address addr;3 e% ?0 Q. z5 z1 _0 C, M5 [- X
      uint amount;7 x: ^2 j0 |3 p5 E
}: g/ N8 L8 F3 w9 f
struct Campaign {* ]- d! M. h6 Y! E% [$ }
      address beneficiary;
* i; D" ?1 R5 |3 A9 A% B+ U       uint fundingGoal;& l1 q# z4 N. ^4 S1 z; C" w4 Z
      uint numFunders;
5 S/ ~6 Q8 [1 Y0 P, B       uint amount;5 `/ v0 X  Q' }1 i6 W" S
      mapping (uint => Funder) funders;
, C* n% e% p- ? }
* x& \1 T/ r: u% V' Q/ m6 ^$ S uint numCampaigns;
/ X* d, |- I. k9 U* n; q7 C mapping (uint => Campaign) campaigns;
$ h9 R+ S4 G" }: U6 j function newCampaign(address beneficiary, uint goal) public returns (uint campaignID) {
( o  b; K0 g4 X6 |( T0 f+ Z! @       campaignID = numCampaigns++; // campaignID 作为一个变量返回+ v4 {6 o7 K) J  f
      // 创建新的结构体示例，存储在 storage 中。我们先不关注映射类型。* S* |+ b1 G' G0 o/ k3 d" |- l
      campaigns[campaignID] = Campaign(beneficiary, goal, 0, 0);( H9 q+ ^* V2 j
}) B9 ^5 v% I) [$ f, c: O
function contribute(uint campaignID) public payable {
2 M' \2 ^* z  g: ~  l. s2 X       Campaign storage c = campaigns[campaignID];
* H7 e. C  W0 @. u7 [  N' ?       // 以给定的值初始化，创建一个新的临时 memory 结构体，
; [8 e- h: r* q8 }5 ?       // 并将其拷贝到 storage 中。6 H. b7 L! }1 g' A/ H
      // 注意你也可以使用 Funder(msg.sender, msg.value) 来初始化。4 w6 ?. l0 {; J' V4 W
      c.funders[c.numFunders++] = Funder({addr: msg.sender, amount: msg.value});
: T/ u. Y/ X; p       c.amount += msg.value;
8 j! e1 i1 b# A- M& l3 E$ y }
. B, @; I9 F& I$ J! s function checkGoalReached(uint campaignID) public returns (bool reached) {; n- @2 `( ?& H) O: n7 P
      Campaign storage c = campaigns[campaignID];! R. _8 l6 t2 {' R: s% y1 x
      if (c.amount < c.fundingGoal)5 k) }. ^' y* M3 Y6 q2 ~0 v
         return false;9 v2 o1 X3 V* s* m* L9 O; b$ u
      uint amount = c.amount;, _5 ^. i5 B; }* Y8 D; u0 J: p
      c.amount = 0;
1 y& G. n+ e5 c5 {/ {. L       c.beneficiary.transfer(amount);
! O- P% A* ^( v4 e/ t" F       return true;
" s# U1 U4 [+ _. k- T& ~/ s }
  s. h3 N. y/ O2 I( @9 _- D}
/ g: n4 Y# N- {! ~+ Z8 A2 g上面的合约只是一个简化版的众筹合约，但它已经足以让我们理解结构体的基础概念。9 g# P; u# \6 t2 w
结构体类型可以作为元素用在映射和数组中，其自身也可以包含映射和数组作为成员变量。; R& g/ \; W; b$ `8 h" _6 e7 n
尽管结构体本身可以作为映射的值类型成员，但它并不能包含自身。# B) L; B$ Z5 N% r! G  T% ~
这个限制是有必要的，因为结构体的大小必须是有限的。' N2 v! \8 t7 m. W0 e$ c5 _
注意在函数中使用结构体时，一个结构体是如何赋值给一个局部变量（默认存储位置是 |storage| ）的。
9 |, X- [2 Z  T0 Q6 b4 F! j4 [在这个过程中并没有拷贝这个结构体，而是保存一个引用，所以对局部变量成员的赋值实际上会被写入状态。
* K- M+ @: L6 h( H# u" e3 t9 Y当然，你也可以直接访问结构体的成员而不用将其赋值给一个局部变量，就像这样，
; ?4 U5 ~" |+ \( s* s映射5 t5 b  O# o, ~3 R
映射类型在声明时的形式为 mapping(_KeyType => _ValueType)。: W% P( S1 e, N( Q0 d3 H
其中 _KeyType 可以是除了映射、变长数组、合约、枚举以及结构体以外的几乎所有类型。$ L- l/ d& E4 M/ D
_ValueType 可以是包括映射类型在内的任何类型。
5 |: r7 P! h3 V: V映射可以视作哈希表 <https://en.wikipedia.org/wiki/Hash_table>，它们在实际的初始化过程中创建每个可能的 key，, y% N8 K. S9 m
并将其映射到字节形式全是零的值：一个类型的 :ref:默认值 <default-value>。然而下面是映射与哈希表不同的地方：. D, n4 Y( Z  [- a' k) E
在映射中，实际上并不存储 key，而是存储它的 keccak256 哈希值，从而便于查询实际的值。& H* c% u# ^+ \
正因为如此，映射是没有长度的，也没有 key 的集合或 value 的集合的概念。0 l. n! ~6 Q9 M' O5 u- ~. Z
只有状态变量（或者在 internal 函数中的对于存储变量的引用）可以使用映射类型。。5 Z1 S8 `( z' n6 _! {9 g9 p
可以将映射声明为 public，然后来让 Solidity 创建一个 :ref:getter <visibility-and-getters>。" j0 `" k2 M/ [. e& D
_KeyType 将成为 getter 的必须参数，并且 getter 会返回 _ValueType。
( o- t, F  @; h+ p* c2 h; ]/ T_ValueType 也可以是一个映射。这时在使用 getter 时将将需要递归地传入每个 _KeyType 参数。8 t# q0 e) s1 Z5 K0 a
pragma solidity ^0.4.0;
3 F! J2 A, e5 u5 ^! g6 c8 jcontract MappingExample {
# K' ~) |. q5 u# O mapping(address => uint) public balances;
1 l; W& J- J- }' [- j function update(uint newBalance) public {( P1 f$ {, p! O$ @* n7 }* b4 }
      balances[msg.sender] = newBalance;, B, i" N/ _) @! u
}
% K" e( j9 }# i5 ]: N}
7 w. C4 H3 j8 `8 G4 Zcontract MappingUser {, A% n0 Q; m: J& @+ y: n0 c6 k$ g
function f() public returns (uint) {' u  r4 {# v  D
      MappingExample m = new MappingExample();" ]) p( t7 A% `  i0 f
      m.update(100);
0 S" T8 ?8 @- q1 G5 p/ s2 S       return m.balances(this);) V: v. a5 J; F2 i& z/ W8 s9 v! L
}
0 j) ~- T" u$ ~) K: w8 W7 o3 y. ?' |}
% n2 Y8 J, S' q/ f… note::
+ k9 R$ |4 K1 |! a0 e: n映射不支持迭代，但可以在此之上实现一个这样的数据结构。
  V/ P9 t9 k/ {4 q6 a0 o例子可以参考可迭代的映射 <https://github.com/ethereum/dapp-bin/blob/master/library/iterable_mapping.sol>_。% r/ @5 H% c- I2 d2 @, Q
涉及 LValues 的运算符, W% \% y$ c/ l: k
如果 a 是一个 LValue（即一个变量或者其它可以被赋值的东西），以下运算符都可以使用简写：2 S/ m# ^/ B. h7 m8 \: x+ u+ \" C
a += e 等同于 a = a + e。其它运算符 -=， *=， /=， %=， |=， &= 以及 ^= 都是如此定义的。
/ o/ Y/ Q( u, d+ A* M/ {  qa++ 和 a-- 分别等同于 a += 1 和 a -= 1，但表达式本身的值等于 a 在计算之前的值。& U4 G) B! F) S/ L
与之相反，--a 和 ++a 虽然最终 a 的结果与之前的表达式相同，但表达式的返回值是计算之后的值。& D: q% e' m& F5 L
删除( |& E5 x+ J* Q
delete a 的结果是将 a 的类型在初始化时的值赋值给 a。即对于整型变量来说，相当于 a = 0，/ _9 \2 B7 R+ [3 d# |9 {  N
但 delete 也适用于数组，对于动态数组来说，是将数组的长度设为 0，而对于静态数组来说，是将数组中的所有元素重置。
6 O' O( N, H: A6 \) D$ u/ q如果对象是结构体，则将结构体中的所有属性重置。& O* ]* L7 _) X3 E* j! t7 L+ ]
delete 对整个映射是无效的（因为映射的键可以是任意的，通常也是未知的）。
( _; r( t( ]% A9 L因此在你删除一个结构体时，结果将重置所有的非映射属性，这个过程是递归进行的，除非它们是映射。' q* w! r+ D) l% Q# Y! c# J+ C. n
然而，单个的键及其映射的值是可以被删除的。0 ~' L4 `) Z3 |% @2 n, w. k
理解 delete a 的效果就像是给 a 赋值很重要，换句话说，这相当于在 a 中存储了一个新的对象。1 j( W$ @1 K2 Z/ z
pragma solidity ^0.4.0;
7 V: ?: k5 q, m3 Bcontract DeleteExample {3 X1 {/ ^' H6 ?" J+ Q
uint data;6 v. p/ o9 @; ~9 R/ U
uint[] dataArray;
$ i  m% U6 J" [7 w4 w0 W function f() public {: A# U5 d) Q' Y; U; ^4 d+ I6 @; I' V
      uint x = data;
1 u8 ^$ ]! j  i8 R  r$ I  c0 y& X       delete x; // 将 x 设为 0，并不影响数据
, v8 p+ p  c5 A, u4 \  x       delete data; // 将 data 设为 0，并不影响 x，因为它仍然有个副本
1 s* X& V+ J% G  v5 x0 ?       uint[] storage y = dataArray;
0 O0 f: u0 ^8 X8 `       delete dataArray;
+ X6 U2 v3 Y$ N# n) [       // 将 dataArray.length 设为 0，但由于 uint[] 是一个复杂的对象，y 也将受到影响，
1 h5 k- z4 U  }9 U3 A: }3 P       // 因为它是一个存储位置是 storage 的对象的别名。( d* R  q3 Z, V/ |2 o
      // 另一方面："delete y" 是非法的，引用了 storage 对象的局部变量只能由已有的 storage 对象赋值。
3 U, C' p* }+ A; G+ e2 M0 _ }9 T9 x# [( |* b; }% A' B1 y
}5 f4 I  ~2 j; D# k) p+ J0 ]! k
基本类型之间的转换
% ^! N, _' w& I6 o隐式转换/ N$ h2 L$ \2 g6 }/ w6 G8 P
如果一个运算符用在两个不同类型的变量之间，那么编译器将隐式地将其中一个类型转换为另一个类型（不同类型之间的赋值也是一样）。
7 s# k5 X) N+ ^) `, J! b一般来说，只要值类型之间的转换在语义上行得通，而且转换的过程中没有信息丢失，那么隐式转换基本都是可以实现的：8 ~( ?2 h4 v" p" _
uint8 可以转换成 uint16，int128 转换成 int256，但 int8 不能转换成 uint256
, I1 w* m: b6 l2 u（因为 uint256 不能涵盖某些值，例如，-1）。' H- r! Q$ _) q/ _' c
更进一步来说，无符号整型可以转换成跟它大小相等或更大的字节类型，但反之不能。
/ C) |: n; O+ q2 J& [任何可以转换成 uint160 的类型都可以转换成 address 类型。
" t/ L0 S# V0 @显式转换
, [6 @# N/ f9 j; `8 f7 |如果某些情况下编译器不支持隐式转换，但是你很清楚你要做什么，这种情况可以考虑显式转换。
- X% g+ t* t; x6 X- _8 y注意这可能会发生一些无法预料的后果，因此一定要进行测试，确保结果是你想要的！
* t# \) O% ~; u% t9 N2 m下面的示例是将一个 int8 类型的负数转换成 uint：  d8 h; t4 j- x+ C3 }
int8 y = -3;
9 O, m3 F6 b) n8 quint x = uint(y);
( ], t6 F8 R0 j! _- u' B这段代码的最后，x 的值将是 0xfffff..fd （64 个 16 进制字符），因为这是 -3 的 256 位补码形式。
  m0 l6 M: g% t7 u( h4 ^6 h4 b* C如果一个类型显式转换成更小的类型，相应的高位将被舍弃% ~, a# @' T( p* |- _9 u
uint32 a = 0x12345678;& P& R4 x- d3 m; T8 I) A$ z
uint16 b = uint16(a); // 此时 b 的值是 0x5678
% x/ h4 p4 Q( j. E8 Q  |- Q0 f类型推断  r5 ~/ u8 b& @7 o. Y; E
为了方便起见，没有必要每次都精确指定一个变量的类型，编译器会根据分配该变量的第一个表达式的类型自动推断该变量的类型3 i5 O  O: t8 Y; r/ X0 l& w$ m' H
uint24 x = 0x123;7 Z* M5 c3 D3 k8 x$ t# f
var y = x;2 X' s: ]4 `* Y. N8 k3 ~- _) ?
这里 y 的类型将是 uint24。不能对函数参数或者返回参数使用 var。0 m* h# W. g. F: u
… warning::8 f% c/ n7 ?3 S8 d7 T" D
类型只能从第一次赋值中推断出来，因此以下代码中的循环是无限的，5 C8 r$ [- z- a/ G- N% g
原因是i 的类型是 uint8，而这个类型变量的最大值比 2000 小。
+ ]1 a, E$ `7 m7 H" L* pfor (var i = 0; i < 2000; i++) { ... }