参考教程:【实战篇】1、函数重载_哔哩哔哩_bilibili
1、函数重载:
pragma solidity ^0.5.17;
contract overLoadTest
{
//不带参数
function test() public
{
}
//带一个参数
function test(address account) public
{
}
//参数类型不同,虽然uint160可以和address直接转化,但仍然满足重载的条件
function test(uint160 account) public
{
}
//参数个数不同
function test(uint160 account,address otherAccount) public
{
}
// 此函数会编译报错,因为重载不考虑函数的返回值类型是否相同
// function test(address account) returns(address sender){
// return msg.sender;
// }
uint public result = 0;
function negativeExample1(uint id) public
{
result = 100;
}
function negativeExample1(uint8 id) public
{
result = 200;
}
function test1() public
{
//negativeExample1(1); 该语句会报错,因为传入函数的参数1既符合uint又符合uint8, solidity无法辨别调用哪一个函数
}
function negativeExample2(address account) public
{
result = 100;
}
function negativeExample2(uint160 account) public
{
result = 200;
}
function test2() public
{
//negativeExample2(1); 该语句会报错,address本质上就是一个uint160的一串数字,solidity无法辨别调用哪一个函数
}
}
当一些行为模式一致,但是这个行为所输入的参数不一样时,便构成了重载,具体表现如下:
①函数的名字相同
②函数的参数不同(类型、数量)
③与函数的返回值无关
2、函数命名参数:
pragma solidity ^0.5.17;
contract functionParamTest
{
uint public id;
string public name;
function setParam(uint _id,string memory _name) public
{
id = _id;
name = _name;
}
function test() public
{
setParam(18,"xiaofang"); //正常地传参
}
function test2() public
{
setParam({_id:18,_name:"xiaofang"}); //通过形参名给函数传参
}
function test3() public
{
setParam({_name:"xiaofang",_id:18}); //顺序可以与定义函数参数时不同(在较多参数情况下命名参数对于代码的可读性有很好的提升)
}
function test4() public
{
setParam(18); //调用函数传参时不可缺少参数,否则编译会报错(在外部调用函数时可以缺少参数,但不建议缺少)
}
}
3、函数返回值的特性:
pragma solidity ^0.5.17;
contract functionReturnTest
{
//最常规的返回值写法
function test() public view returns(uint)
{
return 10;
}
//返回值也可以进行一个命名,在returns后可以声明返回值的名称
function test1() public view returns(uint result)
{
result = 1;
return result; //如果不写这条语句也是可以的,因为有声明过返回值的名称(但不建议搞花里胡哨)
}
//可以返回任意匹配类型的值(类型必须匹配,名称不匹配没关系)
function test2() public view returns(uint result)
{
uint a = 10;
result = 100;
return a;
}
//可以返回多个参数,在声明了返回值名称的情况下可以不用写return语句,但必须要给返回值赋值
function test3(uint a,uint b) public view returns(uint add,uint multiply)
{
add = a+b;
multiply = a*b;
}
//返回多个参数时return语句要加括号
function test4(uint a,uint b) public view returns(uint add,uint multiply)
{
return (a+b,a*b);
}
//可以利用多返回值的特性直接进行数据交换操作
function test5(uint a,uint b) public view returns(uint _b, uint _a)
{
return (b,a);
}
}
4、变量的生命周期与作用域:
(1)作用域:在程序中有非常多的花括号,变量定义在哪对花括号中,那么这对花括号所包含的就是变量的作用域,变量可以在其作用域内有效使用。(注意,函数形参的作用域是函数内部,虽然它看起来不是定义在函数体内部)
(2)生命周期:从变量被分配空间到空间被收回的这一个时间段,称为变量的生命周期,变量的生命周期自其被定义开始,至其作用域尾部结束(没有进行手动销毁的话)。
5、值传递与副本拷贝:
pragma solidity ^0.5.17;
contract transferValueTest
{
uint public a = 200;
uint public b = a; //将a的值赋给b,但是a和b各自占有不同的空间
function changIt() public
{
b = 400; //改变b的值,并不影响a
}
//i作为形式参数,当调用该函数时,是将所传值的副本传入的,并不会改变所传引用的值,也就是说,对i做修改并不影响a的值
function changeIt3(uint i) public returns(uint)
{
i++;
return i++;
}
function test() public
{
changeIt3(a);
}
}
6、const静态修饰:
pragma solidity ^0.5.17;
contract constantTest
{
// 在0.4版本中,constant等同于view,在0.5以上的版本中已经废弃
/*
function test() public constant returns(uint)
{
return 100;
}
*/
}
7、构造函数:
pragma solidity ^0.5.17;
contract constructorTest
{
//初始化结果为0
uint public a;
//构造函数的名称与合约名相同,在合约部署(或者被创建)的时候执行(0.5以下版本支持该种语法)
/*
function constructorTest()
{
a = 100;
}
*/
//一个合约内部不能有多个构造函数
/*
function constructorTest(uint _a,uint _b){
a = _a;
}
*/
//在0.5以上版本中,solidity采用了关键字constructor来定义构造函数
constructor() public
{
a = 100;
}
/*
address public ower;
function constructorTest() 在合约部署时,可以借助构造函数传递一些内容到合约内,例如部署合约的账户
{
ower = msg.sender;
}
*/
}
8、函数修改器modifire:
(1)基本用法:
pragma solidity ^0.5.17;
contract modifireTest
{
address public ower;
uint public num = 0;
constructor() public
{
ower = msg.sender;
}
//定义一个函数修改器
modifier onlyOwer
{
require(msg.sender == ower); //不符合条件时则抛出异常,停止执行下面的语句并回滚
//修饰函数时,函数相当于被插入到'_;'位置,然后把onlyOwer当作函数执行
_;
}
function changeIt(uint _num) public onlyOwer
{
num = _num; //该例中只有部署该合约的账户才有权利调用这个函数,其它账户调用该函数将会报错
//当然,“require(msg.sender == ower);”也可以直接写在该函数中,这样就不需要借助modifier
}
}
Solidity的异常处理:
①Solidity使用“状态恢复异常”来处理异常。这样的异常将撤消对当前调用(及其所有子调用)中的状态所做的所有更改,并且向调用者返回错误。
②函数assert和require可用于判断条件,并在不满足条件时抛出异常
• assert() 一般只应用于测试内部错误,并检查常量
• require() 应用于确保满足有效条件,或验证调用外部合约的返回值
• revert() 用于抛出异常,它可以标记一个错误并将当前调用回退
(2)运用示例1:
pragma solidity ^0.5.17;
contract mappingTest
{
//一个钱包地址对应一个个人身份id
mapping(address => uint) idMapping;
//一个人的身份id地址对应一个人的姓名
mapping(uint => string) nameMapping;
uint id = 0;
address public ower;
//定义一个函数修改器
modifier onlyOwer
{
require(idMapping[msg.sender] == 0); //判断调用函数的账户有没有绑定身份的记录,以免同一账户注册多个身份
//修饰函数时,函数相当于被插入到'_;'位置,然后把onlyOwer当作函数执行
_;
}
function register(string memory name) public onlyOwer //该函数模拟新账户绑定身份
{
address account = msg.sender; //调用该函数的账户为需要绑定身份和生成id号的新账户
id++; //这里的id号应该是随机生成,总之每个调用该函数的账户都应该获得不同的id号
//给账户分配一个id
idMapping[account] = id;
//再将个人id与个人姓名进行映射绑定
nameMapping[id] = name;
}
//根据账户地址获取id
function getIdByAddress(address account) public view returns(uint)
{
return idMapping[account];
}
//根据id获取个人姓名
function getNameById(uint id) public view returns(string memory)
{
return nameMapping[id];
}
(3)运用示例2:
pragma solidity ^0.5.17;
contract modifireTest
{
uint level = 200;
uint money = 0;
modifier modifyLevel(uint _inputLevel) //函数修改器可以有参数,这样使用起来更加灵活
{
require(level >= _inputLevel, "Your level is not within the range!");
//如不满足require中的条件,错误类型为Your level is not within the range
_;
}
function addMoney() modifyLevel(50) public
{
//require(level >= 50); 五十级以上才能调用该函数
money = 100;
}
function recoverCash() modifyLevel(200) public
{
//require(level >= 200); 两百级以上才能调用该函数
money = 200;
}
function getMoney() public view returns(uint)
{
return money;
}
}
(4)多重modifire的执行顺序:
pragma solidity ^0.5.17;
contract modifireTest4
{
uint public a = 0;
modifier mod1
{
a = 1; //执行顺序——1(最先执行)
_;
a = 2; //执行顺序——5(最后执行)
}
modifier mod2
{
a = 3; //执行顺序——2
_;
a = 4; //执行顺序——4
}
function test() public mod1 mod2 //调用该函数后,a的值为2
{
a = 100; //执行顺序——3
}
}
9、合约的继承:
(1)基本的继承:
pragma solidity ^0.5.17;
contract Father
{
uint money = 10000;
function noSmoking() public view returns(string memory)
{
return "I'm not somking";
}
}
contract Son is Father //继承语法:contract 子类名称 is 父类名称1,父类名称2……
{
function getMoney() public view returns(uint)
{
return money; //子类继承了父类中的属性
}
function test() public view returns(string memory)
{
return noSmoking(); //子类继承了父类中的函数
}
}
(2)连续继承:
pragma solidity ^0.5.17;
contract GrandFather
{
uint height = 170;
}
contract Father is GrandFather
{
uint money = 10000;
function getHeight() public view returns(uint)
{
return height; //子类继承了父类中的属性
}
}
contract Son is Father
{
function getHeight() public view returns(uint)
{
return height; //子类继承了父类的父类中的属性
}
}
(3)继承权限:
①合约属性的继承:
pragma solidity ^0.5.17;
contract Father
{
uint private privateMoney = 2000; //加上private标识的属性或函数不会被子类继承
//其余情况下可以被继承
//uint privateMoney = 2000;
//uint public privateMoney = 2000;
//uint internal privateMoney = 2000;
//注意:external不能修饰属性,只修饰函数
uint money = 10000;
function noSmoking() public view returns(string memory)
{
return "I'm not somking";
}
}
contract Son is Father
{
function getMoney() public view returns(uint)
{
return money; //正常“财产”可以被继承
}
function getPrivateMoney() public view returns(uint)
{
//return privateMoney; 父类的私房钱子类无法继承
}
}
②public修饰父类函数:
pragma solidity ^0.5.17;
contract Father
{
function noSmoking() public view returns(string memory)
{
return "I'm not somking";
}
}
contract Son is Father
{
function test() public view returns(string memory)
{
return noSmoking(); //子合约可以正常调用父类中public修饰的函数
}
}
③private修饰父类函数:
pragma solidity ^0.5.17;
contract Father
{
function noSmoking() private view returns(string memory)
{
return "I'm not somking";
}
}
contract Son is Father
{
function test() public view returns(string memory)
{
//return noSmoking(); 子合约不可以调用父类中private修饰的函数
}
}
④internal修饰父类函数:
pragma solidity ^0.5.17;
contract Father
{
function noSmoking() internal pure returns(string memory)
{
return "I'm not somking";
}
function test() public returns(string memory)
{
return noSmoking(); //被internal修饰的函数,只能在合约内部以及子合约中被调用,外部无法直接调用
}
}
contract Son is Father
{
function test2() public pure returns(string memory)
{
return noSmoking(); //子合约可以正常调用父类中internal修饰的函数(当然,也只能在合约内部调用,外部不可见)
}
}
⑤external修饰父类函数:
pragma solidity ^0.5.17;
contract Father
{
function noSmoking() external pure returns(string memory)
{
return "I'm not somking";
}
function test() public returns(string memory)
{
//return noSmoking(); 被external修饰的函数,只能在外部被调用,合约内部以及子合约中无法直接调用
return this.noSmoking(); //通过this可以让编译器认为这是在外部通过该合约地址调用该函数,这样就不会报错
}
}
contract Son is Father
{
function test2() public view returns(string memory) //使用this的话,千万不要使用pure
{
//return noSmoking();
return this.noSmoking(); //子类也可以通过this调用父类中external修饰的函数
}
}
contract Mother
{
function test() public returns(string memory)
{
Father f = new Father(); //对于被external修饰的函数,在其它非子合约中可以直接创建合约对象,通过合约对象进行外部调用
return f.noSmoking();
}
}
10、全局变量自动getter函数:
(1)普通变量的get方法:
pragma solidity ^0.5.17;
contract GetterTest
{
uint public num = 100; //public修饰符修饰的属性,默认会生成一个get方法,供我们外部调用
/*
function num() external returns(uint)
{
return num;
}
1、变量用public修饰后,这个函数就是生成的get方法(函数体内部定义的变量不能用public修饰)
2、默认生成的get函数是external权限的,不能够在合约的内部调用
3、对于该例,num()方法只能有一个,要是自己进行重写,就会覆盖默认生成的get方法
*/
function test() public
{
// num();
this.num(); //可以通过this对get方法进行外部调用
}
}
(2)mapping类型数据的get方法:
pragma solidity ^0.4.18; //编译器版本与前面例子所用的不同
contract GetterTest
{
mapping(uint => string) public map;
function map(uint key) external returns(string) //map的get方法(需传入key值才能获取value值,对于嵌套的mapping,就需要传入多个key值)
{
return map[key];
}
}
补充——mapping映射:
pragma solidity ^0.5.17;
contract mappingTest
{
//个人认为这个有点像Python中的字典(可以理解为mapping(key => value) 字典名)
//一个钱包地址对应一个个人身份id
mapping(address => uint) idMapping;
//一个人的身份id地址对应一个人的姓名
mapping(uint => string) nameMapping;
uint id = 0;
function register(string memory name) public //该函数模拟新账户绑定身份
{
address account = msg.sender; //调用该函数的账户为需要绑定身份和生成id号的新账户
id++; //这里的id号应该是随机生成,总之每个调用该函数的账户都应该获得不同的id号
//给账户分配一个id
idMapping[account] = id;
//再将个人id与个人姓名进行映射绑定
nameMapping[id] = name;
}
//根据账户地址获取id
function getIdByAddress(address account) public view retu服务器托管网rns(uint)
{
return idMapping[account];
}
//根据id获取个人姓名
function getNameById(uint id) public view returns(string memory)
{
return nameMapping[id];
}
mapping(uint => mapping(uint => mapping(uint => string))) public map;
function test() public
{
map[0][1][1] = "lalalalala"; //mapping数据类型还可以嵌套,相当于Python中的多维字典
//map[0]:mapping(uint => mapping(uint => string))
//map[0][1]:mapping(uint => string)
//map[0][1][1]:string
}
}
mapping(key => value) Mapping的相关语句:
(1)“mapping(type1 => type2) Mapping;”的作用是创建一个type1类型到type2类型的映射,映射组的名称为“Mapping”。
(2)“Mapping[key] = value;”的作用是:
①如果Mapping组中此前没有key这个键值,那么Mapping组中会添加key这个键值到value的映射。
②如果Mapping组中此前存在key这个键值,那么key键值的映射修改为value。
11、继承中的重写:
(1)属性重写:
pragma solidity ^0.5.17;
contract Father
{
uint money = 10000;
uint public height = 170; //父类属性用public修饰,那么子类继承后会生成get方法,调用该方法会获取父类的height而不是子类的
}
contract Son is Father
{
uint money = 20000; //子类重写了父类的money,以子类为准(但是不影响父类的money)
uint height = 180; //子类重写了父类的height,那么子类使用height时将以此为准(如果用public修饰该属性,那么此处生成的get方法会将父类生成的get方法覆盖,调用该方法会获取子类的height)
function getMoney() public view returns(uint)
{
return money;
}
function getHeight() public view returns(uint)
{
return height;
}
}
(2)函数重写:
pragma solidity ^0.5.17;
contract Father
{
uint public money = 10000;
function noSmoking() public view returns(string memory)
{
return "I don't smoke,an服务器托管网d I do not drink";
}
}
contract Son is Father
{
uint public money = 20000;
function noSmoking() public view returns(string memory) //子类重写了父类的函数,父类函数将会被覆盖
{
return "I do not smoke,but I do drink";
}
function test() public view returns(string memory)
{
return noSmoking();
}
}
12、多继承需要注意的情况:
pragma solidity ^0.5.17;
contract Father
{
uint public money = 10000;
uint public height = 180;
}
contract Mother
{
uint public money = 20000;
uint public height = 170;
uint public weight = 120;
}
contract Son is Father,Mother
{
function test() public view returns(uint)
{
return height; //会返回Mother中的height,后继承的属性如果与前面继承的相同,前继承的属性将会被覆盖
}
}
13、合约的销毁(析构函数):
pragma solidity ^0.5.17;
contract DestructTest
{
address ower;
constructor() public
{
ower = msg.sender;
}
uint public money = 100;
function increment() public
{
money += 100;
}
function kill() public
{
if(msg.sender == ower) //只有发布合约的账户有权利销毁合约
{
//手动进行自我销毁
selfdestruct(msg.sender);
}
}
}
服务器托管,北京服务器托管,服务器租用 http://www.fwqtg.net
相关推荐: AWS EC2 必知必会小技巧 | 机型特点解析和选型技巧分享
背景 AWS EC2 是 AWS 的弹性计算服务,为广大开发者提供简单便捷弹性的虚拟机,是 AWS 历史最悠久的服务之一(另外一个是 S3),从 2006 年发布至今,已经发展了近 17 年历史。 相信不少刚开始接触 EC2 的朋友都有如下类似的感受: AWS…