Solidity的语言类型：

静态类型的语言：编译前变量类型需要先确定
变量可以分为：

值类型：赋值或者传参时总是进行值拷贝

引用类型：传递的是地址

这里先给出一个总览图：

整型：

和其他语言类型，可以用int关键字声明：

有符号整数：int8,int16,int32,……int255,

无符号整数：uint8,uint16,uint32,……uint255,

跟在关键字后的数字表示多少字节，表示数大小的范围，跟默认int,表示255。

注意

：

整型的溢出问题分为：向上溢出和向下溢出，例如：

uint8表示的最大数==》255，如果此时加1，会出现向上溢出的错误，此时的结果为：0；uint8表示的最小值==》0，此时如果减1，会出现向下溢出的错误，结果为：255。

如何解决上述的溢出问题呢？

可以使用assert（断言）关键字，进行预判断处理。

定点浮点型：

关键字：

fixed

和

ufixed

,对应于其他语言的float和double.

3. 使用时需要声明位数，指明大小

4. 格式：

fixedMN,其中M为:数值，代表所占的空间位数，N为：小数点位数，M以8步进，可为8到256位，N可为0到80之间。

定长字节数组：

关键字：bytes

占空间固定的数组：

bytes1,bytes2,…bytes32，其中的数字的单位为字节。

1.通过属性.length获取字节数组的长度

2.可以像字符串一样使用：bytes2=”couse”

3.可以想整型一样运算比较和位运算

4.像数组一样使用索引：bytes8[k],返回第k+1个字节，0<=k<8

常量：

整型常量：1，23，1.55

字符串常量：不支持“+”运算

十六进制常量：hex”aabb”

枚举：

1.关键字enum用来自定义类型：如下

enum ColorChioce{Red,Bule,Yellow}

2.可与整数进行转换，但不能进行隐式转换

3.枚举类型应至少有一名成员

地址类型：

关键字：address,表示一个账户地址（20字节）

属性：.balance，获取余额，单位是wei，1eth(以太币)=10^18wei

成员函数：

1.transfer()，转账函数

2.send()，也是转账函数，错误时不发生异常返回false,使用时一定要检查返回值，大部分时候使用transfer()。

addr.transfer(y) 等价于 require(addr.send(y))

注意：

send()和transfer()使用时有2300gas限制，当合约接收以太币时，转账容易失败。

3.call()，可以调用另外一个合约地址的函数，如下：

addr.call(函数签名，参数)：调用对应函数

addr.call.value(y)()功能上类似addr.transfer(y),但没有gas的限制。

addr.call.gas():指定gas,指定调用函数消耗的gas。

补充：如何区分合约地址及外部地址？

答：evm提供了一个操作码EXTCODESIZE,用来获取地址相关联的代码大小（长度），如果是外部帐号地址，没有代码返回0，因此我们可以使用以下方法判断合约地址及外部帐号地址：

uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}

函数类型

solidity中，函数是一种类型。像其他类型⼀一样，函数类型可以作为变量量类型，也可以作为返回值类型（函数式语⾔言的特点）

函数分为两种类型：

1.外部(external)函数：发起EVM消息调用，使用:( 地址.函数名) 进行调用

2.内部(internal)函数：代码跳转调用， gas小的多，但法在合约外部调用，使用: （函数名）进行调用，默认是内部(internal)函数。

声明格式：

1.声明一个函数：function foo(int) 或者 function foo(int) external returns(int)

2.声明一个韩式类型变量：function(int) foo 或者 function(int) external returns(int) foo

数据储存位置:

1.storage（区块链中）:永久储存在区块链链中。

例：①状态变量

contract A {
uint a;
}

②复杂类型的局部变量

contract A {
function fun() {
uint[] arr;
}
}

2.memory(EVM内存中)：随着交易的结束，内存释放。

例：局部变量

contract A {
function fun(uint[] a) {
uint b;
}}

两者的赋值表现：

在memory和storage之间总是会创建一个完全独⽴立的拷贝。

状态变量量之间相互赋值，总是会创建一个完全独⽴立的拷贝。

同样的数据位置之间赋值只是引⽤用的传递。

示例代码：

contract TestLoc(){
    uint[] x;//x的储存位置是storage

    function f(uint[] memoryArray) public returns (uint[]){

    x=memoryArray;//从memory 复制到storage

    uint[] y=x;//storage引用传递给复杂局部变量y(y是一个storage引用)
    y[1]=2;     //此时x,y都会被修改

    g(x);//引用传递，g可以改变x的内容
    h(x);//拷贝到memory,h无法改变x的内容
}
    function g(uint[] storage storageArray) internal{}
    function h(uint[] memoryArray) public {}
}

数组：

数组声明的两种格式：

1.普通格式

：T[k]

T: 元素类型， k: 数组长度（可选）

uint [10] tens; uint [ ] us;

uint [] public u = [1, 2, 3]; //public数组状态变量量会自动生成一个对应变量量的函数，数组长度省略

