solidity数据类型 external internal view pure enum struct mapping

1 基础运算
1.1 三目运算符

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0;
contract threeEyeTest{
    function tete(bool acc) public pure returns(string memory){
        return acc?"one":"two";
    }
}

1.2 循环

支持for(){}、while(){}、do{}while();
使用continue中断本次循环
使用break中断直接退出循环

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0;
contract forTest{
    function addNum()public pure returns(uint256){
        uint256 res=0;
        for(uint8 i=0;i<=100;i++){
            res+=i;
        }
        return res;
    }
    function whileTest()public pure returns(uint256){
        uint16 res=0;
        uint8 i=0;
        while(i<=5){
            res+=i;
            i++;
        }
        return res;
    }
    function dowhileTest()public pure returns(uint256){
        uint16 res=0;
        uint8 i=0;
        do{
            res+=i;
            i++;
        }while(i<=100);
        return res;
    }
}

1.3 判断语句

支持if(){}else{} 分支判断

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0;
contract ifelseTest{
    uint256 num;
    function setArg(uint256 nu)public {
        num=nu;
    }
    function getArg()public view returns (string memory _score){
    if(num<60){
        _score="C";
    }else if(num>=60 && num<90){
        _score="B";
    }else{
        _score="A";
        }
        return _score;
    }
}

1.4 自增运算

solidity定义数组 与 前置或后置++

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0;
contract operationContract{
    uint8 [5]arr=[1,2,3,4,5];
    function prefieTest()public view returns (uint8){
        uint8 index=0;
        return arr[++index];
    }
    function postfieTest()public view returns (uint8){
        uint8 index=0;
        return arr[index++];
    }
}

2 external 修饰的方法

external外部函数是合约接口的一部分，可以从其它合约通过交易调用
调用需要通过this关键字

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0;
contract externalTest{
    uint8 id;
    function setId(uint8 newId)public{
        id=newId;
    }
    function getId()public view returns(uint8){
        //return id;
        //external函数的调用需要this
        return this.getIdByexternal();
    }
    function getIdByexternal()external view returns(uint8){
        return id;
    }
}
contract subInternalTest is externalTest{
    function getexternalId()public view returns(uint8){
        //return id;
        return this.getIdByexternal();
    }
}

3 internal修饰的方法

internal内部函数只能通过内部访问 或者在继承的合约内访问
调用internal方法不用加this

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0;
contract internalFuncTest{
    uint8 internal id;//state-values default keywords is internal
    function setId(uint8 newId)public{
        id=newId;
    }
    function getId()public view returns(uint8){
        //return id; //输出一致 调用internal函数不用加this
        return fetchId();
    }
    //internal keywords could be inherited 
    function fetchId()internal view returns(uint8){
        return id;
    }
}
contract subInternalFuncTest is internalFuncTest{
    function getsubId()public view returns(uint8){
        return id;
    }
    
    function sunFetch()public view returns(uint8){
        //uint8 res = fetchId(); //internal function could be called but will not displayed in page
        //继承的函数也可以调用internal 函数
        return fetchId();
    }
}

4 private修饰的方法

private 私有函数仅在当前合约内访问，在继承的合约中不可访问
private是权限最小的修饰符

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0;
contract privateFuncTest{
    uint8 private id;
    function setId(uint8 newId)public{
        id=newId;
    }
    //private修饰的方法可以通过内部调用 在继承的方法中不可调用
    function getId()public view returns(uint8){
       // return id;   //两个返回的数据一致
       return fetchId();
    }
    function fetchId()private view returns(uint8){
       return id;
    }
}
contract subPrivataTest is privateFuncTest{
    function getPriId()public view returns(uint8){
        return getId();
        //return id;  //编译出错
        //return fetchId();//编译出错  private方法无法在继承的合约中访问
    }
}

5 字面量

