Solidity 介绍

一.Solidity 语言

Solidity 语言是一种面向合约的高级编程语言，用于在以太坊区块链网络上实现智能合约。Solidity 语言深受c++、Python 和 JavaScript 的影响，针对以太坊(Ethereum)虚拟机(EVM)设计。

Solidity 语言是静态类型语言支持继承、库和复杂的用户定义类型。

1、静态类型语言：变量定义时有类型声明的语言。

（1）变量的类型在编译的时候确定

（2）变量的类型在运行时不能修改，这样编译器就可以确定运行时需要的内存总量。

例如：C、Scala、Java、F#语言是静态类型语言。

2、动态类型语言：变量定义时无类型声明的语言。

（1）变量的类型在运行的时候确定

（2）变量的类型在运行可以修改

例如：python、Javascript、Ruby语言是动态类型语言。

3、强类型定义语言

强制数据类型定义的语言。也就是说，一旦一个变量被指定了某个数据类型，如果不经过强制转换，那么它就永远是这个数据类型了。举个例子：如果你定义了一个整型变量a,那么程序根本不可能将a当作字符串类型处理。强类型定义语言是类型安全的语言。

4、弱类型定义语言

数据类型可以被忽略的语言。它与强类型定义语言相反, 一个变量可以赋不同数据类型的值。强类型定义语言在速度上可能略逊色于弱类型定义语言，但是强类型定义语言带来的严谨性能够有效的避免许多错误。

可以使用 Solidity 语言创建区块链上运行的投票、众筹、钱包等各种类型的智能合约。

以太坊/Ethereum是什么” />去中心化的，运行智能合约的区块链平台。

以太坊/Ethereum虚拟机(EVM)

Ethereum 虚拟机，也称为EVM，是以太坊/Ethereum中智能合约的运行时环境。

可以用某种语言，例如 Solidity 语言，开发智能合约程序，编译成以太坊(Ethereum)虚拟机支持的字节码/bytecode，然后该程序就可以在虚拟机中执行了。

什么是智能合约?

智能合约（Smart contract ）是一种旨在以信息化方式传播、验证或执行合同的计算机协议。智能合约允许在没有第三方的情况下进行可信交易，这些交易可追踪且不可逆转。智能合约概念于1995年由Nick Szabo首次提出。

智能合约的目的是提供优于传统合约的安全方法，并减少与合约相关的其他交易成本。

简单地说，智能合约可以理解为一个自执行的协议。智能合约可以自动处理协议的履行、管理、以及支付。

例如，可以编写这样一个智能合约：本月底之前，老王转账给小张1个以太币，这个智能合约部署后，就会在月底之前，自动把老王的1个以太币转账给小张，无需人为干预。

如果你现在不理解智能合约也没关系，我们稍后会更详细地讲解。

二.Solidity安装本地编译器

安装本地编译器

安装 nodejs / npm

node官方网站下载node，推荐LTS版本，按提示完成安装，npm会同时装上。

验证Node版本：

> node -vv10.16.3> npm -v6.11.3

安装 Solidity 编译器 solc

一旦安装了Node.js包管理器，就可以按照下面的步骤安装 Solidity 编译器

$ npm install -g solc@0.4.25

上面的命令将安装solcjs程序，并使其在整个系统中都可用。

验证solc安装：

$ solcjs --version

如果一切顺利，这将打印如下内容

0.4.25+commit.c082d0b4.Emscripten.clang

现在，可以使用本地的 solcjs 了，它比标准的 solidity 编译器少很多特性，但对于学习来说足够了。

三.基本语法

一个 Solidity 源文件可以包含任意数量的合约定义、import指令和pragma指令。

让我们从一个简单的 Solidity 源程序开始。下面是一个 Solidity 源文件的例子：

Pragma

第一行是pragma指令，它告诉我们源代码是为Solidity version 0.4.25版本编写的。

pragma指令只对自己的源文件起作用，如果把文件B导入到文件A，文件B的pragma将不会自动应用于文件A。

pragma solidity ^0.4.0;

上面的pragma指令意思是，源文件不能用低于0.4.0版本的编译器编译，也不能用0.5.0版本及以上版本的编译器编译。

这里第二个条件是用^加上的，表示不超过0.5.0版本，背后的意思是，0.4.0 ~ 0.4.9 之间的小版本改动通常不会有破坏性更改，源代码应该都是兼容的。

