智能合约技术学习part2

智能合约技术学习part2

solidity语言

官方文档https://docs.soliditylang.org/en/v0.8.11/index.html

在线编译工具https://remix.ethereum.org

一、hello world

智能合约是面向对象的语言，拥有属性和行为两种常见的对象

//SPDX-License-Identifier:MIT
pragma solidity ^0.5.0;

contract helloworld{
    string myname = "helloworld"; 

    //调用getName函数，gas是否会消耗  
    function getName () public view returns (string memory){
        return myname;
    }
//调用changeName函数，gas是否会消耗
    function changeName (string memory _newname) public {
        myname = _newname;
    } 

}

先分步骤解析

//SPDX-License-Identifier:MIT

预编译，声明源码版权，上例是MIT的版权，没有会警告/报错

pragma solidity ^0.5.0;

^表示向上兼容，默认范围0.5.0-0.6.0，版本不同也会有不同的问题，或者可以采用如下的版本命名法

pragma solidity >=0.5.0 <0.8.0;

contract也就是合约 是solidity的一个特殊关键词，是状态变量，用来说明新合约，类似于面向对象中语言中类的定义，声明合同的作用状态变量是其值永久存储在合约存储中的变量。

string myname = "helloworld"

一个string类型的变量，状态变量myname是储存在区块链上

注意：在0.7.0以上的版本，输入中文字符等需要加入unicode前缀标识例如：unicode"Hello 😃"

function getName () public view returns

function是代码的可执行单元。function通常在合约内定义，但也可以在合约外定义。

public 是显式功能可见性

注意：public词在0.5.0以上的版本如果没有添加 会进行报错

本例中调用changeName会被gas消耗，而使用getName则不会被gas消耗

gas可以理解为在运行调用智能合约时候消耗的资源

二、view与pure

view和pure在solidity中可以有节约gas的作用

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Test01{
    sting public name = unicode"你好hello";
    
    function getName() public view returns(string memory){
        return name;
    }
    
    function setName(string meory _newName) public {
        name = _newName;
        
    }
    
    function f(uint a, uint b ) public pure returns(uint){
        return a*(b+42)
    }
}

上例子中：

function getName() public view returns(string memory)

在function函数中用到view，作用是，因为name上的数据已经存储到区块链上了，然后对区块链上的数据进行读取时候，需要对getName()进行状态修饰。

function f(uint a, uint b ) public pure returns(uint)

在function函数中用到pure的修饰符，静态修饰符，是因为这个函数并没有对区块链上的数据进行读取

？

function setName(string meory _newName) public

这个function函数中，仅仅是修改了 状态变量name的变量值没有读取区块链上的数据

setName是作用于getName函数上的不需要有修饰符。

？

view与pure是solidity中的函数修饰符，在使用view修饰符时候，因为读取并修改了区块链上的数据所以gas值会产生变化。而在使用pure的时候，因为并没有读取区块链，反而在本地进行，gas值并不会产生变化。

三、bool类型

bool类型只有真或假也就是 true和false，bool类型一般适用于运算，一般用于流程控制

// SPDX-License-Identifier: Steven
pragma solidity ^0.8.0;

