Solidity基础语法、关键字

目录

• • • • 一、版本指令：pragma solidity ^x.x.xx;
      • 二、合约创建：contract xxx { … }
      • 三、状态变量
      • 四、无符号整数：uint
      • 五、数学运算（加减乘除、乘方）
      • 六、结构体：struct
      • 七、数组
      • • 静态数组
        • 动态数组
        • 公共数组
      • 八、定义函数
      • 九、使用结构体和数组
      • 十、私有 / 公共函数
      • 十一、返回值：returns
      • 十二、函数的修饰符：view
      • 十三、函数修饰符：pure
      • 十四、散列函数Keccak256：字符串转256位16进制数字
      • 十五、类型转换
      • 十六、事件：event
      • 十七、Web3.js
      • 十八、地址：Address
      • 十九、映射：mapping
      • 二十、Msg.sender
      • 二十一、Require
      • 二十二、继承（Inheritance）
      • 二十三、引入（Import）
      • 二十四、Storage（永久存储在区块链的变量）与Memory（临时变量）
      • 二十五、函数可见性（internal 和 external）
      • 二十六、与其他合约的交互（接口）
      • 二十七、处理多返回值
      • 二十八、if语句
      • 二十九、构造函数
      • 三十、modifier修饰符

一、版本指令：pragma solidity ^x.x.xx;

pragma solidity >=0.5.0 <0.6.0;//在本示例的范围内，我们希望能够使用0.5.0（包括）到 0.6.0（不包括）范围内的任何编译器版本来编译我们的智能合约。

所有 Solidity 源代码都应该以“版本编译指示”开头——该代码应该使用的 Solidity 编译器版本的声明。这是为了防止未来编译器版本的问题可能会引入会破坏您的代码的更改。
总而言之，这是一个基本的起始合同——每次开始一个新项目时你要写的第一件事。

二、合约创建：contract xxx { … }

contract HelloWorld {....}

Solidity的代码都封装在contracts中。contract是以太坊应用程序的基本构建块，所有变量和函数都属于一个合约，这将是你所有项目的起点。

三、状态变量