2.使用new 关键字：

uint[] c = new uint

;、需要指定长度，不能省略

属性：

1.length，获取长度

uint [10] tens; //tens.length 为10

storage的变长数组，可以通过给.length赋值调整数组长度

memory数组一旦创建，大小不不可调整

2..push() 添加元素，返回新长度

仅针对变长数组，memory数组不支持

字节数组：

字节数组bytes：

类似 byte[ ] ，不过bytes作为外部函数的参数时占用的空间更更小，推荐使用,相比前面的定长字节数组，这个是不定长的。

声明形式：

bytes mybs;

bytes mybs=“hello world”

字符串：

solidity中，字符串也是数组

声明：

string mystr;

string mystr=”Solidity入门详解”;

注意：

字符串没有.length属性，但是可以通过bytes(s).length 获取字节数组的长度，但也只是字节数组的长度，没法获得字符串长度。

另外还可通过bytes(s)[k] : 获取字节数组下标k的UTF-8 编码。

bytes和string都可以储存字符串，那他们的区别是声明呢？

两者储存数据的方式不一样

bytes: 用来存储任意长度的字节数据

string: 用来存储UTF-8编码的字符串数据

前面说到我们没法获取字符串的长度，那怎么才能获取呢？

引入第三方库：stringutils，github地址：

https://github.com/Arachnid/solidity-stringutils

该第三库支持很多强大的功能：

获取字符串长度

匹配字符串串：find(), startsWith(),endsWith()

字符串串拼接

….

映射

关键字

：mapping

声明一个映射类型：

mapping(键=> 值) public mymapping

键类型不能是变长数组、合约类型、嵌套类型值类型无限制

如下：

mapping(address => uint) public balances;

访问形式：

索引访问，mymapping[键]

限制：

1.只能作为状态变量，不能放在函数里声明

2.无法遍历访问，没有长度，没有键集合，没有值集合

解决限制

因为solidity提供的这个mapping的功能实在有限，因此我们可以借助第三方库来实现一些有用的功能，第三方库github地址为:

https://github.com/ethereum/dapp-bin/blob/master/library/iterable_mapping.sol

结构体

关键字：

struct，类似C语言的结构体

定义一个结构体：

struct First{
bool myBool;
uint myInt;
}

其中结构体的类型可以为：基本类型、数组、结构体、映射

声明与初始化：

仅声明变量，不初始化：

First  f1;

按成员顺序初始化:

First  f1 = First(true,1);

命名方式初始化:

First  f1 = First({myBool:true,myInt:1});

访问与赋值:

First  f1 ;
f1.myBool=true;

使用限制：

结构体目前仅支持在合约内部使用，或继承合约内使用，如果要在参数和返回值中使用结构体，函数必须声明internal。

类型转换：

将一个类型转为另一个类型，转换可分为隐式转换和显式转换。

1.隐式转换：

运算符两边有不同的类型，不会丢失数据下，编译器会尝试隐式转换类型，如下：

uint8 -> uint16,uint256

uint16,uint256 -> uint8（出错）

2.显式转换：

如果编译器不允许隐式的自动转换，但你知道转换没有问题时，可以进行强转。

注意：

不正确的转换会带来错误，如果转换为一个更小的类型，高位将被截断。

重置变量

对一个变量进行重置

关键字

：delete

**使用：**delete 变量名;

使用重置变量后，变量会变为默认值，下面列出各个类型的默认值：

bool -> false;
uint -> 0
address -> 0x0
bytes -> 0x0
string ->""
注意：
delete 对映射无效

例如：

aa=true;
delete aa;//aa变为false

uint[] memory arr = new uint[](7);
delete arr; // a.length = 0;

CustomType memory ct = CustomType(true, 100);
delete ct; // ct.myBool = false ; myInt = 0;

特别注意：

delete 不影响值拷贝的变量，但是如果是传递引用的变量，就会受到影响。

内置API

使用时间日期：

1.now函数：获取当前时间

2.引入第三方库执行更多功能，推荐github·上一个第三方库：

https://github.com/pipermerriam/ethereum-datetime

区块和交易相关API：

blockhash(uint blockNumber) returns (bytes32)：返回给定区块号的哈希值，只支持最近256个区块，且不包含当前区块。
block.coinbase (address): 当前块矿工的地址。
block.difficulty (uint):当前块的难度。
block.gaslimit (uint):当前块的gaslimit。
block.number (uint):当前区块的块号。
block.timestamp (uint): 当前块的Unix时间戳（从1970/1/1 00:00:00 UTC开始所经过的秒数）
gasleft() (uint256): 获取剩余gas。
msg.data (bytes): 完整的调用数据（calldata）。
msg.gas (uint): 当前还剩的gas（弃用）。
msg.sender (address): 当前调用发起人的地址。
msg.sig (bytes4):调用数据(calldata)的前四个字节（例如为：函数标识符）。
msg.value (uint): 这个消息所附带的以太币，单位为wei。
now (uint): 当前块的时间戳(block.timestamp的别名)
tx.gasprice (uint) : 交易的gas价格。
tx.origin (address): 交易的发送者（全调用链）