Contract/智能合约

智能合约是位于以太坊区块链上特定地址的代码(函数)和数据(状态)的集合。

这行代码：uint number;，声明了一个名为number的状态变量，类型为uint，set和get函数可用于修改或检索变量的值。

导入文件

上面的例子没有import语句，但是Solidity 支持与JavaScript非常相似的导入语句。

下面的语句从“filename”导入所有全局符号。

import "filename";

下面的示例，创建一个新的全局符号symbolName，它的成员都是来自“filename”的全局符号。

import * as symbolName from "filename";

要从当前目录导入文件x，请使用import "./x"。如果不指定当前路径，可能会在全局“include目

；录”中引用另一个文件。

保留关键字

下面是 Solidity 语言中的保留关键字：

四、第一个程序

为简单起见，我们使用在线Solidity开发工具Remix IDE编译和运行Solidity程序。

第1步– 在File explorers选项卡下，新建一个test1.sol文件，代码如下：

示例

pragma solidity ^0.5.0;contract SolidityTest { constructor() public{ }function getResult() public view returns(uint){uint a = 1;uint b = 2;uint result = a + b;return result; }}

第2步– 在Compiler选项卡下，单击Compile按钮，开始编译
第3步– 在Run选项卡下，单击Deploy按钮进行部署
第4步– 在Run选项卡下，选择SolidityTest at 0x…下拉
第5步– 单击getResult按钮显示结果。

输出

0: uint256: 3

五、代码注释

Solidity 支持c风格和c++风格的注释。

• //之后到行尾的文本，都被看作注释，编译器忽略此内容，”ctrl+/“
• /*与*/之间的文本被看作注释， 编译器忽略此内容， ”shift+ctrl+a“

示例