contract Example {//这将永久存储在区块链中 uint myUnsignedInteger = 100;}

状态变量永久存储在合约存储中。这意味着它们被写入以太坊区块链。把它们想象成写数据库。
在示例中，定义 myUnsignedInteger 为 uint 类型并将其设置为 100。

四、无符号整数：uint

uint 无符号数据类型， 指其值不能是负数，对于有符号的整数存在名为 int 的数据类型。

注: Solidity中， uint 实际上是 uint256代名词， 一个256位的无符号整数。你也可以定义位数少的无符号整数 — uint8， uint16， uint32， 等…… 但一般来讲你愿意使用简单的 uint， 除非在某些特殊情况下，这我们后面会讲。

五、数学运算（加减乘除、乘方）

加法：x+y减法：x-y乘法：x*y除法：x/y

Solidity 还支持 乘方操作 (如：x 的 y次方） // 例如： 5 ** 2 = 25uint x = 5 ** 2; // equal to 5^2 = 25

六、结构体：struct

struct Person {uint age;string name;}

结构体允许你生成一个更复杂的数据类型，它有多个属性。

注：我们刚刚引进了一个新类型, string。 字符串用于保存任意长度的 UTF-8 编码数据。 如： string greeting = “Hello world!”。

七、数组

如果你想建立一个集合，可以用数组这样的数据类型. Solidity 支持两种数组: 静态数组和动态数组:

静态数组

// 固定长度为2的静态数组:uint[2] fixedArray;// 固定长度为5的string类型的静态数组:string[5] stringArray;// 动态数组，长度不固定，可以动态添加元素:uint[] dynamicArray;

动态数组

你也可以建立一个 结构体类型的数组 例如，（六、结构体中提到的) Person:

Person[] people; // 这是动态数组，我们可以不断添加元素

记住：状态变量被永久保存在区块链中。所以在你的合约中创建动态数组来保存成结构的数据是非常有意义的。

公共数组

你可以定义 public 数组, Solidity 会自动创建 getter 方法. 语法如下:

Person[] public people;

其它的合约可以从这个数组读取数据（但不能写入数据），所以这在合约中是一个有用的保存公共数据的模式。

八、定义函数

function eatHamburgers(string _name, uint _amount) {}

这是一个名为 eatHamburgers 的函数，它接受两个参数：一个 string类型的 和 一个 uint类型的。现在函数内部还是空的。

注：: 习惯上函数里的变量都是以(_)开头 (但不是硬性规定) 以区别全局变量。我们整个笔记都会沿用这个习惯。

调用函数示例：

eatHamburgers("vitalik", 100);

九、使用结构体和数组

struct Person {uint age;string name;}Person[] public people;

现在我们创建新的 Person 结构，然后把它加入到名为 people 的数组中.

// 创建一个新的Person:Person satoshi = Person(172, "Satoshi");// 将新创建的satoshi添加进people数组:people.push(satoshi);

你也可以两步并一步，用一行代码更简洁:

people.push(Person(16, "Vitalik"));

注：array.push() 在数组的 尾部 加入新元素 ，所以元素在数组中的顺序就是我们添加的顺序， 如:

uint[] numbers;numbers.push(5);numbers.push(10);numbers.push(15);// numbers is now equal to [5, 10, 15]

十、私有 / 公共函数

Solidity 定义的函数的属性默认为public。 这就意味着任何一方 (或其它合约) 都可以调用你合约里的函数。

显然，不是什么时候都需要这样，而且这样的合约易于受到攻击。 所以将自己的函数定义为private是一个好的编程习惯，只有当你需要在外部调用它时才将它设置为public。

如何定义一个私有的函数呢？

uint[] numbers;function _addToArray(uint _number) private {numbers.push(_number);}

这意味着只有我们合约中的其它函数才能够调用这个函数，给 numbers 数组添加新成员。

可以看到，在函数名字后面使用关键字 private 即可。和函数的参数类似，私有函数的名字用(_)起始。

十一、返回值：returns

Solidity 里，函数的定义里可包含返回值的数据类型(如本例中 string)。

string greeting = "What's up dog";function sayHello() public returns (string) {return greeting;}

十二、函数的修饰符：view

上面的函数实际上没有改变 Solidity 里的状态，即，它没有改变任何值或者写任何东西。
这种情况下我们可以把函数定义为 view, 意味着它只能读取数据不能更改数据:

function sayHello() public view returns (string) {

十三、函数修饰符：pure

Solidity 还支持 pure 函数, 表明这个函数甚至都不访问应用里的数据，例如：

function _multiply(uint a, uint b) private pure returns (uint) {return a * b;}

这个函数甚至都不读取应用里的状态 — 它的返回值完全取决于它的输入参数，在这种情况下我们把函数定义为 pure.

注：可能很难记住何时把函数标记为 pure/view。 幸运的是， Solidity 编辑器会给出提示，提醒你使用这些修饰符。

十四、散列函数Keccak256：字符串转256位16进制数字

Ethereum 内部有一个散列函数keccak256，它用了SHA3版本。一个散列函数基本上就是把一个字符串转换为一个256位的16进制数字。字符串的一个微小变化会引起散列数据极大变化。

这在 Ethereum 中有很多应用，但是现在我们只是用它造一个伪随机数。

例子:

//6e91ec6b618bb462a4a6ee5aa2cb0e9cf30f7a052bb467b0ba58b8748c00d2e5keccak256("aaaab");//b1f078126895a1424524de5321b339ab00408010b7cf0e6ed451514981e58aa9keccak256("aaaac");

显而易见，输入字符串只改变了一个字母，输出就已经天壤之别了。

注: 在区块链中安全地产生一个随机数是一个很难的问题，只适用于不那么重要的功能，如果要一个安全的随机数，本例的方法并不安全。

十五、类型转换

uint8 a = 5;uint b = 6;// 将会抛出错误，因为 a * b 返回 uint, 而不是 uint8:uint8 c = a * b;// 我们需要将 b 转换为 uint8:uint8 c = a * uint8(b);

上面, a * b 返回类型是 uint, 但是当我们尝试用 uint8 类型接收时, 就会造成潜在的错误。如果把它的数据类型转换为 uint8, 就可以了，编译器也不会出错。

十六、事件：event

事件 是合约和区块链通讯的一种机制。你的前端应用“监听”某些事件，并做出反应。

例子:

// 这里建立事件event IntegersAdded(uint x, uint y, uint result);function add(uint _x, uint _y) public {uint result = _x + _y;//触发事件，通知appIntegersAdded(_x, _y, result);return result;}

你的 app 前端可以监听这个事件。JavaScript 实现如下:

YourContract.IntegersAdded(function(error, result) {// 干些事})

十七、Web3.js

如果我们要写一段 JavaScript 前端代码来调用这个合约。

以太坊有一个 JavaScript 库，名为Web3.js。

在后面的课程里，我们会进一步地教你如何安装一个合约，如何设置Web3.js。 但是现在我们通过一段代码来了解 Web3.js 是如何和我们发布的合约交互的吧。

如果下面的代码你不能全都理解，不用担心。

// 下面是调用合约的方式:var abi = /* abi是由编译器生成的 */var ZombieFactoryContract = web3.eth.contract(abi)var contractAddress = /* 发布之后在以太坊上生成的合约地址 */var ZombieFactory = ZombieFactoryContract.at(contractAddress)// `ZombieFactory` 能访问公共的函数以及事件// 某个监听文本输入的监听器:$("#ourButton").click(function(e) {var name = $("#nameInput").val()//调用合约的 `createRandomZombie` 函数:ZombieFactory.createRandomZombie(name)})// 监听 `NewZombie` 事件, 并且更新UIvar event = ZombieFactory.NewZombie(function(error, result) {if (error) returngenerateZombie(result.zombieId, result.name, result.dna)})// 获取 Zombie 的 dna, 更新图像function generateZombie(id, name, dna) {let dnaStr = String(dna)// 如果dna少于16位,在它前面用0补上while (dnaStr.length < 16)dnaStr = "0" + dnaStrlet zombieDetails = {// 前两位数构成头部.我们可能有7种头部, 所以 % 7// 得到的数在0-6,再加上1,数的范围变成1-7// 通过这样计算：headChoice: dnaStr.substring(0, 2) % 7 + 1，// 我们得到的图片名称从head1.png 到 head7.png// 接下来的两位数构成眼睛, 眼睛变化就对11取模:eyeChoice: dnaStr.substring(2, 4) % 11 + 1,// 再接下来的两位数构成衣服，衣服变化就对6取模:shirtChoice: dnaStr.substring(4, 6) % 6 + 1,//最后6位控制颜色. 用css选择器: hue-rotate来更新// 360度:skinColorChoice: parseInt(dnaStr.substring(6, 8) / 100 * 360),eyeColorChoice: parseInt(dnaStr.substring(8, 10) / 100 * 360),clothesColorChoice: parseInt(dnaStr.substring(10, 12) / 100 * 360),zombieName: name,zombieDescription: "A Level 1 CryptoZombie",}return zombieDetails}

我们的 JavaScript 所做的就是获取由zombieDetails 产生的数据, 并且利用浏览器里的 JavaScript 神奇功能 (我们用 Vue.js)，置换出图像以及使用CSS过滤器。在后面的课程中，你可以看到全部的代码。

十八、地址：Address

以太坊区块链由 account (账户)组成，你可以把它想象成银行账户。一个帐户的余额是 以太 （在以太坊区块链上使用的币种），你可以和其他帐户之间支付和接受eth，就像你的银行帐户可以电汇资金到其他银行帐户一样。

每个帐户都有一个“地址”，你可以把它想象成银行账号。这是账户唯一的标识符，它看起来长这样：

0x0cE446255506E92DF41614C46F1d6df9Cc969183

十九、映射：mapping

在上面，我们看到了 结构体 和 数组 。 映射 是另一种在 Solidity 中存储有组织数据的方法。
映射是这样定义的：

//对于金融应用程序，将用户的余额保存在一个 uint类型的变量中：mapping (address => uint) public accountBalance;//或者可以用来通过userId 存储/查找的用户名mapping (uint => string) userIdToName;

映射本质上是存储和查找数据所用的键-值对。在第一个例子中，键是一个 address，值是一个 uint，在第二个例子中，键是一个uint，值是一个 string。

二十、Msg.sender

在 Solidity 中，有一些全局变量可以被所有函数调用。 其中一个就是 msg.sender，它指的是当前调用者（或智能合约）的 address。

注意：在 Solidity 中，功能执行始终需要从外部调用者开始。 一个合约只会在区块链上什么也不做，除非有人调用其中的函数。所以 msg.sender总是存在的。

以下是使用 msg.sender 来更新 mapping 的例子：

mapping (address => uint) favoriteNumber;function setMyNumber(uint _myNumber) public {// 更新我们的 `favoriteNumber` 映射来将 `_myNumber`存储在 `msg.sender`名下favoriteNumber[msg.sender] = _myNumber;// 存储数据至映射的方法和将数据存储在数组相似}function whatIsMyNumber() public view returns (uint) {// 拿到存储在调用者地址名下的值// 若调用者还没调用 setMyNumber， 则值为 `0`return favoriteNumber[msg.sender];}

在这个小小的例子中，任何人都可以调用 setMyNumber 在我们的合约中存下一个 uint 并且与他们的地址相绑定。 然后，他们调用 whatIsMyNumber 就会返回他们存储的 uint。

使用 msg.sender 很安全，因为它具有以太坊区块链的安全保障 —— 除非窃取与以太坊地址相关联的私钥，否则是没有办法修改其他人的数据的。

二十一、Require

require使得函数在执行过程中，当不满足某些条件时抛出错误，并停止执行：

function sayHiToVitalik(string _name) public returns (string) {// 比较 _name 是否等于 "Vitalik". 如果不成立，抛出异常并终止程序// (敲黑板: Solidity 并不支持原生的字符串比较, 我们只能通过比较// 两字符串的 keccak256 哈希值来进行判断)require(keccak256(_name) == keccak256("Vitalik"));// 如果返回 true, 运行如下语句return "Hi!";}

如果你这样调用函数 sayHiToVitalik（“Vitalik”） ,它会返回“Hi！”。而如果调用的时候使用了其他参数，它则会抛出错误并停止执行。

因此，在调用一个函数之前，用 require 验证前置条件是非常有必要的。

二十二、继承（Inheritance）

当代码过于冗长的时候，最好将代码和逻辑分拆到多个不同的合约中，以便于管理。

有个让 Solidity 的代码易于管理的功能，就是合约 inheritance (继承)：

contract Doge {function catchphrase() public returns (string) {return "So Wow CryptoDoge";}}contract BabyDoge is Doge {function anotherCatchphrase() public returns (string) {return "Such Moon BabyDoge";}}

由于 BabyDoge 是从 Doge 那里 inherits （继承)过来的。 这意味着当你编译和部署了 BabyDoge，它将可以访问 catchphrase() 和 anotherCatchphrase()和其他我们在 Doge 中定义的其他公共函数。

这可以用于逻辑继承（比如表达子类的时候，Cat 是一种 Animal）。 但也可以简单地将类似的逻辑组合到不同的合约中以组织代码。

二十三、引入（Import）

在 Solidity 中，当你有多个文件并且想把一个文件导入另一个文件时，可以使用 import 语句：

import "./someothercontract.sol";contract newContract is SomeOtherContract {}

这样当我们在合约（contract）目录下有一个名为 someothercontract.sol 的文件（ ./ 就是同一目录的意思），它就会被编译器导入。

二十四、Storage（永久存储在区块链的变量）与Memory（临时变量）

在 Solidity 中，有两个地方可以存储变量 —— storage 或 memory。

Storage 变量是指永久存储在区块链中的变量。
Memory 变量则是临时的，当外部函数对某合约调用完成时，内存型变量即被移除。 你可以把它想象成存储在你电脑的硬盘或是RAM中数据的关系。

大多数时候你都用不到这些关键字，默认情况下 Solidity 会自动处理它们。 状态变量（在函数之外声明的变量）默认为“存储”形式，并永久写入区块链；而在函数内部声明的变量是“内存”型的，它们函数调用结束后消失。

然而也有一些情况下，你需要手动声明存储类型，主要用于处理函数内的 结构体 和 数组 时：

contract SandwichFactory {struct Sandwich {string name;string status;}Sandwich[] sandwiches;function eatSandwich(uint _index) public {// Sandwich mySandwich = sandwiches[_index];// ^ 看上去很直接，不过 Solidity 将会给出警告// 告诉你应该明确在这里定义 `storage` 或者 `memory`。// 所以你应该明确定义 `storage`:Sandwich storage mySandwich = sandwiches[_index];// ...这样 `mySandwich` 是指向 `sandwiches[_index]`的指针// 在存储里，另外...mySandwich.status = "Eaten!";// ...这将永久把 `sandwiches[_index]` 变为区块链上的存储// 如果你只想要一个副本，可以使用`memory`:Sandwich memory anotherSandwich = sandwiches[_index + 1];// ...这样 `anotherSandwich` 就仅仅是一个内存里的副本了// 另外anotherSandwich.status = "Eaten!";// ...将仅仅修改临时变量，对 `sandwiches[_index + 1]` 没有任何影响// 不过你可以这样做:sandwiches[_index + 1] = anotherSandwich;// ...如果你想把副本的改动保存回区块链存储}}

当你不得不使用到这些关键字的时候，Solidity 编译器也会发警示提醒你的。

现在，只要知道在某些场合下也需要你显式地声明 storage 或 memory就够了！

二十五、函数可见性（internal 和 external）

除 public 和 private 属性之外，Solidity 还使用了另外两个描述函数可见性的修饰词：internal（内部） 和 external（外部）。

internal 和 private 类似，不过， 如果某个合约继承自其父合约，这个合约即可以访问父合约中定义的“内部”函数。

external 与public 类似，只不过这些函数只能在合约之外调用 – 它们不能被合约内的其他函数调用。稍后我们将讨论什么时候使用 external 和 public。

声明函数 internal 或 external 类型的语法，与声明 private 和 public类 型相同：

contract Sandwich {uint private sandwichesEaten = 0;function eat() internal {sandwichesEaten++;}}contract BLT is Sandwich {uint private baconSandwichesEaten = 0;function eatWithBacon() public returns (string) {baconSandwichesEaten++;// 因为eat() 是internal 的，所以我们能在这里调用eat();}}

二十六、与其他合约的交互（接口）

如果我们的合约需要和区块链上的其他的合约会话，则需先定义一个 interface (接口)。

先举一个简单的栗子。 假设在区块链上有这么一个合约：

contract LuckyNumber {mapping(address => uint) numbers;function setNum(uint _num) public {numbers[msg.sender] = _num;}function getNum(address _myAddress) public view returns (uint) {return numbers[_myAddress];}}

这是个很简单的合约，您可以用它存储自己的幸运号码，并将其与您的以太坊地址关联。 这样其他人就可以通过您的地址查找您的幸运号码了。

现在假设我们有一个外部合约，想要使用 getNum 函数可读取其中的数据。

首先，我们定义 LuckyNumber 合约的 interface ：

contract NumberInterface {function getNum(address _myAddress) public view returns (uint);}

请注意，这个过程虽然看起来像在定义一个合约，但其实内里不同：

首先，我们只声明了要与之交互的函数 —— 在本例中为 getNum —— 在其中我们没有使用到任何其他的函数或状态变量。

其次，我们并没有使用大括号（{ 和 }）定义函数体，我们单单用分号（;）结束了函数声明。这使它看起来像一个合约框架。

编译器就是靠这些特征认出它是一个接口的。

在我们的 app 代码中使用这个接口，合约就知道其他合约的函数是怎样的，应该如何调用，以及可期待什么类型的返回值。

我们可以在合约中这样使用这个接口：

contract MyContract {address NumberInterfaceAddress = 0xab38...;// ^ 这是FavoriteNumber合约在以太坊上的地址NumberInterface numberContract = NumberInterface(NumberInterfaceAddress);// 现在变量 `numberContract` 指向另一个合约对象function someFunction() public {// 现在我们可以调用在那个合约中声明的 `getNum`函数:uint num = numberContract.getNum(msg.sender);// ...在这儿使用 `num`变量做些什么}}

通过这种方式，只要将您合约的可见性设置为public(公共)或external(外部)，它们就可以与以太坊区块链上的任何其他合约进行交互。

二十七、处理多返回值

function multipleReturns() internal returns(uint a, uint b, uint c) {return (1, 2, 3);}function processMultipleReturns() external {uint a;uint b;uint c;// 这样来做批量赋值:(a, b, c) = multipleReturns();}// 或者如果我们只想返回其中一个变量:function getLastReturnValue() external {uint c;// 可以对其他字段留空:(,,c) = multipleReturns();}

二十八、if语句

if语句的语法在 Solidity 中，与在 JavaScript 中差不多：

function eatBLT(string sandwich) public {// 看清楚了，当我们比较字符串的时候，需要比较他们的 keccak256 哈希码if (keccak256(sandwich) == keccak256("BLT")) {eat();}}

二十九、构造函数

/** * @dev The Ownable constructor sets the original `owner` of the contract to the sender * account. */function Ownable() public {owner = msg.sender;}

构造函数：function Ownable()是一个 _ constructor_ (构造函数)，构造函数不是必须的，它与合约同名，构造函数一生中唯一的一次执行，就是在合约最初被创建的时候。

三十、modifier修饰符

/** * @dev Throws if called by any account other than the owner. */modifier onlyOwner() {require(msg.sender == owner);_;}

修饰符跟函数很类似，不过是用来修饰其他已有函数用的， 在其他语句执行前，为它检查下先验条件。(此修饰符在另一篇文章有更详细的解释，如果我下篇文章写完没改变主义的话，下篇文章应该叫solidity理论)