什么是ABI?

ABI是Application Binary Interface的缩写，即应用程序二进制接口。

当我们向合约地址发送一个交易，交易的内容就ABI编码数据。

作用：用来计算一个函数以及参数的ABI编码数据。

ABI的编码函数有如下这些，用来直接得到ABI编码信息：

* abi.encode(...) returns (bytes)：计算参数的ABI编码。
* abi.encodePacked(...) returns (bytes)：计算参数的紧密打包编码
* abi. encodeWithSelector(bytes4 selector, ...) returns (bytes)： 计算函数选择器和参数的ABI编码
* abi.encodeWithSignature(string signature, ...) returns (bytes): 等价于* abi.encodeWithSelector(bytes4(keccak256(signature), ...)

错误处理：

solidity的错误处理如下：

当发生错误处理的时候，会出现事件的回滚。

do something1

do error

do something2

当执行到do error，错误发生，此时 do something2，do something1都不会执行。

错误处理函数：

1.assert(bool condition)：用于判断内部错误，天剑不满足时抛出异常，此时会消耗掉所剩余的gas。

2.require(bool condition)：用于判断输或者外部组件错误，条件不满足时判处异常，此时gas会返回还给调用者，区别于assert。

require(bool condition,string message)：同时上，多了一个错误信息。

3.revert():终止执行还原改变的状态。

revert(string,reason):同上，提供一个错误提醒信息。

用require还是assert?

使用require的情况：

1.用于检查用户输入；

2.用于检查合约调用返回值，如require(addr.send(1));

3.用于检查状态，如：msg.sender==owner;

4.通常用于函数的开头；

5.不知道使用哪一个的时候

使用assert的情况：

1.用于检查溢出错误，如‘z=x+y;assert(z>=x)’;

2.用于检查不应该发生的异常情况；

3.用于在状态改变之后，检查合约状态；

4.尽量少用assert;

5.通常用于函数中间或者结尾；

函数修改器：

关键字：modifier

函数修改器可以改变一个函数的行为，通常用于在函数执行检查某种前置条件。

modifier onlyOwener{
        require(msg.sender==owner);
        _;
}

function my() public onlyOwener{
        //do something;
}

函数修改器修饰函数时，函数题被插入到“_”处。所以在执行my()函数前，会执行onlyOwener这个函数，如果检查通过，再执行my()函数。

一些补充：

1.函数修改器可被继承

2.函数修改器可接受参数

3.多个函数修改器一起使用（空格隔开，修改器会一次检查执行）

函数修饰符：

1.payable：边表示一个函数能附加以太币调用：

function f(uint a) public payable returns (uint):{

}

2.view：表示一个函数不能修改状态。

view函数和constant等价，constant在0.5版本之后会弃用。使用了这个修饰符的函数不会消耗gas。

3.pure:表示一个函数不读取状态，也不修改状态。本地执行不消耗gas。

solidity的继承：

1.继承的合约可以访问所有非private成员。

external：外部访问、

public：内外都可以、

internal：内部级继承、

private：内部，继承的也不行

2..is表示继承，通过复制代码的方式实现继承

contract  A{
}
contract  B is A{
}

3.如果父合约与构造函数，那么派生合约需要调用父合约的构造函数，如果有参数，派生合约需要提供参数调用父合约构造函数。

形式一：

contract  B is A(uint a){
}
//其中a为传递给父合约A的参数

形式二：

contract B is A{
    constructor(uint a) A(a) public{
    }
    }

3.多重继承：

is后接多个合约，基类合约在is后的顺序很重要。继承顺序原则是从最接近基类到最接近派生类。

4.抽象合约：

合约在没有函数体（实现）的函数

合约不能通过编译，只能继承

5.接口：

关键字：interface

里面的函数必须是未实现的。函数不能继承其他合约或者接口。不能定义构造器，变量，结构体，枚举类。

抽象合约和接口的作用主要是用做基类。

库

1.库其实就是一个特殊的合约：

可以像其他合约一样进行部署，但是没有状态变量，不能存以太币。

2.可重用：

部署一次，在不同的合约内反复使用。节约gas,相同功能的代码不用重复部署

3.定义库、使用库：

定义：

library  my{
    myfunction();
}

使用：

先导入：import “./my”,，然后my.myfunction();

4.网上好用的常用库：

openzeppelin，github地址是：

https://github.com/Openzeppelin/openzeppelin-solidity

另外还有：ethereum-libraries，dapp-bin，Stringutils等

回调函数

定义：无名称。无参数，无返回值的函数

一个合约可以有一个回退函数。当给合约转以太币时，需要有payable回退函数。如果调用合约时，没有匹配上任何函数，就会调用回退函数。

未完。。。

原文链接：https://blog.csdn.net/qq_34493908/article/details/82120032