【一步步一起学DApp开发】（三）Solidity语言讲解 | 用Solidity编写智能合约_solidity 语言 .编写原材料接口newmaterial,初始化信息,返回合约地址,并实现通过

有好几种语言可以用于编写以太坊智能合约，不过Solidity是最热门的语言。在本章中，我们将首先学习Solidity编程语言。然后创建一个DApp，用于证明在特定时间的存在、真实性和所有权，即证明一个文件在一个特定时间属于一个特定所有者。

要点：

• Solidity源文件的布局
• 理解Solidity的数据类型
• 合约的特殊变量和函数
• 控制结构
• 合约的结构和功能
• 编译和部署合约

Solidity源文件

Solidity源文件使用的扩展名为.sol。这里面我们使用的是0.4.2版本。

智能合约的结构

合约就像一个类（class），其中包含：

• 状态变量（state variable）
• 函数（function）
• 函数修改器（function modifier）
• 事件（event）
• 结构（structure）
• 枚举（enum）

同时，合约还支持继承与多态。

示例：

contract Sample
{
	//状态变量
	uint256 data;
	address owner;
	
	//定义事件
	event logData(uint256 dataToLog);
	//函数修改器
	modifier onlyOwner() {
		if(msg.sender!=owner) throw;
		
	}
	//构造器,名字与合约名一致
	function Sample(uint256 initData,address initOwner) {
		data = initData;
		owner = initOwner;
	}
	//函数
	function getData() returns (uint256 returnedData) {
	return data;	
	}
	function setData() returns (uint256 newData) onlyOwner {
		logData(newData);
		data = newData;
	}
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

代码注释：

• contract 关键字：用于声明一个合约

• data和owner:是两个状态变量。data包含一些数据，owner包含所有者的以太坊钱包地址，即部署合约者的以太坊地址

• event logData 定义事件logData,用于通知客户端：一旦data发生变化，将触发这个事件。所有事件都保存在区块链中。

• 函数修改器：onlyOwner。修改器用于在执行一个函数之前自动检测文件。这里的修改器用于检测合约所有者是否在调用函数。如果没有，则会抛出异常。

• 合约函数构造器constructor:在部署合约时，构造器用于初始化状态变量。

• function,getData()用于得到data状态变量的值，setData()用于改变data的值。

数据位置（较难理解）

通常，变量会存储在内存中。但是，在Solidity中，会根据不同的情况，变量可能会不存储在内存和文件系统中。

通常，在Solidity中，数据有一个默认位置。通常，存储有一个storage位置和一个memory位置，即本地存储与内存存储。

函数参数，包括其返还参数，默认用memory，本地变量默认用storage,例如状态变量，其数据位置强制使用storage。

注意：

• 不能把memory中存储的复杂类型分配给storage；

###什么是不同的数据类型

首先明白3点；

• Solidity是一种静态类型语言，变量存储的数据类型需要预先定义。
• 所有变量默认值都是0。
• 在Solidity中，变量是有函数作用范围的，也就是说，在函数中任何地方声明的变量将对整个函数存在适用范围。

那么Solidity提供了哪些数据类型——》

基本类型

除了数组类型、字符串类型、结构类型、枚举类型和map类型外，
其他类型均称为基本类型。

• 无符号型：例如uint8，uint16，uint24，…，uint256分别用于存储无符号的8位，16
  位，24位，…，256位整数
• 有符号型：例如，int8，int16，…，int256分别用于存储8位，16位，24位，…，256位整数
• address类型：用于存储以太坊地址，用16进制表示。address类型有两个属性：balance和send。balance用于检测地址余额，send用于向地址发送以太币。send方法拿出需要转账那
  些数量的wei，并根据转账是否成功返回true或者false。

注意：

• uint和int是uint256和int256的别名。

• 如果一个数字超过256位，则使用256位数据类型存储该数字的近似值。

• 数组：Solidity支持generic和byte两种数组类型。

数组有length属性，用于发现数组的长度。

注意：不可以在内存中改变数组大小，也不可以改变非动态数组大小。

字符串类型

有两种方法创建字符串：使用bytes和string。
bytes用于创建原始字符串，而string用于创建UTF-8字符串

示例：

contract sample {
    string myString = "";// string
    bytes myRawString;

    function sample(string initString,bytes rawStringInit) {
        myString = initString;

        string storage myString2 = myString;
        string memory myString3 = "ABCDE";
        myString3 = "imaginecode";
        myRawString = rawStringInit;
        myRawString.length++;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

结构类型struct

示例

contract sample {
	struct myStruct {
		bool myBool;
		string myString;
	}
	myStruct s1;
	myStruct s2 = myStruct{true,""}; 
	
	function sample(bool initBool,string initString){
		s1 = myStruct(initBool,initString);
		
		myStruct memory s3 = myStruct(initBool,initString);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

注意：函数参数不可以是结构类型，且函数不可以返回结构类型。

枚举类型 enum

示例

contract sample {
    enum OS {OSX, Linux,Unix,windows }

    OS choice;

    function sample(OS chosen) {
        choice = chosen;
    }
    function setLinux() {
        choice = OS.Linux;
    }
    function getChoice return (OS chosenOS) {
        return choice;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

mapping 类型

• mapping类型只可以存在于storage中，不存在于memory中，因此它们是作为状态变量声明的。

• mapping类型包含key/value对，不是实际存储key，而是存储key的keccak256哈希，用于查询value。

• mapping不可以被分配给另一个mapping。

constract sample {
	mapping (int => string) myMap;
	function sample(){
		myMap[key] = value;
		mapping (int => string) myMap2 = myMap;
	}
}
1
2
3
4
5
6
7

注意：如果想访问mapping中不存在的key，返回的value为0。

delete 操作符

可用于操作任何类型的变量。

• 对动态数组使用delete操作符，则删除所有元素，其长度变为0。

• 对静态数组使用delete操作符，则重置所有索引

• 对map类型使用delete操作符，什么都不会发生，但是，对map类型的一个键使用delete操作符，则会删除与该键相关的值

示例

contract sample {
    struct Struct {
        mapping (int => int) myMap;
        int myNumber;
    }
    int[] myArray;
    Struct myStruct;

    function sample(int key,int value,int number,int[] array) {
        myStruct = Struct(number);

        myStruct = Struct(number);
        myStruct.myMap[key] = value;//对某个键赋值
        myArray = array;
    }
    function reset() {
        delete myArray;//myArray数组长度为0
        delete myStruct;//myNumber为0，myMap不变
    }
    function deleteKey(int key) {
    		delete myStruct.myMap[key];//删除myMap中的某个键的值
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

基本类型之间的转换

• 隐式转换：常用。通常来说，如果没有语义信息丢失，值和类型之间可以进行隐式转换：uint8可转换为uint16，int128可转换为int256，但是int8不可转换为uint256（因为uint256不能存储，例如-1）
• Solidity也支持显式转换，如果编译器不允许在两种数据类型之间隐式转换，则可以进行显式转换。建议尽量避免显式转换，因为可能返回难以预料的结果。

示例：

uint32 a = 0x12345678;
uint16 b = uint16(a); // b = 0x5678,将uint32类型显式转换为uint16，也就是说，把较大类型转换为较小类型，因此高位被截掉了
1
2

var

使用关键字var声明的变量，其变量类型根据分配给它的第一个值来动态确定。一旦分配了值，类型就固定了，所以如果给它指定另一个类型，将引起类型转换。

int256 x= 12;
var y = x;//此时y的类型是int256

uint256 z = 9;
y = z;//此时，报出异常，因为uint256不能转换为int256类型
1
2
3
4
5

但要注意的是：

• 在定义数组array和map时不能使用var。var也不能用于定义函数参数和状态变量

控制结构

• if-else
• while
• for
• break\continue
• return
• ?:
• 等等

//结构上和其他语法没有什么差异
contract sample {
	int a = 12;
	int[] b;
	
	function sample() {
		if(a == 12) {}
		else if(a==34){}
		else {}
		var temp = 10;
		while(temp<20)
		{
			if(temp==17){break;}
			else {continue;}
		}
		temp++;
	}
	for(var m=0;m<b.length;m++){
	
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

用new 操作符创建合约

一个合约可以使用new关键字来创建一个新合约。

例如：

contract sample1 {
	int a;
	function assign(int b){
		a = b;
	}
}

contract sample2 {
	function sample2(){
		sample1 s = new sample1(); //注意写法
		s.assign(12);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

异常

异常的抛出分为自动和手动。
若你想手动抛出异常，可以使用throw手动抛出。
注意，异常抛出后，会撤销对状态和余额的所有改变。

contract sample {
	function myFunction () {
		throw;
	}
}
1
2
3
4
5

函数调用

• 内部函数调用：一个函数在同一个合约中调用另一个函数
• 外部函数调用：一个函数调用另一个合约的函数。

外部函数调用–this关键字

合约sample1

contract sample1 {
	int a;
	function sample1(int b) payable {
		a = b;
	}
	function assign(int c){
		a = c;
	}
	function makePayment(int d) payable {
		a = d;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

合约sample2

contract sample2 {
	function hello() {}
	function sample2(address addressOfContract){
		sample1 s = (new sample1).value(12)(23);
		s.makePayment(22);
		s.makePayment.value(45)(12);
		s.makePayment.value(4).gas(900)(12);
		this.hello(); //利用this调用外部合约函数
		sample1 s2 = sample1(addressOfContract);
		s2.makePayment(112);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

注意:使用this关键字进行的调用称为外部调用。在函数中，this关键字代表当前合约实例

合约功能——深入理解合约

可见性

可见性定义了谁可以看到它，函数和状态变量有四种可见性：external、public、internal和private

• 函数可见性，默认为 public

• 状态变量可见性，默认为 internal

• external：外部函数只能由其他合约调用，或者通过交易调用——this.f（）

• public：公共函数和状态变量可以用所有可行办法访问

• internal：内部函数和状态变量只可以内部访问，即从当前合约内和继承它的合约访问。不可以使用this访问它

• private：私有函数和状态变量类似于内部函数，但是继承合约不可以访问它们

示例

contract sample1 {
	int public b = 78;
	int internal c = 90;
	
	function sample1() {
		this.a();//外部访问
		b = 21;//内部访问
		
	}
	function a() external {}
}

contract sample2 {
	int internal d = 9;
	int private e = 90;
}
//sample3 继承 sample2
contract sample3 is sample2 {
	sample1 s;
	function sample3() {
		s = new sample1();
		s.a();//外部访问
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

函数修改器（较难理解）

先看一个修改器的例子：

contract sample {
    int a = 90;
    modifier myModifier1(int b) {
        int c = b;
        _;
        c = a;
        a = 1;
    }
    modifier myModifier2 {
        int c = a;
        _;
       
    }
    modifier myModifier3 {
        a = 96;
        return;
        _;
        a = 99;
    }
    modifier myModifier4 {
        int c = a;
        _;
    }
    function myFunction() myModifier1(a) myModifier2 myModifier3 returns (int d) {
        a = 2;
        return a;
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

注：

• 在修改器中，无论下一个修改器体或者函数体二者哪个先到达，都会被插入到“_；”出现的地方。

回退函数

即一个合约中唯一一个未命名函数。

• 不能有实参
• 不能有返回值
• 如果其他函数都不能匹配给定的函数标识符，那么就执行回退函数
• 如果你想让你的合约接收以太币，就必须实现回退函数

contract sample {
	function() payable {
	
	}
}
1
2
3
4
5

继承

即使一个合约继承自其他多个合约，在区块链上也只会创建一个合约。
父合约的代码总是会被复制到最终合约里。

• 关键字 is

示例

contract sample1 {
	function a(){}
	function b() {}
}
//合约2继承自合约1
contract sample2 is sample1{
	function b() {}
}
contract sample3{
	function sample3(int b){
	}
}
//合约4继承自合约1与合约2
contract sample4 is sample1,sample2 {
	function a(){}
	function c() {
		a();
		//执行合约1中的a方法
		sample1.a();
		//执行合约2中的b方法
		b();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

关键字super

• 用于引用最终继承链中的下一个合约
  示例

contract sample1{
}
contract sample2{
}
contract sample3 is sample2{
}
contract sample4 is sample2{
}
contract sample5 is sample4{
	function myFunc(){}
}
contract sample6 is sample1,sample2,sample3,sample4,sample5 {
	function myFunc() {
	//执行sample5中的myFunc方法
		super.myFunc();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

抽象合约

• 仅包含函数原型而不包含函数实现的合约
• 抽象合约不能被编译
• 如果一个合约继承自抽象合约且不重写，那么它自己也是抽象合约

示例

contract sample1{
	function a() returns (int b);
}
contract sample2{
	function myFunc(){
		sample1 s = sample();
		s.a();
	}
}
1
2
3
4
5
6
7
8
9

库

库的目的是在一个特定地址中只部署一次，其其代码可供复用。

示例-使用solidity的math库：

library math
{
	function addInt(int a,int b) return (int c){
		return a+b;
	}
}
contract sample {
	function data() returns (int d){
		return math.addInt(1,2);//调用math库中的addInt方法
	}
}
1
2
3
4
5
6
7
8
9
10
11

使用场景

• 如果有许多合约，这些合约有一些共同的代码，那么可以把它们共同的代码部署成一个库。这么做的好处是这样能节省gas。因为gas的大小依赖于合约的规模。

返回多个值

示例：

contract sample{
	function a() returns (int a,string c){
			return (1,"m");
	}
	function b(){
		int A;
		string memory B;
		
		(A,B) = a();// A =1,B = "m"
		(A,)  = a();// A =1
		(,B) = a(); //B = "m"
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

全局变量

• 特殊变量
• 特殊函数

1、区块和交易属性

• block.blockhash(uint blockNumber) returns (bytes32) //区块哈希值
• block.coinbase(address) //当前区块矿工的地址
• block.difficulty(uint) //当前区块的难度值
• block.gaslimit(uint) //当前区块的gas上限,定义了整个区块中的所有交易最多能消耗多少gas
• block.number(uint) //当前区块的序号
• block.timestamp(uint) //当前区块的时间戳
• msg.gas(uint) //当前剩余的gas
• msg.sender(address) //当前调用发起人的地址
• msg.sig(bytes4) //调用数据的前四个字节
• msg.value(uint) //这个消息所附带的货币量，单位为wei
• now(uint) //当前区块的时间戳，等同于block.timestamp
• tx.gasprice(uint) //交易的gas价格
• tx.origin(address) //交易的发起人

2、地址类型相关

• .balance(uint256) //地址余额，单位为wei
• .send(uint256 amount) returns(bool) //发送指定数量的wei到地址

3、合约相关

• this //当前合约
• selfdestruct(address recipient) //销毁当前合约，把其中的资金发送到指定地址

以太币单位

一个数字可以用wei、finney、szabo、Ether等单位转换为不同面值的以太币。默认使用wei为单位。

存在、真实性和所有权合约的证明

下面我们要实现一个“证明文件所有权”的合约。

分以下几步来进行：

• 1、成对存储文件的哈希和文件所有者的名字，用以实现所有权证明（PoO）
• 2、成对存储文件的哈希和区块的时间戳，用以实现文件在某个特定时间存在的证明（PoE）
• 3、存储哈希自身，用以证明文件的真实性。如果文件被修改，其哈希也会被改变。更改过的文件的哈希会使得合约无法发现文件，从而证明文件被修改过。

代码如下：

contract Proof{
	struct FileDetails {
		uint timestamp;
		string owner;
	}
	mapping (string => FileDetails) files;
	
	event logFileAddedStatus(bool status,uint timestamp,string owner,string fileHash);
	
	//存储文件所有者
	function set(string owner,string fileHash){
		if(files[fileHash].timestamp==0){
			files[fileHash] = FileDetails(block.timestamp,owner);
			//触发一个事件以至于前端应用知道文件的存在
			logFileAddedStatus(true,block.timestamp,owner,fileHash);
		}else {
		//告诉前端文件存在，但是不能存储
			logFileAddedStatus(false,block.timestamp,owner,fileHash);
		}
	}
	//获取文件信息
	function get(string fileHash) returns (uint timestamp,string owner){
		return (files[fileHash].timestamp,files[fileHash].owner);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

编译和部署合约

• sol编译器 之 安装指南
  查看sol编辑器查看链接

• sol编译器 之 使用指南
  查看sol编辑器使用指南链接

这里，我们使用solcjs和Browser Solidity ，其中solcjs允许在node.js中以编程方式编译Solidity，而Browser Solidity是一个适用于小型合约的IDE。

至此，我们将Solidity语言进行了基本的讲解，下一节中我们将介绍如何使用web3.js开发DApp前端。