加入public自动返回get

bytes  length方法 ， string无length属性，可先转回bytes

bytes  push方法

 修改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]; //查看第一位是否被修改
    }
    
}

 String类型中中文按utf-8存储占3个字节

字节数组可以进行大小比较

pragma solidity ^0.4.0;

contract helloworld {
    bytes1 public num1 = 0x12;  
    bytes4 public num2 = 0x12121212;
    uint8 num3 = 0x12;
    uint8 num4 = 12;
    function compare1() public view returns(bool){
        return num1<num2;
    }
    function compare2() public view returns(bool){
        return num1>num2;
    }
    function compare3() public view returns(bool){
        //return num1>num3;不管是16进制还是二进制，编译器都会报错，
        //return num1>num4;说明无法进行byte和int之间的比较
    }
}

说明无法进行byte和int之间的比较

将固定长度数组变为可变长度数组 

contract arrtranstest{
    bytes10 testword=0x68656c6c6f776f726c64;
    bytes transarr = new bytes(testword.length);
    
    function setvalue() public {
       for(uint i=0;i<testword.length;i++){
           transarr[i]=testword[i];
        }
    }
    function showtransarr() public view returns(bytes){
        return transarr;
    }
}

 将可变长度字节数组bytes转化为可以显示字符的string

contract bytestostring{
    bytes testword = new bytes(10);
    
    function setvalue() public {
       testword.push(0x68);
       testword.push(0x4d);
    }
    function showtransarr() public view returns(string){
        return string(testword);
    }
}

将固定长度字节数组转化为string类型

contract bytes32tostring{
    bytes10 testword=0x68656c6c6f776f726c64; //为helloworld
    
    function bytes32tostringF() public view returns(string){
        uint count=0; //这里必须初始为uint，否则报错
    for(uint i=0;i<testword.length;i++){
        bytes1 tester=testword[i];
        if(tester!=0x00){//此步计算出所有不为空值的位数
            count++;
        }
    }
    bytes memory transarr=new bytes(count);//声明一个新的可变数组，长度为之前的count，
                                           //这样就不会导致转化后后面过多的方框了
    for(uint j=0;j<count;j++){//重新对可变数组进行赋值
        transarr[j]=testword[j];      
    }
    return string(transarr);//强制转化即可
    }
}

 固定长度数组

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

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数据到数组
    }
    
}

 可变长度二维数组

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

contract dynamicdoublearrtest{
    uint[][] testarr1=[[1,2],[3,4],[5,6]];
    function changevalue() public{
        testarr1[0][1]=10;
        testarr1[2][0]=200;
        
    }
    
    //function showall() public view returns(uint[][]){
    //       return testarr1;
    //}
    
    //function pushtest() public{
           //testarr1.push([7,8]);
           //testarr1.push(7,8);
    
    function inittest() public{
           //testarr1[0][3]=7;
          testarr1[0][2]=7; //未声明的值仍然不支持直接赋值
          testarr1[0][3]=8;
           //testarr1.push(7,8);
    }
    
   function initvalue1() public view returns(uint){
       return testarr1[0][2];
    }
    
   function initvalue2() public view returns(uint){
       return testarr1[0][3];
   }
    
    
    function getsum() public view returns (uint){
        uint sum=0;
        for(uint i=0;i<testarr1.length;i++){
            for(uint j=0;j<testarr1[i].length;j++){
                sum+=testarr1[i][j];
            }
        }
        return sum;
    }
    
    function changelengthtest1() public{
        testarr1.length=5;
    }
    
    function changelengthtest2() public{
        testarr1[0].length=5;
    }
    
    function getlength1() public view returns(uint){
        return testarr1.length;
    }
    
    function getlength2() public view  returns(uint){
        return testarr1[0].length;
    }
    
    function getdefaultvalue() public view  returns(uint){
        return testarr1[0][4];
    }
}

数组字面量

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;
    }
}

标签：function,return,Solidity,笔记,语法结构,returns,uint,public,view
来源： https://blog.csdn.net/vacatin/article/details/121936838