字符串字面量 由""包裹的字符串
支持的转义字符 \x表示16进制 最高位应为0 所以最大值为\x7F
\u表示unicode字节码

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0;
contract stringLiteralcontract{
    string public A="\x41";//16 index \x41=4*16+1=65
    string public uni="\u4e2d";//output chinese language zhong
    function getNUm()public view returns(uint8){
    return uint8(bytes(A)[0]);
     }   
}

十六进制字面量
\x表示16进制的一个字节 hex()可以表示多个字节

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0;
contract hexTest{
    string public hexte=hex"7A7B7C7D7E7F70";
    function getHex()public view returns(uint8 _7a,uint8 _7b){
        bytes memory b = bytes(hexte);
        _7a=uint8(b[0]);
        _7b=uint8(b[1]);
    }
}

有理数字面量
solidity可以初始化整型变量 涉及小数乘除的最终结果需要是整型
不能整除的数无法强制转换成int类型

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0;
contract rationalLiteralTest{
    //通过public关键字的getter()函数获取变量值
    uint8 public num=1;
    //uint8 retionNum=0.1;///compoil failure 
    uint8 public res=0.5*8+1.5*4;//compoil success only when res is a intenger num
    uint public ress=8/0.5;
}

6枚举类型

枚举值的初始化定义使用enum关键字 不加；
枚举值的获取是通过index获取 枚举类型的对应关系是从0开始的 0，1，2，3…

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0;
contract enumTest{
    enum Level  { A, B, C}//enum keywords without ; 
    function getLevel(Level level)public view returns(string memory){
        if(level == Level.A){//inuput is uint8 level input is index of enum
            return "A";
        }else if (level==Level.B){
            return "B";
        }else if(level==Level.C){
            return "C";
        }else{
            return "wtf";
        }
    }
    function getALevel() public view returns(uint){
        return uint(Level.A);
    }
}

合约结果

7 mapping类型

mapping(key=>value)
key的类型为：除了mapping、动态数组、合约、枚举、结构体
value可以是任意类型
在取键值的时候，如果键值不存在，那么获取到的就是0或者值类型的默认值

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0;
contract mappingTest{
    mapping(uint8=>string) public idName;
    constructor(){
        idName[0]="a";
        idName[1]="b";
        idName[2]="c";
        idName[3]="d";
    }
    struct stutt{
    string name;
    uint8 age;
  }
  //映射为结构体
  mapping(uint => stutt) public structMapping;
  mapping(address => stutt) public addrMapping;
  //value也是mapping类型
  mapping(string => mapping(uint => stutt)) public complexMapping;
  
  mapping(uint => uint) public intMapp;
  mapping(uint => mapping(uint => string)) public mapMapp;
 
  function sett()public{
    intMapp[1] = 100;
    //value也是mapping类型的赋值
    mapMapp[2][2] = "aaa";
  }
}

合约结果：

8 struct结构体

结构体中初始化不用new关键字

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0;
contract structTest{
    struct Student{
        uint8 id;
        string name;
    }
    Student public  tom; //public keywords has default getter function
    //public方法自动生成元素的getter方法
    Student public jack;
    constructor(){
    //结构体的初始化
        tom=Student(1,"tom");//init struct object without
        jack=Student({id:2,name:"jack"});
    }
    function getTomId()public view returns(uint8){
        return tom.id;
    }
    function getJackName()public view returns(string memory){
        return jack.name;
    }
    function getTom()public view returns(Student memory){
        return tom;
    }
    function getJack()internal view returns(Student memory){//internal function not display in the deploy page
    //internal修饰的方法只能通过内部访问，或者在继承的合约中调用 不会显示在deploy后的合约ABI中
        return jack;
    }
    function getJackByExternal()external view returns(Student memory){
        return jack;
    }
    function externamTest() public view returns(Student memory){
    //external 外部修饰的外部方法 不需使用this进行调用 也可以从其它合约通过交易发起调用
      // return this.getJackByExternal(); //external function must be called by this
      return getJack();
    }
    // function structArgs(Student memory st)public view returns(Student memory){
    //   st=tom;
    //     return st;
    // }
}

合约效果：