function getResult() public view returns(uint){ // 这是一行注释，类似于c++中的注释 /** 这是多行注释* 类似于c语言中的注释*/ uint a = 1; uint b = 2; uint result = a + b; return result;}

六、数据类型

在用任何语言编写程序时，都需要使用变量来存储各种信息。变量是内存空间的名称，变量有不同类型，例如整型、字符串类型等等。操作系统根据变量的数据类型分配内存。

Solidity中，变量类型有以下几大类：

• 值类型
• 地址类型
• 引用类型

1.值类型

2.地址类型

地址类型表示以太坊地址，长度为20字节。地址可以使用.balance方法获得余额，也可以使用.transfer方法将余额转到另一个地址。

address x = 0x212;address myAddress = this;if (x.balance = 10) x.transfer(10);

3.引用类型/复合数据类型

Solidity中，有一些数据类型由值类型组合而成，相比于简单的值类型，这些类型通常通过名称引用，被称为引用类型。

引用类型包括：

• 数组 (字符串与bytes是特殊的数组，所以也是引用类型)
• struct (结构体)
• map (映射)

七、变量

Solidity 支持三种类型的变量：

• 状态变量– 变量值永久保存在合约存储空间中的变量。
• 局部变量– 变量值仅在函数执行过程中有效的变量，函数退出后，变量无效。
• 全局变量– 保存在全局命名空间，用于获取区块链相关信息的特殊变量。

Solidity 是一种静态类型语言，这意味着需要在声明期间指定变量类型。每个变量声明时，都有一个基于其类型的默认值。没有undefined或null的概念。

1.状态变量

变量值永久保存在合约存储空间中的变量。

pragma solidity ^0.5.0;contract SolidityTest { uint storedData;// 状态变量 constructor() public {storedData = 10; // 使用状态变量 }}

2.局部变量

变量值仅在函数执行过程中有效的变量，函数退出后，变量无效。函数参数是局部变量。

pragma solidity ^0.5.0;contract SolidityTest { uint storedData; // 状态变量 constructor() public {storedData = 10;} function getResult() public view returns(uint){uint a = 1; // 局部变量uint b = 2;uint result = a + b;return result; // 访问局部变量 }}

示例

pragma solidity ^0.5.0;contract SolidityTest { uint storedData; // 状态变量 constructor() public {storedData = 10;} function getResult() public view returns(uint){uint a = 1; // 局部变量uint b = 2;uint result = a + b;return storedData; // 访问状态变量 }}

可以使用 Solidity 第一个程序中的步骤，运行上述程序。

输出

0: uint256: 10

3.全局变量

这些是全局工作区中存在的特殊变量，提供有关区块链和交易属性的信息。

Solidity 变量名

在为变量命名时，请记住以下规则

• 不应使用 Solidity 保留关键字作为变量名。例如，break或boolean变量名无效。
• 不应以数字(0-9)开头，必须以字母或下划线开头。例如，123test是一个无效的变量名，但是_123test是一个有效的变量名。
• 变量名区分大小写。例如，Name和name是两个不同的变量。

八、变量作用域

局部变量的作用域仅限于定义它们的函数，但是状态变量可以有三种作用域类型。

• Public– 公共状态变量可以在内部访问，也可以通过消息访问。对于公共状态变量，将生成一个自动getter函数。
• Internal– 内部状态变量只能从当前合约或其派生合约内访问。
• Private– 私有状态变量只能从当前合约内部访问，派生合约内不能访问。

示例

pragma solidity ^0.5.0;contract C { uint public data = 30; uint internal iData= 10; function x() public returns (uint) {data = 3; // 内部访问return data; }}contract Caller { C c = new C(); function f() public view returns (uint) {return c.data(); // 外部访问 }}contract D is C { uint storedData; // 状态变量 function y() public returns (uint) {iData = 3; // 派生合约内部访问return iData; } function getResult() public view returns(uint){uint a = 1; // 局部变量uint b = 2;uint result = a + b;return storedData; // 访问状态变量 }}

九、运算符

1.算术运算符

Solidity 支持的算术运算符，如下表所示：

假设变量A的值为10，变量B的值为20。

示例

下面的代码展示了如何使用算术运算符。

pragma solidity ^0.5.0;contract SolidityTest { constructor() public{ } function getResult() public view returns(uint){uint a = 1; uint b = 2;uint result = a + b; // 算术运算return result;}}

输出

0: uint256: 3

2.比较运算符

Solidity 支持的比较运算符，如下表所示：

下面的代码展示了如何使用比较运算符。

pragma solidity ^0.5.0;contract SolidityTest { uint storedData;constructor() public{storedData = 10;} function getResult() public view returns(string memory){uint a = 1; // 局部变量uint b = 2;uint result = a + b;return integerToString(result);} function integerToString(uint _i) internal pure returns (string memory _uintAsString) {if (_i == 0) { // 比较运算符 return "0";}uint j = _i;uint len;while (j != 0) {// 比较运算符 len++; j /= 10;}bytes memory bstr = new bytes(len);uint k = len - 1;while (_i != 0) { bstr[k--] = byte(uint8(48 + _i % 10)); _i /= 10;}return string(bstr);// 访问局部变量 }}

输出

0: string: 3

3.逻辑运算符

Solidity 支持的逻辑运算符，如下表所示：

假设变量A的值为10，变量B的值为20。

示例

下面的代码展示了如何使用逻辑运算符

pragma solidity ^0.5.0;contract SolidityTest { uint storedData; // 状态变量 constructor() public{storedData = 10;} function getResult() public view returns(string memory){uint a = 1; // 局部变量uint b = 2;uint result = a + b;return integerToString(storedData); // 访问状态变量 } function integerToString(uint _i) internal pure returns (string memory) {if (_i == 0) { return "0";}uint j = _i;uint len;while (!(j == 0)) {// 逻辑运算符 len++; j /= 10;}bytes memory bstr = new bytes(len);uint k = len - 1;while (_i != 0) { bstr[k--] = byte(uint8(48 + _i % 10)); _i /= 10;}return string(bstr); }}

输出

0: string: 3

4.位运算符

Solidity 支持的位运算符，如下表所示：

假设变量A的值为2，变量B的值为3。

示例

下面的代码展示了如何使用位运算符

pragma solidity ^0.5.0;contract SolidityTest { uint storedData;constructor() public{storedData = 10;} function getResult() public view returns(string memory){uint a = 2; // 局部变量uint b = 2;uint result = a & b;// 位与return integerToString(result);} function integerToString(uint _i) internal pure returns (string memory) {if (_i == 0) { return "0";}uint j = _i;uint len;while (j != 0) { len++; j /= 10;}bytes memory bstr = new bytes(len);uint k = len - 1;while (_i != 0) { bstr[k--] = byte(uint8(48 + _i % 10)); _i /= 10;}return string(bstr);// 访问局部变量 }}

输出

0: string: 2

5.赋值运算符

Solidity 支持的赋值运算符，如下表所示：

注意– 同样的逻辑也适用于位运算符，因此它们将变成<<=、>>=、>>=、&=、|=和^=。

下面的代码展示了如何使用赋值运算符。

pragma solidity ^0.5.0;contract SolidityTest { uint storedData;constructor() public{storedData = 10;} function getResult() public view returns(string memory){uint a = 1; uint b = 2;uint result = a + b;return integerToString(storedData);} function integerToString(uint _i) internal pure returns (string memory) {if (_i == 0) { return "0";}uint j = _i;uint len;while (j != 0) { len++; j /= 10; // 赋值运算}bytes memory bstr = new bytes(len);uint k = len - 1;while (_i != 0) { bstr[k--] = byte(uint8(48 + _i % 10)); _i /= 10;// 赋值运算}return string(bstr);// 访问局部变量 }}

输出

0: string: 10

6.条件运算符

Solidity 支持条件运算符。

0: string: 2

while (表达式) { 被执行语句(如果表示为真)}

pragma solidity ^0.5.0;contract SolidityTest { uint storedData;constructor() public{storedData = 10;} function getResult() public view returns(string memory){uint a = 10; uint b = 2;uint result = a + b;return integerToString(result);} function integerToString(uint _i) internal pure returns (string memory) {if (_i == 0) { return "0";}uint j = _i;uint len;while (j != 0) { len++; j /= 10;}bytes memory bstr = new bytes(len);uint k = len - 1;while (_i != 0) { // while 循环 bstr[k--] = byte(uint8(48 + _i % 10)); _i /= 10;}return string(bstr); }}

0: string: 12

do { 被执行语句(如果表示为真)} while (表达式);

pragma solidity ^0.5.0;contract SolidityTest { uint storedData;constructor() public{storedData = 10;} function getResult() public view returns(string memory){uint a = 10; uint b = 2;uint result = a + b;return integerToString(result);} function integerToString(uint _i) internal pure returns (string memory) {if (_i == 0) { return "0";}uint j = _i;uint len;while (j != 0) { len++; j /= 10;}bytes memory bstr = new bytes(len);uint k = len - 1;do { // do while 循环bstr[k--] = byte(uint8(48 + _i % 10)); _i /= 10;}while (_i != 0);return string(bstr); }}

0: string: 12

for (初始化; 测试条件; 迭代语句) { 被执行语句(如果表示为真)}

pragma solidity ^0.5.0;contract SolidityTest { uint storedData;constructor() public{storedData = 10;} function getResult() public view returns(string memory){uint a = 10; uint b = 2;uint result = a + b;return integerToString(result);} function integerToString(uint _i) internal pure returns (string memory) {if (_i == 0) { return "0";}uint j=0;uint len;for (j = _i; j != 0; j /= 10) {//for循环的例子 len++; }bytes memory bstr = new bytes(len);uint k = len - 1;while (_i != 0) { bstr[k--] = byte(uint8(48 + _i % 10)); _i /= 10;}return string(bstr);//访问局部变量 }}

0: string: 12

pragma solidity ^0.5.0;contract SolidityTest { uint storedData;constructor() public{storedData = 10;} function getResult() public view returns(string memory){uint a = 1; uint b = 2;uint result = a + b;return integerToString(result);} function integerToString(uint _i) internal pure returns (string memory) {if (_i == 0) { return "0";}uint j = _i;uint len;while (true) { len++; j /= 10; if(j==0){break; // break 语句跳出循环 }}bytes memory bstr = new bytes(len);uint k = len - 1;while (_i != 0) { bstr[k--] = byte(uint8(48 + _i % 10)); _i /= 10;}return string(bstr); }}

0: string: 3

pragma solidity ^0.5.0;contract SolidityTest { uint storedData;constructor() public{storedData = 10;} function getResult() public view returns(string memory){uint n = 1;uint sum = 0;while( n < 10){ n++; if(n == 5){continue; // 当n的和是5时，跳过n。 } sum = sum + n;}return integerToString(sum);} function integerToString(uint _i) internal pure returns (string memory) {if (_i == 0) { return "0";}uint j = _i;uint len;while (true) { len++; j /= 10; if(j==0){break; // break跳出循环 }}bytes memory bstr = new bytes(len);uint k = len - 1;while (_i != 0) { bstr[k--] = byte(uint8(48 + _i % 10)); _i /= 10;}return string(bstr); }}

0: string: 49