Solidity极简入门: 4. 函数输出 return

这一讲，我们将介绍Solidity函数输出，包括：返回多种变量，命名式返回，以及利用解构式赋值读取全部和部分返回值。

返回值 return和returns

Solidity有两个关键字与函数输出相关：return和returns，他们的区别在于：

returns加在函数名后面，用于声明返回的变量类型及变量名；
return用于函数主体中，返回指定的变量。

// 返回多个变量
function returnMultiple() public pure returns(uint256, bool, uint256[3] memory){
        return(1, true, [uint256(1),2,5]);
    }

上面这段代码中，我们声明了returnMultiple()函数将有多个输出：returns(uint256, bool, uint256[3] memory)，接着我们在函数主体中用return(1, true, [uint256(1),2,5])确定了返回值。

命名式返回

我们可以在returns中标明返回变量的名称，这样solidity会自动给这些变量初始化，并且自动返回这些函数的值，不需要加return。

// 命名式返回
function returnNamed() public pure returns(uint256 _number, bool _bool, uint256[3] memory _array){
    _number = 2;
    _bool = false; 
    _array = [uint256(3),2,1];
}

在上面的代码中，我们用returns(uint256 _number, bool _bool, uint256[3] memory _array)声明了返回变量类型以及变量名。这样，我们在主体中只需要给变量_number，_bool和_array赋值就可以自动返回了。

当然，你也可以在命名式返回中用return来返回变量：

// 命名式返回，依然支持return
function returnNamed2() public pure returns(uint256 _number, bool _bool, uint256[3] memory _array){
    return(1, true, [uint256(1),2,5]);
    }

解构式赋值

solidity使用解构式赋值的规则，支持读取函数的全部或部分返回值。

读取所有返回值：声明变量，并且将要赋值的变量用,隔开，按顺序排列。

uint256 _number;
bool _bool;
uint256[3] memory _array;
(_number, _bool, _array) = returnNamed();

读取部分返回值：声明要读取的返回值对应的变量，不读取的留空。下面这段代码中，我们只读取_bool，而不读取返回的_number和_array：

1	(, _bool2, ) = returnNamed();

使用场景和好处

代码简洁：使用结构式赋值可以使代码更加简洁易读，特别是在处理多个返回值或复杂数据结构时。
减少错误：减少了额外的赋值语句，降低了因错误处理不当导致的bug。
提高开发效率：直接在一行代码中完成多个变量的赋值，提高了开发效率。
便于维护：代码更加简洁明了，便于后期维护和理解。

结构式赋值是现代编程语言中的一个非常有用的特性，它能够让数据操作更加直观和高效。

在remix上验证

部署合约后查看三种返回方式的结果

总结

这一讲，我们介绍函数的返回值return和returns，包括：返回多种变量，命名式返回，以及利用解构式赋值读取全部和部分返回值。

Solidity极简入门: 5. 变量数据存储和作用域 storage/memory/calldata

Solidity中的引用类型

**引用类型(Reference Type)**：包括数组（array），结构体（struct）和映射（mapping），这类变量占空间大，赋值时候直接传递地址（类似指针）。==由于这类变量比较复杂，占用存储空间大，我们在使用时必须要声明数据存储的位置。==

数据位置

solidity数据存储位置有三类：storage，memory和calldata。不同存储位置的gas成本不同。storage类型的数据存在链上，类似计算机的硬盘，消耗gas多；memory和calldata类型的临时存在内存里，消耗gas少。大致用法：

storage：合约里的==状态变量默认都是storage==，存储在链上。
memory：函数里的参数和临时变量一般用memory，存储在内存中，不上链。
calldata：和memory类似，存储在内存中，不上链。==与memory的不同点在于calldata变量不能修改（immutable）==，一般用于函数的==参数==。例子：

function fCalldata(uint[] calldata _x) public pure returns(uint[] calldata){
    //参数为calldata数组，不能被修改
    // _x[0] = 0 //这样修改会报错
    return(_x);
}

Example:

数据位置和赋值规则

==在不同存储类型相互赋值时候，有时会产生独立的副本（修改新变量不会影响原变量），有时会产生引用（修改新变量会影响原变量）。==规则如下：

storage（合约的状态变量）赋值给==本地（指的基本都是函数里面）==storage（函数里的）时候，会创建引用，改变新变量会影响原变量。例子：

uint[] x = [1,2,3]; // 状态变量：数组 x

function fStorage() public{
    //声明一个storage的变量 xStorage，指向x。修改xStorage也会影响x
    uint[] storage xStorage = x;
    xStorage[0] = 100;
}

Example:

storage赋值给memory，会创建独立的副本，修改其中一个不会影响另一个；反之亦然。例子：

