区块链Solidity智能合约语言学习笔记

淡淡的烟草味﹌ 2024-04-05 06:07 77阅读 0赞

### **Solidity简介** ###

以太坊拥有多种高级语言,可用于编写智能合约,每种语言都受到另一种广泛使用的语言的启发。最流行的一种叫做Solidity,它基于JavaScript。由于Solidity是迄今为止最成熟的以太坊语言,因此它是社区大力鼓励开发人员现在使用的语言。

Solidity是一种语法类似JavaScript的高级语言。它被设计成以编译的方式生成以太坊虚拟机代码。使用它很容易创建用于投票、众筹、封闭拍卖、多重签名钱包等等的合约。

### **编译环境** ###

Remix在线编译器:[http://remix.app.hubwiz.com/][http_remix.app.hubwiz.com]

VScode编译器也行，其插件：

![f552f345549441dbb2bbb298241480cb.png][]

### **第一个程序Hello world** ###

参考：[https://blog.csdn.net/weixin\_45067603/article/details/105726491][https_blog.csdn.net_weixin_45067603_article_details_105726491]

pragma solidity ^0.4.0;
    
    contract helloworld {
        string myword = "helloworld";
        
        function show() public view returns(string){
            return myword;
        }
        
        function changMyword(string _newWord) public{
            myword = _newWord;
        }
    
    }

![9edfcad2fbe041f1b1afd69e7ddf00f7.png][]

![42622dc1192040cda262b380945a89a5.png][]

### **solidity的四种可见度/访问权限** ###

*  public：任何人都可以调用该函数，包括DApp的使用者。
 *  private：只有合约本身可以调用该函数（在另一个函数中）。
 *  internal：只有这份合同以及由此产生的所有合同才能称之为合同。
 *  external：只有外部可以调用该函数，而合约内部不能调用。

### **solidity的三种修饰符** ###

view: 可以自由调用，因为它只是“查看”区块链的状态而不改变它

pure: 也可以自由调用，既不读取也不写入区块链

payable:常常用于将代币发送给合约地址。

### **solidity的函数应有以下部分组成** ###

#### **function** ####

你的函数名字(类型1 名字,类型2 名字，。。。,类型n 名字) 如果没有就什么都不填即可

可见度/访问权限，即public/private/internal/external 如果不写则系统默认为public并且警告

修饰符，即view/pure/payable 如果需要花费gas则不写

#### **returns(类型1 名字,类型2 名字，。。。,类型n 名字)**  ####

### **布尔值bool** ###

pragma solidity ^0.4.0;
    
    contract helloworld {
        bool boola=true; //声明一个布尔类型的值，只用一个等号
        function booltesta() public view returns(bool){
            return boola;
        }
        
        function booltestb(int a,int b) public pure returns(bool){
            return a==b;
        }
        
        function boolteston(int a,int b) public pure returns(bool){
            return !(a==b);
        }
    }

![0fd7faf306714735ab21cf1c8e9a95a3.png][]

### **与，或** ###

即： && ||

### **通常运算符** ###

即+，-，\*，/，%以及特殊的符号\*\*代表x的x次幂

位运算符

1.& 操作数之间转换成二进制之后每位进行与运算操作（同1取1）

2.| 操作数之间转换成二进制之后每位进行或运算操作（有1取1）

3.~ 操作数转换成二进制之后每位进行取反操作（直接相反）

4.^ 操作数之间转换成二进制之后每位进行异或操作（不同取1）

5.<<操作数转换成二进制之后每位向左移动x位的操作

6.>>操作数转换成二进制之后每位向右移动x位的操作

### **可变长度byte数组** ###

声明方法

bytes arr = new bytes(length);
    
    function arrlengthchange(uint a) public { arr1.length=a;  }

### **String型** ###

pragma solidity ^0.4.0;
    contract stringtest1{
        string testword='helloworld'; //68656c6c6f776f726c64为这串字符的16进制
        
        function stringlength() public view returns (uint){
            //return testword.length;  直接返回长度会报错
            return bytes(testword).length;  //强制类型转换之后可以
        }
        
        function stringchange() public  {
            //testword[0]='A'; 直接进行变更会报错
            bytes(testword)[0]='A'; //41为A的16进制值，强制类型转换之后可以修改
        }
        
        function getname() public view returns(bytes){
            return bytes(testword); //查看16进制的string
        }
        
        function stringchangetest() public view returns(byte){
            return bytes(testword)[0]; //查看第一位是否被修改
        }
        
    }

![1ee2e18d54ac4d6c9b3619681c225c96.png][]

#### **string类型是怎么存储数据的** ####

英文字符(A-z)以及特殊字符(&\*@\#&%())等为一个字节  
中文字符为3个字节 PS.solidity中文输入支持很差

pragma solidity ^0.4.0;
    
    contract stringstoragetest{
        string testword1='asldhlkasdh';
        string testword2='^*^*%*()*-/';
        string testword3='中文字符';
        string testword4='中文字符6666';
        
        function getest1() public view returns(uint){
            return bytes(testword1).length;
        }
        function getest2() public view returns(uint){
            return bytes(testword2).length;
        }
        function getest3() public view returns(uint){
            return bytes(testword3).length;
        }
         function getest4() public view returns(uint){
            return bytes(testword4).length;
        }
    }

![907fdfdc408f4a1ea510ed3cc8cc30fb.png][]

#### **固定长度字节数组bytes的截断** ####

结论：位数足够则保留前面的，位数不够再后面加0

pragma solidity ^0.4.0;
    
    contract bytetest1{
        bytes10 testword=0x68656c6c6f776f726c64; //helloworld
        function transbytes1() public view returns(bytes1){
            return bytes1(testword);
        }
        function transbytes2() public view returns(bytes5){
            return bytes5(testword);
        }
        function transbytes3() public view returns(bytes12){
            return bytes12(testword);
        }   
    }

![d9c27ccba3c741e2b0aa0007a7cb4ecc.png][]

#### 固定长度数组入门 ####

结论：  
1.如果不赋值，那么默认所有位均为0  
2.支持直接使用.length查看数组长度，但不支持对数组长度做修改  
3.不支持通过.push添加数据

pragma solidity ^0.4.0;
    
    contract fixedarrtest{
        uint[3] testarr1;//不进行赋值直接声明数组
        uint[3] testarr2=[1,2,3];//声明数组并进行赋值
        
        function showarr1() public view returns(uint[3]){
            return testarr1; //如果不赋值，那么默认所有位均为0
        }
        
        function showarr2() public view returns(uint[3]){
            return testarr2;
        }
        
        function initarr() public{
            testarr1[0]=12;//进行赋值操作
        }
        
        function lengthtest() public view returns(uint){
            return testarr1.length;//solidity支持直接查看数组长度
        }
        
        function changelengthtest() public view returns(uint){
            //testarr1.length=testarr1.length+3;//solidity不支持直接修改数组长度
        }
        
        function pushtest() public view {
            //testarr2.push(2);//solidity不支持直接push数据到数组
        }
        
    }

![a580608bedbe46ec8ab8f48ec0af7c61.png][]

#### 可变长度数组入门 ####

注意：与固定数组区别在于创建时是否定义长度  
结论：  
1.如果不初始化就无法单独赋值，但可以push或者改长度使有值之后再进行赋值。即必须修改的这一位不能为空  
2.支持直接使用.length查看数组长度，也支持对数组长度做修改。  
将数组长度缩小则会从前往后保留  
将数组长度增长则后面原本没有值的位会被默认置0  
3.支持直接通过.push方法在末尾添加数值

pragma solidity ^0.4.0;
    
    contract dynamicarrtest{
        uint[] testarr=[1,2,3,4,5];
        
        function showarr() public view returns (uint[]){
            return testarr;
        }
        
        function changearr() public{
            //for(uint i=0;i<5;i++){
                testarr[0] = 2;//如果不使0位有值，那么该函数无用
            //}
        }
        
        function lengthtest() public view returns(uint){
            return testarr.length;
        }
        
        function changelengthtest1() public{
            testarr.length=1;
        }
        
        function changelengthtest2() public{
            testarr.length=10;//变长之后后面默认置0
        }
        
        function pushtest() public{
            testarr.push(6);//可变数组支持此操作
        }
        
    }

![abab011961094d7099ccccc3660722ff.png][]

#### 固定长度二维数组 ####

结论  
1.初始化时，uint\[ i \] \[ j \]表示有j个元素，每个元素包含i个值（和其他许多语言不同）  
2.二维数组可以直接获取长度，既可以获得所有元素个数，也可以获得单独元素有多少值  
3.对二维数组进行增删改等操作时时是与初始化时反过来的，即uint\[ i \] \[ j \]表示第i个元素的第j个值（和其他许多语言一样）  
4.不支持push方法，也不支持对长度进行修改  
原文链接：[https://blog.csdn.net/weixin\_45067603/article/details/105751748][https_blog.csdn.net_weixin_45067603_article_details_105751748]

#### 可变长度二维数组 ####

结论  
1.初始化时，uint\[ i \] \[ j \]表示有j个元素，每个元素包含i个值（和其他许多语言不同）  
2.可变长度二维数组可以直接获取长度，既可以获得所有元素个数，也可以获得单独元素有多少值  
3.对二维数组进行增删改等操作时时是与初始化时反过来的，即uint\[ i \] \[ j \]表示第i个元素的第j个值（和其他许多语言一样）  
4.不支持push方法  
5.支持对长度进行修改，修改后默认值为0  
6.未声明的值不能直接赋值，修改长度之后默认有值才可以  
原文链接：[https://blog.csdn.net/weixin\_45067603/article/details/105751748][https_blog.csdn.net_weixin_45067603_article_details_105751748]

#### 数组字面量 ####

结论：  
1.返回数组时，returns（）括号里面的类型要与return的数据类型相同。  
通过getarr1和getarr2可以知道，return之后的会默认最小数据类型，比如小于255的就默认为uint8类型， return \[1,2,3\]就默认uint8，return \[256,2,3\]就默认uint16等等，然而returns（）里面的uint默认为uint256，所以报错，需注意  
2.可以通过对return里面任意一个数值来进行强制转换来改变数据类型  
3.可以直接接受参数来进行计算

pragma solidity ^0.4.0;
    
    contract finaltest{
        function getarr1() public view returns(uint[3]){
        //    return [1,2,3];  报错，此处为uint8，而需要返回的是uint256
        }
        function getarr2() public view returns(uint[3]){
        //    return [256,2,3];报错，此处为uint16，而需要返回的是uint256
        }
        function getarr3() public view returns(uint8[3]){
            return [1,2,3];    //成功
        }
        function getarr4() public view returns(uint16[3]){
            return [256,2,3];  //成功
        }
        function getarr5() public view returns(uint32[3]){
            return [uint32(1),2,3]; //可以通过对return里面任意一个数值来
                                    //进行强制转换来改变数据类型
        }
        function getarr6(uint[] num) public view returns(uint){
            uint sum=0;
            for(uint i=0;i<num.length;i++){
                sum+=num[i]; //可以直接接受参数来进行计算，
               //参数需要按照格式来，此处就应该为[x1,x2,x3,x4,...,xn]
            }
            return sum;
        }
    }

[http_remix.app.hubwiz.com]: http://remix.app.hubwiz.com/
[f552f345549441dbb2bbb298241480cb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/04/79af7e17f2ce4b2d9338d073322e98eb.png
[https_blog.csdn.net_weixin_45067603_article_details_105726491]: https://blog.csdn.net/weixin_45067603/article/details/105726491
[9edfcad2fbe041f1b1afd69e7ddf00f7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/04/0744c801021c41149e1b4256762e8ef9.png
[42622dc1192040cda262b380945a89a5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/04/29d5a9f04605497f833915492e33d67d.png
[0fd7faf306714735ab21cf1c8e9a95a3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/04/3feced2947104eb8940d05cc0a25fed1.png
[1ee2e18d54ac4d6c9b3619681c225c96.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/04/1a7e8c0eb64141aabf884707150fa78b.png
[907fdfdc408f4a1ea510ed3cc8cc30fb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/04/7af83603717e43d983cc982dc5b99082.png
[d9c27ccba3c741e2b0aa0007a7cb4ecc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/04/144fdc78a09747dfb410cf4ebd8925c2.png
[a580608bedbe46ec8ab8f48ec0af7c61.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/04/746378f7cda94ee6a8b4134a1a6d0163.png
[abab011961094d7099ccccc3660722ff.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/04/e72e21959f314adb87638b712422b412.png
[https_blog.csdn.net_weixin_45067603_article_details_105751748]: https://blog.csdn.net/weixin_45067603/article/details/105751748