solidity 学习记录1

开发工具

remix

Remix - Ethereum IDE

需要下载的插件

 solidity文档

Units and Globally Available Variables — Solidity 0.8.12 documentation

helloworld

//版本号
pragma solidity ^0.4.0;

contract helloworld {
    string myName = "waston";
    
    function getName() public view returns(string){
        return myName;
    }
    function changeName(string _newName) public 
    {
        myName = _newName;
    }  
    function pureTest(string _name) public pure returns(string)
    {
        return _name;
    }
}

相关权限

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

solidity的三种修饰符

view: 可以自由调用，因为它只是“查看”区块链的状态而不改变它
pure: 也可以自由调用，既不读取也不写入区块链
payable:常常用于将代币发送给合约地址。

 bool类型及  与  或

pragma solidity ^0.4.0;
contract booleanTest{
    bool _a;
    int num1 = 100;
    int num2 = 200;
    function getBool() returns(bool){
        return _a;
    }
    function getBool2() returns(bool){
        return !_a;
    }
    function panduan() returns(bool){
        return num1==num2;
    }
    function panduan2() returns(bool){
        return num1!=num2;
    }
    // true  && false = false
    //true ||false = true
    function yu() returns(bool){
        return (num1==num2) && (num1!=num2);
    }
    function huo() returns(bool){
        return false||true;
    }
}

相关运算符

pragma solidity ^0.4.0;
contract math{
    // int uint  int可正可负   uint只能正
    uint numa=4;   
    uint numb =2;
    uint8 numc= 2;
    function add(uint a,uint b) pure public returns(uint){
        return a+b;
    }   
    function jian(uint a,uint b) pure public returns(uint){
        return a-b;
    }  
    function cheng(uint a,uint b) pure public returns(uint){
        return a*b;
    }  
    function chu(uint a,uint b) pure public returns(uint){
        return a/b;
    }  
    function yu(uint a,uint b) pure public returns(uint){
        return a%b;
    }  
    function pingfang(uint a, uint b) pure public returns(uint){
        return a**b;
    }
    uint8  a = 3;
    uint8 b = 4;
    function weiyu() view public returns(uint){
        return  a & b;
    }
     function weihuo() view  public returns(uint){
        return  a | b;
    }
    function weifan() view public returns(uint){
        return  ~a;
    }
    function yihuo() view public returns(uint){
        return  a ^ b;
    }
     function zuoyi() view public returns(uint){
        return  a << 1;
    }
     function youyi() view public returns(uint){
        return  a >> 1;
    }
    function flow() pure public returns(uint){
        uint8 mm =255;
        mm++;
        return mm;
    }
    function flow2() pure public returns(uint){
        uint8 mm =0;
       mm--;
        return mm;
    }
    // function errorTest() returns(int){
    //     int a =2;
    //     // int b=0;   不执行除0操作
    //   // return a/b;
       
    // }
    // function errorTest2() returns(int){
    //     int a =2;
    //     int b = -1;
    //     a << b;
       
    // }
    function intergerTest() returns(uint){
        uint num= (2**800+1) -2**800;
        return num;
    }
    function intergerTest2() returns(uint){
        uint num= 2/4*1000;
        return num;
    }
     function intergerTest3() returns(uint){
        uint num= 11111111111111111111111111111213123112312311231312-11111111111111111111111111111213123112312311231311;
        return num;
    }
}

solidity中的运算不管内部的过程 只要结果符合对应的变量类型即可

int表示的整型可以有负数

uint表示的整型不能有负数

相关运算符

1.& 操作数之间转换成二进制之后每位进行与运算操作（同1取1）
2.| 操作数之间转换成二进制之后每位进行或运算操作（有1取1）
3.~ 操作数转换成二进制之后每位进行取反操作（直接相反）
4.^ 操作数之间转换成二进制之后每位进行异或操作（不同取1）
5.<<操作数转换成二进制之后每位向左移动x位的操作
6.>>操作数转换成二进制之后每位向右移动x位的操作
 

字节数组

byte数组为bytes1，bytes2......bytes32，依次以八个位递增

不能字节数组改变长度

pragma solidity ^0.4.0;
contract ByteArray{
    bytes1 public num1 = 0x7a;  //0111 1010
    bytes2 public num2 = 0x7a68;  //0111 1010 0110 1000
    
   function getLength() returns(uint)
   {
       return num1.length;
   }
   function getLength2() returns(uint)
   {
       return num2.length;
   }
   function setLength(){
    //    num1.length=18;
    
   }
   bytes1 a = 0x7a;   //0111  1010
   bytes1 b = 0x68;    //0110 1000
   function bijiao() public view returns(bool){
       return a>b;
   }
    function bijiao2() public view returns(bool){
       return a>=b;
   }
    function bijiao3() public view returns(bool){
       return a<b;
   }
    function bijiao4() public view returns(bool){
       return a<=b;
   }
    function bijiao5() public view returns(bool){
       return a==b;
   }
    function bijiao6() public view returns(bool){
       return a!=b;
   }
      function weiyu() view public returns(bytes1){
        return  a & b;
    }
     function weihuo() view  public returns(bytes1){
        return  a | b;
    }
    function weifan() view public returns(bytes1){
        return  ~a;
    }
    function yihuo() view public returns(bytes1){
        return  a ^ b;
    }
     function zuoyi() view public returns(bytes1){
        return  a << 1;
    }
     function youyi() view public returns(bytes1){
        return  a >> 1;
    }
    function changeContent() public {
        num1 = 2;

    }
}

可变数组长度

pragma solidity ^0.4.0;

contract DynamicByte{
    bytes public name = new bytes(2);
    function initName(){
        name[0] = 0x7a;
        name[1] = 0x68;
    }
    function getLength() view returns(uint){
        return name.length;
    }
     function changeName(){
        name[0] = 0x88;
       
    }
    function changeLength(){
    
        name.length=5;
    }
    function pushtest(){
        name.push(0x99);
    
    }
}