contract Booltest{
    bool a;
    int c = 100; 
    int d = 200; 
    function getBoolDefault( ) public view returns ( bool ) { 
        return a; 
    }  //会返回（false）,bool 的默认类型是false
    function getBoolean( ) public view returns ( bool ) { 
        return !a; 
    }   //会返回（ture），非false
    function judge( ) public view returns ( bool ) { 
        return c==d; 
    }   //会返回（false）,c不等于d
    function logicAnd( ) public view returns ( bool ) { 
        return c==d && true;   
    }    //会返回（false），假真为假
    function logicOr( ) public view returns ( bool ) { 
        return c==d || true;  
    }    //会返回（ture），假真为真
    function logicNot() public view returns ( bool ) {
        return c!=d && true; 
    }    //会返回（ture），真真为真

与运算符：

与(&&)：逻辑规则是两真才真。与and等同。

true && true = true ===> 1 && 1 = 1

true && false = false ===> 1 && 0 = 0

false && false = false ===> 0 && 0 = 0

false && true = false ===> 0 && 1 = 0

或运算符：

或(||)：逻辑规则是只有一个为真就为真。与or等同。

true || true = true ===> 1 || 1 = 1

true || false = true ===> 1 || 0 = 1

false || false = false ===> 0 || 0 = 0

false || true = true ===> 0 || 1 = 1

四、整型的运算

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.0;
contract math {
	
    uint8 numa = 255;//0~255
	int8 numb = 127;//-128~127
	int numc = 255;
	//加法
	function add(uint a , uint b) public pure returns(uint){
       	return a+b;
    }
    //减法
   	function subtract(uint a , uint b) public pure returns(uint){
       	if(a > b) {
         	return  a - b;
    	} else {
       		return b - a;
    	}
   	}
   	//乘法
   	function multiply(uint a , uint b) public pure returns(uint){
        return a*b;
    }
    //除法
    function divide(uint a , uint b) public pure returns(uint){
        if(b != 0){
        	return a/b;
    	}
    }
    //取余
    function Surplus(uint a , uint b ) public pure returns(uint){
        return a%b;
    }
    //a的b次方
    function square(uint a , uint b) public pure returns(uint){
        return a**b;
    }
}

取值范围：

int/ uint：各种大小的有符号和无符号整数。

关键字uint8to uint256（8是无符号 8 字节和 无符号256字节 ）和int8to int256。

uint和分别是和int的别名。uint256 int256

类型	有无符号	占用空间	表述范围
int8	有	1字节	-128~127
int16	有	2字节	-2的15次方~2的15次方-1
int32	有	4字节	-2的31次方~2的31次方-1
int64	有	8字节	-2的63次方~2的63次方-1
uint8	无	1字节	0~255
uint16	无	2字节	0~2的16次方-1
uint32	无	4字节	0~2的32次方-1
uint64	无	8字节	0~2的64次方-1

五、底层运算

a&b：位与（有0则为0）

a|b：位或（有1则为1）

~a：位非（1则0，0则1）（取反）

a^b：位异或（相同则为1，不同则为0）

a<<1：左移（整体左移，低位补零）

a>>1：右移（整体右移，高位补零）

注意：solidity 目前没有浮点数，不能计算浮点数等特殊数据类型

六、固定长度字节数和动态长度字节数组

bytes=8个字节，只能定义16进制数0Xff，而uint即可16进制又可以10进制，uint256=bytes32 ==>32*8=256

bytes需要指定位数如要写成bytes2=2*8=16位

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
contract DynamicByte{
    bytes public name = new bytes(2);
	//设置两个动态数组
    function Initname ()public{
        name[0] = 0x7a;
        name[1] = 0x68;
    }
	
    function getLength() public view returns(uint) {
        return name.length;
    }
	//将索引处0的位置改为0x88
    function changename( )public{
		name[0]=0x88;
    }
	//追加0x55
    function pushBytes()public{
		name.push(0x55);
    }
	//bytes转换为string类型
 	function bytesToString()public view returns(string memory){
    	return string (name);
 }
}

注意：

function changename( )：改变内容

function pushBytes()：加入字节数组，.push可以在后面加入数组

function bytesToString()：字节数组的转换

七、数据类型

数据类型：bool型、 整型、字符串、字节、枚举型、地址

// Solidity program to demonstrate
// value types
pragma solidity ^ 0.5.0;   
   
contract Types {   
 
    // bool型
    bool public boolean = false;
    
    // 整型
    int32 public int_var = -60313;
 
    //  字符串
    string public str = "GeeksforGeeks";
 
    // 字节
    bytes1 public b = "a";
     
    // 枚举型
    enum my_enum { geeks_, _for, _geeks } 
 
    function Enum() public pure returns(my_enum) {   
        return my_enum._geeks;   
    }   
}

参考类型：数组、结构体、对应关系

pragma solidity ^0.4.18;

// Creating a contract
contract mapping_example {

	//定义数组
	uint[5] public array
	= [uint(1), 2, 3, 4, 5] ;
	
	// 定义结构体
	struct student {
		string name;
		string subject;
		uint8 marks;
	}

	// 创建结构对象
	student public std1;

	// 定义返回函数
	// 写入结构体的值
	function structure() public view returns(
	string memory, string memory, uint){
		std1.name = "John";
		std1.subject = "Chemistry";
		std1.marks = 88;
		return (
		std1.name, std1.subject, std1.marks);
	}
	
	// 创建对应关系
	mapping (address => student) result;
	address[] student_result;
}