注:本教程为技术教程,不谈论且不涉及炒作任何数字货币
address
等以太坊独有的类型,Solidity 源码文件通常以 .sol 作为扩展名Solidity的语法接近于JavaScript,是一种面向对象的语言。但作为一种真正意义上运行在网络上的去中心合约,它又有很多的不同:
payable
等关键字,可以在语言层面直接支持支付。Solidity 源代码要成为可以运行在以太坊上的智能合约需要经历如下的
步骤:
Remix 是一个开源的 IDE,是一个浏览器在线编辑器。作为 Solidity 智能合约开发环境,Solidity IDE Remix(在线浏览器编辑器)提供基本的编译、部署至本地或测试网络、执行合约等功能。
在浏览器端有俩个选择,分别为英文版与中文版(有些许差别)
PS.可能需要科学上网
下面都以英文版
为例子介绍
1、浏览器输入 https://remix.ethereum.org/
如果出现加载慢,加载不完全的情况,刷新几次即可
2、左侧可以看到我们所有的文件,下面是我们的remix控制台
上图小图标从左到右依次为:
控制台图片如下:
3、点击文件样式图标输入我们的文件名即可(以.sol为后缀)
4、安装必要的插件
点击插件管理器,页面中为这个图标
安装compiler
搜索关键字compiler
5、写一个简单的样例
pragma solidity ^0.4.0;
contract SimpleStorage {
uint storedData;
function set(uint x) public {
storedData = x;
}
function get() public view returns (uint) {
return storedData;
}
}
第一行就是告诉大家源代码使用Solidity版本0.4.0写的,并且使用0.4.0以上版本运行也没问题(最高到0.5.0,但是不包含0.5.0)。这是为了确保合约不会在新的编译器版本中突然行为异常。关键字 pragma
的含义是,一般来说,pragmas(编译指令)是告知编译器如何处理源代码的指令的。
Solidity中合约的含义就是一组代码(它的 函数 )和数据(它的 状态 ),它们位于以太坊区块链的一个特定地址上。 代码行 uint storedData
; 声明一个类型为 uint
(256位无符号整数)的状态变量,叫做 storedData
。 你可以认为它是数据库里的一个位置,可以通过调用管理数据库代码的函数进行查询和变更。对于以太坊来说,上述的合约就是拥有合约(owning contract)。在这种情况下,函数 set
和 get
可以用来变更或取出变量的值。
要访问一个状态变量,并不需要像 this.
这样的前缀,虽然这是其他语言常见的做法。
该合约能完成的事情并不多(由于以太坊构建的基础架构的原因):它能允许任何人在合约中存储一个单独的数字,并且这个数字可以被世界上任何人访问,且没有可行的办法阻止你发布这个数字。当然,任何人都可以再次调用 set
,传入不同的值,覆盖你的数字,但是这个数字仍会被存储在区块链的历史记录中。
点击compile test.sol
,可以看到编译按钮,建议将Auto compile
打钩(自动编译),之后会在编译图标上看到一个以绿色为背景的对勾。
编译组件说明:
Compiler
可以选择Solidity的编译器版本Language
可以选择编程语言EVM Version
可以选择EVM虚拟机版本Auto compile
可以设置自动编译,修改完代码后自动执行编译操作Enable optimization
可以设置对编译进行优化Hide warnings
可以设置隐藏警告信息。Contract
选择需要编译的合约Publish on Swarm
和Publish on Ipfs
分别将合约上传到Swarm和Ipfs这两个分布式文件系统上去Compilation Details
很重要,可以查看编译的信息,包括ABI、字节码、函数Hash等ABI
和Bytecode
分别复制ABI和字节码。我们点击Compilation Details
就能看到编译之后的一些信息,如下图所示(部分)
NAME
:合约名METADATA
:一些编译相关的信息,比如版本、所用的语言、设置等BYTECODE
:写入区块的字节码ABI
:此智能合约对应的 ABI ,也就是我们合约里面定义的一些接口WEB3DEPLOY
:智能合约编译之后的发布命令,这个就是比较重要的,之后的web3就是调用这段命令来部署合约的METADATAHASH
:数据的一个哈希值SWARMLOCATION
:Swarm网络的一个地址FUNCTIONHASHES
:合约定义的方法的hash,其实我们执行合约的时候就是通过这个hash去找到对应的方法进行执行的GASESTIMATES
:关于矿工费的一个预算,在ETH上进行合约的部署,执行等都是需要矿工费的。一般合约代码越多矿工费越高。点击下面的run图标,可以看到部署,以及账户信息,环境等等
点击deploy之后天可以看到自己的合约已经部署完成,打开之后可以看见我们写的函数set
,get
了,给set
函数输入一个值,点击get
会得到相应的值
Environment
表示合约部署的环境。Javascript VM
是虚拟了一个节点,而Injected Web3
和Web3 Provider
则真正连接一个节点。Account
代表不同的虚拟账户,每个虚拟账户每个有 100 ETHDeploy
表示合约部署按钮Deployed Contracts
表示已经部署的合约中文版界面与英文版界面有些许不一致,但都大同小异,想了解同学可以查看本博客(界面与中文版大致相同):
Solidity语言编辑器REMIX指导大全
本地配置:
Docker
我们为编译器提供了最新的docker构建。 stable 仓库里的是已发布的版本,nightly 仓库则是在开发分支中的带有不稳定变更的版本。
docker run ethereum/solc:stable solc --version
目前,docker 镜像只含有 solc 的可执行程序,因此你需要额外的工作去把源代码和输出目录连接起来。
由于篇幅有限,以下只会讲解一些较基础、重要的概念(足够后面使用),有些可能会一带而过或者“忽略”,如果大家途中有没太明白地方建议先百度、Google,或者查看此教程Solifity中文文档、Solidity英文文档
源文件可以被版本杂注pragma所注解,表明要求的编译器版本
pragma solidity ^0.4.0;
这样,源文件将既不允许低于 0.4.0 版本的编译器编译, 也不允许高于(包含) 0.5.0 版本的编译器编译(第二个条件因使用 ^ 被添加)。 这种做法的考虑是,编译器在 0.5.0 版本之前不会有重大变更,所以可确保源代码始终按预期被编译。 上面例子中不固定编译器的具体版本号,因此编译器的补丁版也可以使用。
import(导入其它源文件)
import "filename";
从“filename”中导入所有的全局符号到当前全局作用域中
import * as symbolName from "filename";
创建一个新的全局符号 symbolName,其成员均来自 “filename”中全局符号
import {
symbol1 as alias, symbol2} from "filename";
创建新的全局符号 alias 和 symbol2,分别从 “filename” 引用 symbol1 和 symbol2
import "filename" as symbolName;
这条语句等同于 import * as symbolName from “filename”;
注释
可以使用单行注释(//)和多行注释(/…/)
// 这是一个单行注释。
/*
这是一个
多行注释。
*/
可能的取值为字符常量值 true 或 false
例子:
pragma solidity ^0.4.0;
contract helloworld {
bool boola=true; //声明一个布尔类型的值,只用一个等号
function booltesta() public view returns(bool){
return boola;
}
function booltestb(int a,int b) public pure returns(bool){
return a==b;
}
}
int
/ uint
:分别表示有符号和无符号的不同位数的整型变量。 支持关键字 uint8
到 uint256
(无符号,从 8 位到 256 位)以及 int8
到 int256
,以 8 位为步长递增。 uint
和 int
分别是 uint256
和 int256
的别名。
fixed
/ ufixed
:表示各种大小的有符号和无符号的定长浮点型。 在关键字 ufixedMxN
和 fixedMxN
中,M
表示该类型占用的位数,N
表示可用的小数位数。 M
必须能整除 8,即 8 到 256 位。 N
则可以是从 0 到 80 之间的任意数。 ufixed
和 fixed
分别是 ufixed128x19
和 fixed128x19
的别名。
地址类型存储一个 20 字节的值(以太坊地址的大小)。 地址类型也有成员变量,并作为所有合约的基础。
地址类型成员变量:balance
和 transfer
可以使用 balance 属性来查询一个地址的余额, 也可以使用 transfer 函数向一个地址发送 以太币 (以 wei 为单位):
address x = 0x123;
address myAddress = this;
if (x.balance < 10 && myAddress.balance >= 10) x.transfer(10);
注:如果 x
是一个合约地址,它的代码(更具体来说是它的 fallback 函数,如果有的话)会跟 transfer
函数调用一起执行(这是 EVM 的一个特性,无法阻止)。 如果在执行过程中用光了 gas 或者因为任何原因执行失败,以太币 交易会被打回,当前的合约也会在终止的同时抛出异常。
关键字有 bytes1, bytes2, bytes3, …, bytes32
.length
表示这个字节数组的长度(只读).
注:可以将 byte[]
当作字节数组使用,但这种方式非常浪费存储空间,准确来说,是在传入调用时,每个元素会浪费 31 字节。 更好地做法是使用 bytes
。
bytes
:变长字节数组。它并不是值类型。
string
:变长 UTF-8 编码字符串类型。并不是值类型。
比如像 0xdCad3a6d3569DF655070DEd06cb7A1b2Ccd1D3AF
这样的通过了地址校验和测试的十六进制字面常数属于 address
类型。 长度在 39 到 41 个数字的,没有通过校验和测试而产生了一个警告的十六进制字面常数视为正常的有理数字面常数。
整数字面常数由范围在 0-9 的一串数字组成,表现成十进制。 例如,69 表示数字 69。 Solidity 中是没有八进制的,因此前置 0 是无效的。
十进制小数字面常数带有一个 .,至少在其一边会有一个数字。 比如:1.,.1
,和 1.3
。
科学符号也是支持的,尽管指数必须是整数,但底数可以是小数。 比如:2e10, -2e10, 2e-10, 2.5e1
。
数值字面常数表达式本身支持任意精度,除非它们被转换成了非字面常数类型(也就是说,当它们出现在非字面常数表达式中时就会发生转换)。 这意味着在数值常量表达式中, 计算不会溢出而除法也不会截断。
例如, (2**800 + 1) - 2**800
的结果是字面常数 1 (属于 uint8
类型),尽管计算的中间结果已经超过了 以太坊虚拟机 的机器字长度。 此外, .5 * 8
的结果是整型 4 (尽管有非整型参与了计算)
字符串字面常数是指由双引号或单引号引起来的字符串("foo"
或者 'bar'
)。 不像在 C 语言中那样带有结束符;"foo"
相当于 3 个字节而不是 4 个。 和整数字面常数一样,字符串字面常数的类型也可以发生改变,但它们可以隐式地转换成 bytes1,……,bytes32
,如果合适的话,还可以转换成 bytes
以及 string
。
十六进制字面常数以关键字 hex
打头,后面紧跟着用单引号或双引号引起来的字符串(例如,hex"001122FF"
)。 字符串的内容必须是一个十六进制的字符串,它们的值将使用二进制表示。
一种用户可以定义类型的方法,与C语言类似,默认从0开始递增,一般用来模拟合约的状态
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 (
部分。
函数类型默认是内部函数,因此不需要声明 internal
关键字。 与此相反的是,合约中的函数本身默认是 public
的,只有当它被当做类型名称时,默认才是内部函数。
有两种方法可以访问当前合约中的函数:一种是直接使用它的名字,f
,另一种是使用 this.f
。 前者适用于内部函数,后者适用于外部函数。
如果当函数类型的变量还没有初始化时就调用它的话会引发一个异常。 如果在一个函数被 delete
之后调用它也会发生相同的情况。
如果外部函数类型在 Solidity 的上下文环境以外的地方使用,它们会被视为 function
类型。 该类型将函数地址紧跟其函数标识一起编码为一个 bytes24
类型。
请注意,当前合约的 public 函数既可以被当作内部函数也可以被当作外部函数使用。 如果想将一个函数当作内部函数使用,就用 f
调用,如果想将其当作外部函数,使用 this.f
。
Solidity函数可见性
函数的可见性可以指定为 external,public ,internal 或者 private;对于状态变量,不能设置为 external ,默认是 internal。
Solidity函数状态可变性
内部函数调用
当前合约中的函数可以直接(“从内部”)调用,也可以递归调用,就像下边这个荒谬的例子一样
pragma solidity ^0.4.16;
contract C {
function g(uint a) public pure returns (uint ret) {
return f(); }
function f() internal pure returns (uint ret) {
return g(7) + f(); }
}
这些函数调用在 EVM 中被解释为简单的跳转。这样做的效果就是当前内存不会被清除,也就是说,通过内部调用在函数之间传递内存引用是非常有效的。
外部函数调用
表达式 this.g(8)
; 和 c.g(2)
; (其中 c 是合约实例)也是有效的函数调用,但是这种情况下,函数将会通过一个消息调用来被“外部调用”,而不是直接的跳转。 请注意,不可以在构造函数中通过 this 来调用函数,因为此时真实的合约实例还没有被创建。
如果想要调用其他合约的函数,需要外部调用。对于一个外部调用,所有的函数参数都需要被复制到内存。
当调用其他合约的函数时,随函数调用发送的 Wei 和 gas 的数量可以分别由特定选项 .value()
和 .gas()
指定:
pragma solidity ^0.4.0;
contract InfoFeed {
function info() public payable returns (uint ret) {
return 42; }
}
contract Consumer {
InfoFeed feed;
function setFeed(address addr) public {
feed = InfoFeed(addr); }
function callFeed() public {
feed.info.value(10).gas(800)(); }
}
payable
修饰符要用于修饰 info
,否则,.value()
选项将不可用。
注意,表达式 InfoFeed(addr)
进行了一个的显式类型转换,说明”我们知道给定地址的合约类型是 InfoFeed
“并且这不会执行构造函数。 显式类型转换需要谨慎处理。绝对不要在一个你不清楚类型的合约上执行函数调用。
我们也可以直接使用 function setFeed(InfoFeed _feed) { feed = _feed; }
。 注意一个事实,feed.info.value(10).gas(800)
只(局部地)设置了与函数调用一起发送的 Wei 值和 gas 的数量,只有最后的圆括号执行了真正的调用。
如果被调函数所在合约不存在(也就是账户中不包含代码)或者被调用合约本身抛出异常或者 gas 用完等,函数调用会抛出异常。
比起之前讨论过的值类型,在处理复杂的类型(即占用的空间超过 256 位的类型)时,我们需要更加谨慎。 由于拷贝这些类型变量的开销相当大,我们不得不考虑它的存储位置,是将它们保存在 内存 (并不是永久存储)中, 还是 存储 (保存状态变量的地方)中。
所有的复杂类型,即 数组 和 结构 类型,都有一个额外属性,“数据位置”,说明数据是保存在 内存 中还是 存储 中。 根据上下文不同,大多数时候数据有默认的位置,但也可以通过在类型名后增加关键字 storage
或 memory
进行修改。 函数参数(包括返回的参数)的数据位置默认是 memory
, 局部变量的数据位置默认是 storage
,状态变量的数据位置强制是 storage
。
也存在第三种数据位置, calldata
,这是一块只读的,且不会永久存储的位置,用来存储函数参数。 外部函数的参数(非返回参数)的数据位置被强制指定为 calldata
,效果跟 memory
差不多。
例子:
pragma solidity ^0.4.0;
contract C {
uint[] x; // x 的数据存储位置是 storage
// memoryArray 的数据存储位置是 memory
function f(uint[] memoryArray) public {
x = memoryArray; // 将整个数组拷贝到 storage 中,可行
var y = x; // 分配一个指针(其中 y 的数据存储位置是 storage),可行
y[7]; // 返回第 8 个元素,可行
y.length = 2; // 通过 y 修改 x,可行
delete x; // 清除数组,同时修改 y,可行
// 下面的就不可行了;需要在 storage 中创建新的未命名的临时数组, /
// 但 storage 是“静态”分配的:
// y = memoryArray;
// 下面这一行也不可行,因为这会“重置”指针,
// 但并没有可以让它指向的合适的存储位置。
// delete y;
g(x); // 调用 g 函数,同时移交对 x 的引用
h(x); // 调用 h 函数,同时在 memory 中创建一个独立的临时拷贝
}
function g(uint[] storage storageArray) internal {
}
function h(uint[] memoryArray) public {
}
}
归纳:
强制指定的数据位置:
默认数据位置:
数组可以在声明时指定长度,也可以动态调整大小。 对于 存储 的数组来说,元素类型可以是任意的(即元素也可以是数组类型,映射类型或者结构体)。 对于 内存 的数组来说,元素类型不能是映射类型,如果作为 public
函数的参数,它只能是 ABI
类型。
一个元素类型为 T
,固定长度为 k
的数组可以声明为 T[k]
,而动态数组声明为 T[]
。
举个例子,一个长度为 5,元素类型为 uint
的动态数组的数组,应声明为 uint[][5]
(注意这里跟其它语言比,数组长度的声明位置是反的)。 要访问第三个动态数组的第二个元素,你应该使用 x[2][1]
(数组下标是从 0 开始的,且访问数组时的下标顺序与声明时相反,也就是说,x[2]
是从右边减少了一级)。。
bytes
和 string
类型的变量是特殊的数组。 bytes
类似于 byte[]
,但它在 calldata
中会被“紧打包”(译者注:将元素连续地存在一起,不会按每 32 字节一单元的方式来存放)。 string
与 bytes
相同,但(暂时)不允许用长度或索引来访问。
注:
如果想要访问以字节表示的字符串 s,请使用 bytes(s)
.length / bytes(s)[7] = 'x'
;。 注意这时你访问的是 UTF-8
形式的低级bytes
类型,而不是单个的字符。
成员
length
:
数组有 length 成员变量表示当前数组的长度。 动态数组可以在 存储 (而不是 内存 )中通过改变成员变量 .length 改变数组大小。 并不能通过访问超出当前数组长度的方式实现自动扩展数组的长度。 一经创建,内存 数组的大小就是固定的(但却是动态的,也就是说,它依赖于运行时的参数)。
push
:
变长的 存储 数组以及 bytes 类型(而不是 string 类型)都有一个叫做 push 的成员函数,它用来附加新的元素到数组末尾。 这个函数将返回新的数组长度。
例子:
pragma solidity ^0.4.16;
contract ArrayContract {
uint[2**20] m_aLotOfIntegers;
// 注意下面的代码并不是一对动态数组,
// 而是一个数组元素为一对变量的动态数组(也就是数组元素为长度为 2 的定长数组的动态数组)。
bool[2][] m_pairsOfFlags;
// newPairs 存储在 memory 中 —— 函数参数默认的存储位置
function setAllFlagPairs(bool[2][] newPairs) public {
// 向一个 storage 的数组赋值会替代整个数组
m_pairsOfFlags = newPairs;
}
function setFlagPair(uint index, bool flagA, bool flagB) public {
// 访问一个不存在的数组下标会引发一个异常
m_pairsOfFlags[index][0] = flagA;
m_pairsOfFlags[index][1] = flagB;
}
function changeFlagArraySize(uint newSize) public {
// 如果 newSize 更小,那么超出的元素会被清除
m_pairsOfFlags.length = newSize;
}
function clear() public {
// 这些代码会将数组全部清空
delete m_pairsOfFlags;
delete m_aLotOfIntegers;
// 这里也是实现同样的功能
m_pairsOfFlags.length = 0;
}
bytes m_byteData;
function byteArrays(bytes data) public {
// 字节的数组(语言意义中的 byte 的复数 ``bytes``)不一样,因为它们不是填充式存储的,
// 但可以当作和 "uint8[]" 一样对待
m_byteData = data;
m_byteData.length += 7;
m_byteData[3] = byte(8);
delete m_byteData[2];
}
function addFlag(bool[2] flag) public returns (uint) {
return m_pairsOfFlags.push(flag);
}
function createMemoryArray(uint size) public pure returns (bytes) {
// 使用 `new` 创建动态 memory 数组:
uint[2][] memory arrayOfPairs = new uint[2][](size);
// 创建一个动态字节数组:
bytes memory b = new bytes(200);
for (uint i = 0; i < b.length; i++)
b[i] = byte(i);
return b;
}
}
Solidity 支持通过构造结构体的形式定义新的类型,以下是一个结构体的示例:
struct Funder {
address addr;
uint amount;
}
struct Campaign {
address beneficiary;
uint fundingGoal;
uint numFunders;
uint amount;
mapping (uint => Funder) funders;
}
mapping(_KeyType => _ValueType)
。 其中 _KeyType
可以是除了映射、变长数组、合约、枚举以及结构体以外的几乎所有类型。 _ValueType
可以是包括映射类型在内的任何类型。映射可以视作 哈希表 https://en.wikipedia.org/wiki/Hash_table,它们在实际的初始化过程中创建每个可能的 key, 并将其映射到字节形式全是零的值:一个类型的 默认值。然而下面是映射与哈希表不同的地方: 在映射中,实际上并不存储 key,而是存储它的 keccak256
哈希值,从而便于查询实际的值。
正因为如此,映射是没有长度的,也没有 key
的集合或 value
的集合的概念。
只有状态变量(或者在 internal 函数中的对于存储变量的引用)可以使用映射类型。。
可以将映射声明为 public
,然后来让 Solidity 创建一个 getter。_KeyType
将成为 getter 的必须参数,并且 getter 会返回 _ValueType
。
_ValueType
也可以是一个映射。这时在使用 getter 时将将需要递归地传入每个 _KeyType
参数。
pragma solidity ^0.4.0;
contract MappingExample {
mapping(address => uint) public balances;
function update(uint newBalance) public {
balances[msg.sender] = newBalance;
}
}
contract MappingUser {
function f() public returns (uint) {
MappingExample m = new MappingExample();
m.update(100);
return m.balances(this);
}
}
delete a
的结果是将 a
的类型在初始化时的值赋值给 a
。即对于整型变量来说,相当于 a = 0
, 但 delete 也适用于数组,对于动态数组来说,是将数组的长度设为 0,而对于静态数组来说,是将数组中的所有元素重置。 如果对象是结构体,则将结构体中的所有属性重置。
delete 对整个映射是无效的(因为映射的键可以是任意的,通常也是未知的)。 因此在你删除一个结构体时,结果将重置所有的非映射属性,这个过程是递归进行的,除非它们是映射。 然而,单个的键及其映射的值是可以被删除的。
理解 delete a
的效果就像是给 a
赋值很重要,换句话说,这相当于在 a
中存储了一个新的对象。
pragma solidity ^0.4.0;
contract DeleteExample {
uint data;
uint[] dataArray;
function f() public {
uint x = data;
delete x; // 将 x 设为 0,并不影响数据
delete data; // 将 data 设为 0,并不影响 x,因为它仍然有个副本
uint[] storage y = dataArray;
delete dataArray;
// 将 dataArray.length 设为 0,但由于 uint[] 是一个复杂的对象,y 也将受到影响,
// 因为它是一个存储位置是 storage 的对象的别名。
// 另一方面:"delete y" 是非法的,引用了 storage 对象的局部变量只能由已有的 storage 对象赋值。
}
}
以太币 单位之间的换算就是在数字后边加上 wei
、 finney
、 szabo
或 ether
来实现的,如果后面没有单位,缺省为 Wei
。例如 2 ether == 2000 finney
的逻辑判断值为 true
。
秒是缺省时间单位,在时间单位之间,数字后面带有 seconds
、 minutes
、 hours
、 days
、 weeks
和 years
的可以进行换算,基本换算关系与现实生活相符。
在全局命名空间中已经存在了(预设了)一些特殊的变量和函数,他们主要用来提供关于区块链的信息或一些通用的工具函数。
区块和交易属性
block.blockhash(uint blockNumber) returns (bytes32)
:指定区块的区块哈希——仅可用于最新的 256 个区块且不包括当前区块;而 blocks 从 0.4.22 版本开始已经不推荐使用,由 blockhash(uint blockNumber)
代替block.coinbase (address)
: 挖出当前区块的矿工地block.difficulty (uint)
: 当前区块难度block.gaslimit (uint)
: 当前区块 gas
限额block.number (uint
): 当前区块号block.timestamp (uint)
: 自 unix epoch
起始当前区块以秒计的时间戳gasleft() returns (uint256)
:剩余的 gas
msg.data (bytes)
: 完整的 calldata
msg.gas (uint)
: 剩余 gas
- 自 0.4.21 版本开始已经不推荐使用,由 gesleft() 代替msg.sender (address)
: 消息发送者(当前调用)msg.sig (bytes4)
: calldata 的前 4 字节(也就是函数标识符)msg.value (uint)
: 随消息发送的 wei 的数量now (uint)
: 目前区块时间戳(block.timestamp
)tx.gasprice (uint)
: 交易的gas
价格tx.origin (address)
: 交易发起者(完全的调用链)ABI 编码函数
abi.encode(...) returns (bytes)
: ABI - 对给定参数进行编码abi.encodePacked(...) returns (bytes)
:对给定参数执行 紧打包编码abi.encodeWithSelector(bytes4 selector, ...) returns (bytes):
ABI - 对给定参数进行编码,并以给定的函数选择器作为起始的 4 字节数据一起返回abi.encodeWithSignature(string signature, ...) returns (bytes)
:等价于 abi.encodeWithSelector(bytes4(keccak256(signature), ...)
错误处理
assert(bool condition)
:require(bool condition)
:require(bool condition, string message)
:revert()
:revert(string reason)
:地址相关
.balance (uint256)
:.transfer(uint256 amount)
:.send(uint256 amount) returns (bool)
:.call(...) returns (bool)
:.callcode(...) returns (bool)
:.delegatecall(...) returns (bool):
avaScript 中的大部分控制结构在 Solidity 中都是可用的,除了 switch
和 goto
。 因此 Solidity 中有 if,else,while,do,for,break,continue,return,? :
这些与在 C 或者 JavaScript 中表达相同语义的关键词。
用于表示条件的括号 不可以 被省略,单语句体两边的花括号可以被省略。
注意,与 C 和 JavaScript 不同, Solidity 中非布尔类型数值不能转换为布尔类型,因此 if (1) { ... }
的写法在 Solidity 中 无效 。
当一个函数有多个输出参数时, return (v0, v1, ...,vn)
写法可以返回多个值。不过元素的个数必须与输出参数的个数相同
使用关键字 new
可以创建一个新合约。待创建合约的完整代码必须事先知道,因此递归的创建依赖是不可能的。
pragma solidity ^0.4.0;
contract D {
uint x;
function D(uint a) public payable {
x = a;
}
}
contract C {
D d = new D(4); // 将作为合约 C 构造函数的一部分执行
function createD(uint arg) public {
D newD = new D(arg);
}
function createAndEndowD(uint arg, uint amount) public payable {
//随合约的创建发送 ether
D newD = (new D).value(amount)(arg);
}
}
如示例中所示,使用 .value()
选项创建 D
的实例时可以转发 Ether
,但是不可能限制 gas
的数量。如果创建失败(可能因为栈溢出,或没有足够的余额或其他问题),会引发异常。
Solidity
使用状态恢复异常来处理错误。这种异常将撤消对当前调用(及其所有子调用)中的状态所做的所有更改,并且还向调用者标记错误。 便利函数 assert
和 require
可用于检查条件并在条件不满足时抛出异常。assert
函数只能用于测试内部错误,并检查非变量。
require
函数用于确认条件有效性,例如输入变量,或合约状态变量是否满足条件,或验证外部合约调用返回的值。 如果使用得当,分析工具可以评估你的合约,并标示出那些会使 assert
失败的条件和函数调用。 正常工作的代码不会导致一个 assert
语句的失败;如果这发生了,那就说明出现了一个需要你修复的 bug。
还有另外两种触发异常的方法:revert
函数可以用来标记错误并恢复当前的调用。 revert
调用中包含有关错误的详细信息是可能的,这个消息会被返回给调用者。已经不推荐的关键字 throw
也可以用来替代 revert()
(但无法返回错误消息)。
在下例中,你可以看到如何轻松使用require
检查输入条件以及如何使用assert
检查内部错误,注意,你可以给 require 提供一个消息字符串,而 assert 不行。
pragma solidity ^0.4.22;
contract Sharer {
function sendHalf(address addr) public payable returns (uint balance) {
require(msg.value % 2 == 0, "Even value required.");
uint balanceBeforeTransfer = this.balance;
addr.transfer(msg.value / 2);
//由于转移函数在失败时抛出异常并且不能在这里回调,因此我们应该没有办法仍然有一半的钱。
assert(this.balance == balanceBeforeTransfer - msg.value / 2);
return this.balance;
}
}
Solidity 合约类似于面向对象语言中的类。合约中有用于数据持久化的状态变量,和可以修改状态变量的函数。 调用另一个合约实例的函数时,会执行一个 EVM 函数调用,这个操作会切换执行时的上下文,这样,前一个合约的状态变量就不能访问了。
可以通过以太坊交易“从外部”或从 Solidity 合约内部创建合约。
创建合约时,会执行一次构造函数(与合约同名的函数)。构造函数是可选的。只允许有一个构造函数,这意味着不支持重载。
在内部,构造函数参数在合约代码之后通过 ABI
编码 传递,但是如果你使用 web3.js
则不必关心这个问题。
如果一个合约想要创建另一个合约,那么创建者必须知晓被创建合约的源代码(和二进制代码)。 这意味着不可能循环创建依赖项。
编译器自动为所有 public
状态变量创建 getter
函数。对于下面给出的合约,编译器会生成一个名为 data
的函数, 该函数不会接收任何参数并返回一个 uint
,即状态变量 data
的值。可以在声明时完成状态变量的初始化
pragma solidity ^0.4.0;
contract C {
uint public data = 42;
}
contract Caller {
C c = new C();
function f() public {
uint local = c.data();
}
}
getter 函数具有外部可见性。如果在内部访问 getter(即没有 this. ),它被认为一个状态变量。 如果它是外部访问的(即用 this. ),它被认为为一个函数。
可以将函数声明为 view 类型,这种情况下要保证不修改状态。
下面的语句被认为是修改状态:
pragma solidity ^0.4.16;
contract C {
function f(uint a, uint b) public view returns (uint) {
return a * (b + 42) + now;
}
}
函数可以声明为 pure ,在这种情况下,承诺不读取或修改状态。
除了上面解释的状态修改语句列表之外,以下被认为是从状态中读取:
pragma solidity ^0.4.16;
contract C {
function f(uint a, uint b) public pure returns (uint) {
return a * (b + 42);
}
}
参考自:
注:本系列来自datawhale组队学习教程,将近结束时跟据同学反馈重新整理而来
author:荒、越前浩波、Yurk、Don