Solidity---数据存储

view读取状态变量不能修改；
pure修饰的函数不能改也不能读取；
不消耗燃料；
1.固定长度字符数组
字节数据类型中 对变量加上 public
例如 bytes1 public num = 0x7a;
则就会自动生成一个get方法 不消耗gas

bytes长度不能被修改

2.动态数组

pragma solidity ^0.5.0; 
contract DynamicByte{
    
    bytes public name = new bytes(2);//2个字节大小
    bytes public arr = new bytes(3);//3个字节大小
    function InitName()public {
        
        name[0] = 0x7a;//一个字节为8位  即2个十六进制数
        name[1] = 0x68;
        arr[0] = 0x7a;
        arr[1] = 0x7a;
        arr[2] = 0x7a;
        
    }
    function getlength() public view returns(uint)
    {
        return name.length;
    }
    function getlength2() public view returns(uint)
    {
        return arr.length;//长度  字节数
    }
    function pushtest() public
    {
        name.push(0x88);//向后添加  输出 0x7a6888
    }
     function changeName()public
    {
        name[0] = 0x88;//也可修改数组内容 
    }
    function changeLength() public
    {
        arr.length = 5;//改变数组的长度  向后添加 输出 0x7a7a7a0000
    }
    
}

获取数组中单个元素
注意：string中没有length这个属性 不能直接.length获取字符数组的长度

pragma solidity ^0.5.0;

contract DyString{
    
    
    string name = 'zhangshan';
    function getLength()view public returns (uint)
    {
        //return name.length; //error  不能直接获取string的长度
        
        return bytes(name).length;//通过bytes类型转换
    }
     
}

pragma solidity ^0.5.0;

