我家小花儿

这个屌丝很懒，什么也没留下！

热门标签

【区块链】以太坊Solidity编程：智能合约实现之函数与合约_solidity tuple

作者：我家小花儿 | 2024-04-06 02:01:29

踩

solidity tuple

以太坊Solidity编程：智能合约实现之函数与合约

函数及基本控制结构

函数类型

函数也是一个类型，且属于值类型
可以将一个函数赋值给一个变量赋值给一个变量，一个函数类型的变量
还可以将一个函数作为参数进行传递
也可以在函数调用中返回一个函数
函数类型有两类，可分为internal和external

内部函数（internal）：不能在当前合约的上下文环境以外的地方执行，内部函数只能在当前合约内被使用。如在当前的代码块内，包括库函数，和继承的函数中。
外部函数（External）：外部函数由地址和函数方法签名两部分组成。可作为外部函数调用的参数，或者由外部函数调用返回。

函数类型的定义

function (param types) {internal|external} [pure|constant|view|payable][returns (return types)] varName;
1

如果不写类型，默认的函数类型是internal的
如果函数没有返回结果，则必须省略returns关键字

函数的定义

function f(<parameter types>) {internal|external} [pure|constant|view|payable][returns (<return types>)]{ // function body}
1

示例：

contract SimpleFunc {
	function hello(uint i) {
		// todo
	}
}
1
2
3
4
5

入值和返回值

同JavaScript一样，函数有输入参数，但与之不同的是，函数可能有任意数量的返回参数
入参（Input Parameter）与变量的定义方式一致，稍微不同的是，不会用到的参数可以省略变量名称
出参（Output Parameters）在returns关键字后定义，语法类似变量的定义方式
示例：
Solidity内置支持元素（tuple），这种内置结构可以同时返回多个结果
示例

函数控制结构

支持if、else、while、do、for、break、continue、return、？：
条件判断中的括号不可省略，但在单行语句中的大括号可以省略
无Boolean类型的自动转换，比如if(1){…}在Solidity中是无效的
没有switch

函数调用

内部调用：同一个合约中，函数互相调用。调用在EVM中被翻译成简单的跳转指令
外部调用：一个合约调用另外一个合约的函数，或者通过web3调用合约函数。调用通过消息调用完成（bytes24类型，20字节合约地址+4字节的函数方法签名）。
示例：

命名参数调用和匿名函数参数

函数调用的参数，可以通过指定名字的方式调用，但可以以任意的顺序，使用方式为{}包含。参数的类型和数量要与定义一致。
示例：

省略函数参数名称

没有使用的参数名可以省略
示例：

变量作用范围

一个变量在声明后都有初始值为字节表示的全0
Solidity使用了JavaScript的变量作用范围的规则
函数内定义的变量，在整个函数中均可用，无论它在哪里定义
示例：

函数可见性

函数的可见性

函数类型：internal和external
访问方式：内部访问和外部访问
处于访问控制的需要，函数具有“可见性（Visibility）类型”。
状态变量也具有可见性类型

可见性类型

external：“外部函数”，可以从其他合约或者通过交易来发起调用。合约内不能直接调用。
public:“公开函数”，可以从合约内调用，或者消息来进行调用
Internal:“内部函数”，只能在当前合约或继承的合约里调用
private:“私有函数”，仅在当前合约中可以访问，在继承的合约内，不可访问。
可见性图

默认访问权限

函数默认是public
状态变量默认的可见性是internal

合约声明示例

状态变量访问

编译器为自动为所有的public的状态变量创建访问函数。
生成的函数名为参数名称，输入参数根据变量类型来顶。如uint无须参数，uint[]则需要输入参数数组下标作为参数
示例：

函数修饰符

修改器（Modifiers）可以用来改变一个函数的行为
一般用于在函数执行前检查某种前置条件。
修改器是一种合约属性，可被继承，同时还可派生的合约重写。
函数可以有多个修改器，它们之间以空格隔开，修饰器会依次检查执行。
示例：

函数属性

根据对状态变量的修改情况，函数可以拥有pure|constant|view|public四个属性。
属性定义放置在函数可见性之后
不强制使用
主要是为了节省gas

属性介绍：

只有当函数有返回值的情况下，才需要使用pure、view、constant
prue：可以读取状态变量但是不能改。
view：不能改也不能读状态变量，否则编译通不过
constant：view的旧版本，v4.17之后不建议
带关键字pure或view，就不能修改状态变量的值。默认只是向区块链读取数据，读取数据不需要花费gas。
状态变量的属性：
状态变量可以声明为constant，同一般语言的常量，目前只支持值类型和String。
public的状态变量，其getter函数属性为view。

事件

事件是使用EVM日志内置功能的方便工具
事件在合约中可被继承
当被调用时，会触发参数存储到交易的日志中
可以最多有3个参数被设置为indexed，来设置是否被索引。
设置为索引后，可以允许通过这个参数来查找日志，甚至可以按特定的值过滤。

错误和异常处理

Solidity的异常处理：

Solidity使用“状态恢复”来处理错误
有某些情况下，异常是自动抛出的
抛出异常的效果是当前的执行被终止且被撤销（值的改变和账户余额的变化都会被回退）
Solidity暂时没有捕捉异常的方法（try…catch）

assert/require:

函数assert和require来进行条件检查，如果条件不满足则抛出异常
assert函数通常用来测试内部错误
require函数来检查输入变量或合约状态变量是否满足条件，以及验证调用外部合约返回值

revert/throw：
revert函数可用于标记错误
throw同revert类似，已不建议使用

三个异常示例（等价的）：

常见异常：

数组访问越界，或是负的序号值访问数组
调用require/assert，但参数值为false
.transfer()执行失败
如果你的public的函数在没有payable关键字时，却尝试在接收ether
如果你通过消息调用一个函数，但在调用的过程中，并没有正确结果（如gas不足等）

合约与继承

合约

Solidity中合约类似面向对象语言中的类。
合约可以继承。
一个合约可以调用另外一个合约。
一个合约中可以创建另外一个合约。
合约操作另外一个合约，一般都需要直到其代码。

合约间调用

contract OwnedToken{
	// TokenCreator是一个合约类型
	// 未初始化前，为一个引用
	TokenCreator creator；
	address owner; // 状态变量
	bytes32 name; // 状态变量

	// 构造函数
	function OwnedToken(bytes32 _name) public{
		owner = msg.sender;
		creator = TokenCreator(msg.sender);// 另外一个合约
		name = _name;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

合约中创建合约

一个合约可以通过new关键字来创建一个合约。
要创建合约的完整代码，必须提前知道

contact TokenCreator{
	function createToken(bytes32 name) public returns (OwnedToken){
		// 创建一个新的合约，name为构造函数所需变量
		OwnedToken tokenAddress = new OwnedToken(name);
		return tokenAddress;
	}
}
1
2
3
4
5
6
7

继承

Solidity通过复制包括多态的代码来支持多重继承。基本的继承体系与python类似
当一个合约从多个其他合约那里继承，在区块链上仅会创建一个合约，在父合约里的代码会复制来形成继承合约。
派生的合约需要提供所有父合约需要的所有参数。

contract Owned {
	function owned() { owner = msg.sender; }
	address owner;
}

// 使用`is`来继承另外一个合约
// 子合约可以使用所有的非私有变量，包括内部函数和状态变量
contract Mortal is Owned {
	function kill() {
		if (msg.sender == owner) selfdestruct(owner);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

几种特殊的合约

抽象合约（Abstract Contracts)

合约包含抽象函数，也就是没有函数体的函数
这样的合约不能通过编译，即使合约内也包含一些正常的函数
抽象合约一般可以做为基合约被继承

contact Feline{
	// 函数没有函数实现，为抽象函数，对应的合约为抽象合约
	function utterance() returns (bytes32);
	 
	function getContractName() returns (string) {
		return "Feline";
	}
}

contract Cat is Feline{
	// 继承抽象合约，实现函数功能
	function utterance() returns (bytes32) {return "miaow";}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

接口（Interfaces）

接口与抽象合约类似，与之不同的是，接口内没有任何函数是已实现的，同时还有如下限制：
不能继承其他合约，或接口
不能定义构造器
不能定义变量
不能定义结构体
不能定义枚举类
接口基本上限制为合约ABI定义可以表示的内容

// 接口
interface Token {
	function transfer(address recipient, uint amount);
}

// 接口可以被
contract MyToken is Token {
	function transfer(address recipient, uint amount){
		// 函数发现
	}
}
1
2
3
4
5
6
7
8
9
10
11

库（Libraries）

库与合约类似，但它的目的是在一个指定的地址，且仅部署一次，然后通过EVM的特性来复用代码。
使用库合约的合约，可以将库合约视为隐式的父合约（base contracts），不会显示的出现在继承关系中。
调用库函数的方式非常类似，如库L有函数f()，使用L.f()即可访问

library Set{
	struct Data { mapping(uint => bool) flags; }
	
	// 第一个参数的类型为“storage reference”， 仅存储地址，而不是这个库的特别特征
	// 按照一般语言的惯例，`self`代表第一个参数
	function insert(Data storage self, uint value)
		public
		return (bool)
	{
		if (self.flags[value])
			return false; //already there
		self.flags[value] = true;
		return true;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

contract C{
	Set.Data knownValues;
	
	function register(uint value) public{
		// 库可以直接调用，而无需使用this
		requires（Set.insert(knownValues, value)）;
	}	
}
1
2
3
4
5
6
7
8

实战：奖品竞拍

项目需求

大家之前都拿到了不少课程积分，为活跃课程氛围，特开展奖品竞拍活动：
1. 大家用课程积分竞拍，采用连续竞价、明拍、限时模式。
奖品为电商兑换码，可以兑换不同学习物品
一次拍卖完成后，积分概不退还，可开始下一次拍卖。

基本数据结构

积分体系：完全使用之前的Mycoin即可，使用继承
拍卖列表：用户和出价，使用一个mapping即可
出价最高用户/出价：全局状态变量
限时/兑换码/竞拍状态：全局状态变量

功能需求：竞价

连续竞价，和之前的出价叠加
必须高于当前最高出价才算出价成功。
出价的积分打入合约地址

功能需求：竞价完成

结束时间已到
之前没有领取过
最高出价用户领取
全局状态变量管理员可以强制终止拍卖

功能需求：重开竞价

只有管理员可以重开
重新设置兑换码
重新设置兑换时间
重置竞拍状态

代码

MyCoin.sol

pragma solidity >=0.6.4;


contract MyCoin{
    //数据结构
    //1.用户
    address[] userList;
    mapping(address=>uint8) userDict;

    //2.用户的币
    mapping(address=>uint) balances;

    //3.用户交易，第一个address为交易发起方，第二个为接收方，uint[]为交易量记录
    mapping(address => mapping(address=>uint[])) public trans;

    //用户初次可领取的数量
    uint iniCount = 100;

    function Mycoin() public{
        //合约本身拥有的币
        balances[address(this)] = 100000;
    }

    //领取货币，只能一次
    function getCoin() public returns (bool sufficientAndFirstGet) {
        //判断合约是否钱足够
        if(balances[address(this)]<iniCount) return false;

        //判断是否从合约领取过币
        if(0!=trans[address(this)][msg.sender].length) return false;

        //领取币
        balances[address(this)] -= iniCount;
        balances[msg.sender] += iniCount;

        //记录交易
        trans[address(this)][msg.sender].push(iniCount);

        //加入用户列表
        if(0 == userDict[msg.sender]){
            userList.push(msg.sender);
            userDict[msg.sender] = 1;
        }
        return true;
    }

    //发送货币
    function sendCoin(address receiver, uint amount) public returns(bool sufficient){
        //判断是否还有足够的币
        if(balances[address(this)]<amount) return false;

        //发生交易
        balances[msg.sender] -= amount;
        balances[receiver] += amount;

        //记录交易
        trans[msg.sender][receiver].push(amount);

        //加入用户列表
        if (0 == userDict[receiver]) {
            userList.push(receiver);
            userDict[receiver] = 1;
        }

        return true;
    }

    //获得某个用户的货币量
    function getBalances(address addr) public returns(uint){
        return balances[addr];
    }

    //获得领取的进度
    function getPercent() public returns(uint){
        uint sum = 0;
        for(uint i = 0;i < userList.length; i++){
            address userAddress = userList[i]; //用户的地址
            sum = sum + balances[userAddress];
        }
        return (100*sum)/100000;
    }

    //获得币最多的用户地址
    function getBest() public returns (address){
        address maxAdd;
        uint maxCoin = 0;

        //获得币最多的用户地址
        for(uint i = 0; i < userList.length; i++){
            address userAddress = userList[i]; //用户地址
            uint userCoin = balances[userAddress]; //用户积分
            if(userCoin > maxCoin){
                maxAdd = userAddress;
                maxCoin = userCoin;
            }
        }
        return maxAdd;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

MyBid.sol

pragma solidity >=0.6.4;
import "./MyCoin.sol";


contract MyBid is MyCoin{
    //数据结构
    string private ticket;//电商兑换码
    address owner;//合约创建者

    //时间是unix的绝对时间戳
    uint public auctionEnd;

    // 拍卖的当前状态
    address public highestBidder; //最高出价用户的地址
    uint public highestBid; //最高出价

    //出价列表
    mapping (address => uint) bids;

    // 拍卖结束后设为 true，将禁止所有的变更
    bool ended;

    //事件
    event HighestBidIncreased(address bidder, uint amount);
    event AuctionEnded(address winner, uint amount);

    //dev 创建一个简单的拍卖
    //_biddingTime,拍卖时间；_ticket，兑换码
    constructor (uint _biddingTime, string memory _ticket) public{
        ticket = _ticket;
        auctionEnd = block.timestamp + _biddingTime;
        owner = msg.sender;
    }

    // 竞价，value为加价，和之前的出价叠加
    function bid(uint value) public {
        // 如果拍卖已结束，撤销函数的调用。
		require(block.timestamp < auctionEnd);
        // 如果出价不够高，不继续执行
		uint actualValue = bids[msg.sender] + value;
		require(actualValue > highestBid);

        //把积分发送到合约地址，已经检查额度
		sendCoin(address(this),value);
		
        //更新出价和最高出价
		bids[msg.sender] = actualValue;
		highestBidder = msg.sender;
		highestBid = actualValue;
		
		emit HighestBidIncreased(msg.sender, actualValue);
    }

    // 结束拍卖，并把最高的出价发送给受益人
    function auctionEnded() public payable returns (string memory){
        // 1. 条件
        require(now >= auctionEnd,"Not End!"); // 拍卖尚未结束
        require(!ended); // 该函数已被调用

        //必须是最高出价用户调用，或者管理员强制终止
		require(msg.sender == highestBidder || msg.sender == owner);
        // 2. 生效
		ended = true;
		emit AuctionEnded(highestBidder, highestBid);
        // 3. 返回ticket，只能查看一次
        return ticket;
    }

    // `_;` 表示修饰符，可代表被修饰函数位置
    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }

    //开始新的拍卖
    function newBid(uint _biddingTime, string memory _ticket) public onlyOwner {
        // 1. 条件
		require(now >= auctionEnd);
		require(ended);

        //重置数据
		ticket = _ticket;
		auctionEnd = now + _biddingTime;
		ended = false;
		delete highestBidder; //重置最高出价用户的地址
		delete highestBid; //重置最高出价
		//delete bids[msg.sender];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

注意：可能由于版本问题存在一些错误，如有参考，请及时更正！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/369143