uint[] x = [1,2,3]; // 状态变量：数组 x

function fMemory() public view{
    //声明一个Memory的变量xMemory，复制x。修改xMemory不会影响x
    uint[] memory xMemory = x;
    xMemory[0] = 100;
    xMemory[1] = 200;
    uint[] memory xMemory2 = x;
    xMemory2[0] = 300;
}

Example:

memory赋值给memory，会创建引用，改变新变量会影响原变量。
其他情况，变量赋值给storage，会创建独立的副本，修改其中一个不会影响另一个。

变量的作用域

Solidity中变量按作用域划分有三种，分别是状态变量（state variable），局部变量（local variable）和全局变量(global variable)

1. 状态变量

状态变量是数据存储在链上的变量，所有合约内函数都可以访问，gas消耗高。状态变量在合约内、函数外声明：

contract Variables {
    uint public x = 1;
    uint public y;
    string public z;

我们可以在函数里更改状态变量的值：

function foo() external{
    // 可以在函数里更改状态变量的值
    x = 5;
    y = 2;
    z = "0xAA";
}

2. 局部变量

局部变量是仅在函数执行过程中有效的变量，函数退出后，变量无效。局部变量的数据存储在内存里，不上链，gas低。局部变量在函数内声明：

function bar() external pure returns(uint){
    uint xx = 1;
    uint yy = 3;
    uint zz = xx + yy;
    return(zz);
}

3. 全局变量

全局变量是全局范围工作的变量，都是solidity预留关键字。他们可以在函数内不声明直接使用：

function global() external view returns(address, uint, bytes memory){
    address sender = msg.sender;
    uint blockNum = block.number;
    bytes memory data = msg.data;
    return(sender, blockNum, data);
}

在上面例子里，我们使用了3个常用的全局变量：msg.sender, block.number和msg.data，他们分别代表请求发起地址，当前区块高度，和请求数据。下面是一些常用的全局变量，更完整的列表请看这个链接：

blockhash(uint blockNumber): (bytes32)给定区块的哈希值 – 只适用于256最近区块, 不包含当前区块。
block.coinbase: (address payable) 当前区块矿工的地址
block.gaslimit: (uint) 当前区块的gaslimit
block.number: (uint) 当前区块的number
block.timestamp: (uint) 当前区块的时间戳，为unix纪元以来的秒
gasleft(): (uint256) 剩余 gas
msg.data: (bytes calldata) 完整call data
msg.sender: (address payable) 消息发送者 (当前 caller)
msg.sig: (bytes4) calldata的前四个字节 (function identifier)
msg.value: (uint) 当前交易发送的wei值

Example:

4. 全局变量-以太单位与时间单位

以太单位

Solidity中不存在小数点，以0代替为小数点，来确保交易的精确度，并且防止精度的损失，利用以太单位可以避免误算的问题，方便程序员在合约中处理货币交易。

wei: 1
gwei: 1e9 = 1000000000
ether: 1e18 = 1000000000000000000

function weiUnit() external pure returns(uint) {
    assert(1 wei == 1e0);
    assert(1 wei == 1);
    return 1 wei;
}

function gweiUnit() external pure returns(uint) {
    assert(1 gwei == 1e9);
    assert(1 gwei == 1000000000);
    return 1 gwei;
}

function etherUnit() external pure returns(uint) {
    assert(1 ether == 1e18);
    assert(1 ether == 1000000000000000000);
    return 1 ether;
}

Example:

时间单位

可以在合约中规定一个操作必须在一周内完成，或者某个事件在一个月后发生。这样就能让合约的执行可以更加精确，不会因为技术上的误差而影响合约的结果。因此，时间单位在Solidity中是一个重要的概念，有助于提高合约的可读性和可维护性。

seconds: 1
minutes: 60 seconds = 60
hours: 60 minutes = 3600
days: 24 hours = 86400
weeks: 7 days = 604800

function secondsUnit() external pure returns(uint) {
    assert(1 seconds == 1);
    return 1 seconds;
}

function minutesUnit() external pure returns(uint) {
    assert(1 minutes == 60);
    assert(1 minutes == 60 seconds);
    return 1 minutes;
}

function hoursUnit() external pure returns(uint) {
    assert(1 hours == 3600);
    assert(1 hours == 60 minutes);
    return 1 hours;
}

function daysUnit() external pure returns(uint) {
    assert(1 days == 86400);
    assert(1 days == 24 hours);
    return 1 days;
}

function weeksUnit() external pure returns(uint) {
    assert(1 weeks == 604800);
    assert(1 weeks == 7 days);
    return 1 weeks;
}

Example:

总结

在这一讲，我们介绍了solidity中的引用类型，数据位置和变量的作用域。重点是storage, memory和calldata三个关键字的用法。他们出现的原因是为了节省链上有限的存储空间和降低gas。下一讲我们会介绍引用类型中的数组。==只用记住：合约中状态变量storage赋值给本地storage是引用，合约中memory赋值给本地变量memory也是引用，其他都是创建副本，改变一个其中另一个不会改变==

Solidity极简入门: 6. 引用类型, array, struct

这一讲，我们将介绍solidity中的两个重要变量类型：数组（array）和结构体（struct）。

数组 array

数组（Array）是solidity常用的一种变量类型，用来存储一组数据（整数，字节，地址等等）。数组分为固定长度数组和可变长度数组两种：

固定长度数组：在声明时指定数组的长度。用T[k]的格式声明，其中T是元素的类型，k是长度，例如：

// 固定长度 Array    uint[8] array1;    bytes1[5] array2;    address[100] array3;固定长度 Array
uint[8] 数组1;
字节1[5] 数组2;
地址[100] 数组3;

可变长度数组（动态数组）：在声明时不指定数组的长度。用T[]的格式声明，其中T是元素的类型，例如：

// 可变长度 Array
uint[] array4;
bytes1[] array5;
address[] array6;
bytes array7;

注意：bytes比较特殊，是数组，但是不用加[]。另外，不能用byte[]声明单字节数组，可以使用bytes或bytes1[]。在gas上，bytes比bytes1[]便宜。因为bytes1[]在memory中要增加31个字节进行填充，会产生额外的gas。但是在storage中，由于内存紧密打包，不存在字节填充。

创建数组的规则

在solidity里，创建数组有一些规则：

对于memory修饰的动态数组，可以用new操作符来创建，但是必须声明长度，并且声明后长度不能改变。例子：

1
2
3

// memory动态数组
uint[] memory array8 = new uint[](5);
bytes memory array9 = new bytes(9);

数组字面常数(Array Literals)是写作表达式形式的数组，用方括号包着来初始化array的一种方式，并且里面每一个元素的type是以第一个元素为准的，例如[1,2,3]里面所有的元素都是uint8类型，因为在solidity中如果一个值没有指定type的话，默认就是最小单位的该type，这里int的默认最小单位类型就是uint8。而[uint(1),2,3]里面的元素都是uint类型，因为第一个元素指定了是uint类型了，我们都以第一个元素为准。下面的合约中，对于f函数里面的调用，如果我们没有显式对第一个元素进行uint强转的话，是会报错的，因为如上所述我们其实是传入了uint8类型的array，可是g函数需要的却是uint类型的array，就会报错了。

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.9.0;

contract C {
    function f() public pure {
        g([uint(1), 2, 3]);
    }
    function g(uint[3] memory) public pure {
        // ...
    }
}

如果创建的是动态数组，你需要一个一个元素的赋值。

uint[] memory x = new uint[](3);
x[0] = 1;
x[1] = 3;
x[2] = 4;

数组成员

length: 数组有一个包含元素数量的length成员，memory数组的长度在创建后是固定的。
push(): 动态数组和bytes拥有push()成员，可以在数组最后添加一个0元素。
push(x): 动态数组和bytes拥有push(x)成员，可以在数组最后添加一个x元素。
pop(): 动态数组和bytes拥有pop()成员，可以移除数组最后一个元素。

Example:

结构体 struct

Solidity支持通过构造结构体的形式定义新的类型。创建结构体的方法：

// 结构体
struct Student{
    uint256 id;
    uint256 score; 
}

1	Student student; // 初始一个student结构体

给结构体赋值的两种方法：

//  给结构体赋值
// 方法1:在函数中创建一个storage的struct引用
function initStudent1() external{
    Student storage _student = student; // assign a copy of student
    _student.id = 11;
    _student.score = 100;
}

Example:

 // 方法2:直接引用状态变量的struct
function initStudent2() external{
    student.id = 1;
    student.score = 80;
}

Example:

总结

这一讲，我们介绍了solidity中数组（array）和结构体（struct）的基本用法。下一讲我们将介绍solidity中的哈希表——映射（mapping）。

大帅哥

solidity基础4-6

Solidity极简入门: 4. 函数输出 return

返回值 return和returns

命名式返回

解构式赋值

在remix上验证

总结

Solidity极简入门: 5. 变量数据存储和作用域 storage/memory/calldata

Solidity中的引用类型

数据位置

数据位置和赋值规则

变量的作用域

1. 状态变量

2. 局部变量

3. 全局变量

4. 全局变量-以太单位与时间单位

以太单位

时间单位

总结

Solidity极简入门: 6. 引用类型, array, struct

数组 array

创建数组的规则

数组成员

结构体 struct

总结