contract DyString{
    
    
    string name = 'zhangshan';//0x7a68616e677368616e zhangsan的十六进制
    function getLength() view public returns (uint)
    {
        //return name.length; //error
        
        return bytes(name).length;
    }
    
 function getname()view public  returns (bytes memory )
    {
        //memory  版本号0.5.0 在进行值传递时要加上 memory否则会报错  
        return bytes(name);//获取到字符串的十六进制
    }
    
    
    function getNamesingle() view public returns(bytes1)
    {
       // return name[0];//error  不能直接通过下标获取string中的内容
      return bytes(name)[1];//获取到 string中第二位的h 表示的两位十六进制数
    }
    
    function changeName() public 
    {
        bytes(name)[0] ='A';//修改string中 第一位
    }
    

修改 成功

3.string 中中文 特殊字符 存储

pragma solidity ^0.5.0;

contract DyString{
    
    
  
    string name1 = 'fuhesjdhe243@$#@%%^%';//分别占1个字节 0x66756865736a6468653234334024234025255e25
    
    string name2 = '张三';//中文一个字占3个字节
    
    string name3 = '张大头';//0xe5bca0e5a4a7e5a4b4
    function getLength() view public returns (uint)
    {
        
        
        return bytes(name1).length;
    }
    
   function getLength1() view public returns (uint)
    {
        
        
        return bytes(name2).length;
    }
     function getLength2() view public returns (uint)
    {
        
        
        return bytes(name3).length;
    }
    function getCname()view public  returns (bytes memory )
    {
        return bytes(name3);// 获取中文十六进制数
    }
    
    
   
    
}

4.固定长度字节数组转换

pragma solidity ^0.5.0;


contract changeByte
{
    bytes8 name = 0xabcd123456781234;
    
    function changeByte1() view public returns(bytes1)
    {
        return bytes1(name);
    }
    
    
    function changeByte2()view public  returns(bytes16)
    {
        return bytes16(name);//后面补零
    }
    
    function changeByte3()view public returns(bytes2)
    {
        return bytes2(name);//前面截取2个字节
    }

}

5.固定长度字符串变为可变长度字符串

pragma solidity ^0.5.0;


contract changeByte
{
    bytes6 name =  0xe5bca0e4b889;//张三的十六进制数
 
    function fixBytesToDynamicBytes() view public returns(bytes memory)
    {
        
        bytes memory  newName = new bytes(name.length);
        for(uint i = 0; i < name.length; i++)
        {
            newName[i] = name[i];
        }
        return newName;//bytes6类型转换为bytes
    }
}

6.动态数组bytes转换为string

pragma solidity ^0.4.0;
contract bytestostring
{
    bytes  name = new bytes(2);
    
    function Inint() public
    {
        name[0] = 0x7a;//'zhangshan'十六进制数0x7a68616e677368616e
        name[1] = 0x68;// 0x7a 0x68分别为 z h
    }
    
    function bytesTostring() view public returns(string memory)
    {
        return string (name);
        
    }
    
}

注意：
1、bytes的初始化 —new bytes获取bytes的长度，内容，并修改长度；
2、string—不能直接获取长度和内容，需要转换为bytes；
3、固定长度字节数组之间的相互转换；
4、固定长度字节数组 --转换为bytes可变长度数组；
5、将bytes转化为string；
6、将byte32 等固定的字节数组转化为string；

pragma solidity ^0.4.0;

contract byteNumToString
{
    
    bytes2 name = 0x7a68;
    function bytenumTostring() view public returns (string)
    {
        
        //return string(name); //error
    
    }

     function bytesNToString(bytes32 _newname) view public returns(string)
    {
        //bytes2 _newname 可以换成 bytes6 bytes32等固定字符数组
        bytes memory newName = new bytes(_newname.length);
        
        for(uint i = 0; i < _newname.length; i++)
        {
          //将i初始化为0 
        //判断i是否小于  i<2 _newname的长度
        //将newname[0] = _newname[0]将_newname中的值赋值给newname
        //同样之后 i+1  判断满足条件之后 将newname[1] = _newname[1]
        //·········
        //循环不满足 i< 2之后退出for循环
        // newname = 0x7a68
            newName[i] = _newname[i];
        }
        //将_newname完全拷贝到新的字符数组中去
        return string(newName);
    }
}

function bytesNToString1(bytes32 _newname) view public returns(string)
    {
        uint count = 0;
        
        for(uint i = 0; i < _newname.length; i++)
        { 
            bytes1 char = _newname[i];
            if(char != 0x00)
            {
                count++;//count统计有效字符长度  
            }
           
        }
        
        bytes memory newName = new bytes(count);
         for(uint j = 0; j < count; j++)
        {
            newName[j] = _newname[j];
        }
        
        return string(newName);
    }

7.固定数组

pragma solidity ^0.4.0;
contract fixArray{
    
    uint[5] arr;//未赋值时默认全为0
    uint[5] arr1 = [1,2,3];//定义并初始化数组
    function Init() public
    {
        arr[0] = 199;
        arr[1] = 200;
    }
    
    function getArr() view public returns(uint[5])
    {
        return arr;
    }
    function getArr1() view public returns(uint[5])
    {
        return arr1;
    }
    
    function Intarr()public
    {
        arr[0] = 256;//可以对数组中的数进行修改 
        arr[3] = 253;
    }
    function lengthtest() public view returns(uint)
    {
        return arr1.length;//获取长度
    }
       function lengthup()public view returns(uint)
    {
        //return arr.length = 10;//不能修改固定数组的长度
    }
    
    function pusharr()public view returns (uint)
    {
        //arr.push(2);//固定数组没有push方法
    }
    
    function getGrade() view public returns(uint)
    {
        uint grade = 0;
        for(uint i=0;i<5;i++)
        {
            //grade = grade +arr[i];//数组元素相加
            grade += arr[i];
        }
        return grade;
        
    }
    
    
    
    
    
}

8.动态数组
动态数组：在声明时没有预定大小的数组，它的大小是在运行时确定的。
int[] age;
bytes[] grade;
动态数组可以内联初始化或者使用new运算符初始化。可以在声明时初始化：
int[] age = [int(10),20,30,40,50]; int[] age = new int[](5) ;
也可以分两步初始化：

int [] age;
age = new int[ ](10);

pragma solidity ^0.4.0;

contract dynamicarr

{
    //uint[] arrtest; //当初始状态没有赋值时，在下面赋值intarr方法中会报错 
    //动态数组的定义和初始化 bytes[]、 string[];
    uint[] arrtest = [1,2,3,4];
    
    function getarrtest()public view returns(uint[])
    {
        return arrtest;
    }
    
    function intarr()public
    {
        //修改数组元素
        arrtest[0] = 200;
        arrtest[1] = 300;
    }
     function getarrlength()public view returns(uint)
    {
        return arrtest.length;
    }
   //动态数组可以改变数组长度
    function addlength1()public  returns(uint)
    {
        arrtest.length = 9;
    }
     function addlength2()public  returns(uint)
    {
        arrtest.length = 2;
    }
    function pusharr()public 
    {
        arrtest.push(99);// 动态数组可以使用push方法 对数组进行增添元素 填充到数组末尾 
    }
    //数组元素求和
    function addarr()public view returns (uint)
    {
        uint sum = 0;
        for(uint i=0; i<arrtest.length; i++)
        {
            sum += arrtest[i];
            
        }
    }
    
    
}

未赋值状态：

如果要修改数组里的值，得对数组初始化时就要赋值；

addlength2方法对长度进行截取之后 里面数据永久消失

对长度进行扩大 向后填充0

push值向后填充 数组长度随之改变

9.二维数组
固定长度二维数组
在其他语言中，我们常见的二维数组，例如int[2][3]存储形式如下：

而在solidity中二维数组uint[2][3]存储形式如下：

pragma solidity ^0.4.0;

contract doublearr
{
    uint[2][3] arr = [[1,2],[3,4],[5,6]];
    function getlength() view public returns(uint)
    {
        return arr.length;//二维数组有多少个元素  后面的数3 代表有三个元素  
    }
    function getdoublelength()view public returns(uint)
    {
        return arr[0].length;//元素里有多少个数据  前面的数2 
    }
     function getcontent()view public returns(uint[2][3])
    {
        return arr;//获取数组中内容
    }
    //将数组内元素相加
    function add() view public returns  (uint)
    {
        uint sum = 0;
        //获取元素个数
        for(uint i = 0;i<arr.length;i++)
        {
        //获取元素中的数据  并求和
        
            for(uint j=0;j<arr[0].length;j++)
            {
                sum += arr[i][j];
            }
        }
        return sum;
    }
     function changelength()public{
        //arr.length = 100;//不能修改数组长度
    }
}
//修改数组内容
function changearr() public
    {
        arr[0][1] = 10;
    }

对数组内容进行修改

    function changearr() public
    {
        arr[0][1] = 10;
    }

可变长度二维数组

pragma solidity ^0.4.0;

contract dynamicddoublearr
{
    
    uint[][] grade = [[1,2],[3,4],[5,6]];
    
    /*function getcontent()public view returns(uint[][])
    {//可变长度的二维数组不能返回值 不能更新
        return grade;
    }
    */
       function getlength()public view returns(uint)
    {
        return grade.length;
    }
    //修改元素长度
    function changelength() public
    {
        grade.length = 10;
    }
    //修改元素内容长度
    function changelength1() public
    {
        grade[1].length = 10;
    }
    function getlength1()public view returns(uint)
    {
        return grade[1].length;
    }
    //对数组内容求和
     function add() view public returns  (uint)
    {
        uint sum = 0;
        
        for(uint i = 0;i<grade.length;i++)
        {
            for(uint j=0;j<grade[0].length;j++)
            {
                sum += grade[i][j];
            }
        }
        return sum;
    }
    //修改数组内容
    function changecontent()public
    {
        grade[0][0] = 100;
    }
    //获取修改的内容
    function getchangecontent() view public returns(uint)
    {
        return grade[0][0];
    }
}

修改长度之前

修改长度后


修改内容前 求和为：

修改内容之后 求和为：


10.数组字面量

pragma solidity ^0.4.0;

contract Arraytest
{
    //保证returns()和return()中的类型一致
    function getArraytest1() view public returns(uint[3])
    {
        //return [1,2,3];
    }
    //默认状态 returns 默认为unit8  return 返回默认最小的数据类型uint16
    function getArraytest2() view public returns(uint[3])
    {
        //return [256,2,3];
    }
    //返回一个字面量就要必须要 参数返回值与函数返回值的类型一致
    function getArraytest3() view public returns(uint8[3])
    {
        return [1,2,3];
    }
    //通过对第一个元素强制转化的方式来指定字面量里面的类型
    function getArraytest4() view public returns(uint[3])
    {
        return [uint(1),2,3];
    }
    
    function getArraytest5() view returns(uint16[3])
    {
        return [256,2,3];
    }
    //字面量放在函数的参数列表中
    function getArraytest6(uint[3] grade) public view returns(uint)
    {
       uint sum = 0;
       for(uint i=0;i<grade.length;i++)
       {
           sum+=grade[i];
    
       }
       return sum;
    }
    
}