solidity 学习记录2

string类型整理

pragma solidity ^0.4.0;
contract DynamicString{
    string name = "wanshitong";
    string name2= "123!@#!@#";
    string name3 = "万事通";
    function getLength()  view returns(uint){
        return bytes(name).length;
    }
    //特殊字符占一个字节
    function getLength2() view public returns(uint){
        return bytes(name2).length;
    }
    //一个中文占三个字节
    function getLength3() view public returns(uint){
        return bytes(name3).length;
    }
    //可以查看中文特殊字符  其他语言的所储存的字节类型
    function getChineseName() view public returns(bytes){
        return bytes(name3);
    }
    function changeName() view returns(bytes1){
        // return name[0];
         return bytes(name)[2];
    }
    //0x77616e736869746f6e67
    function getName() view returns(bytes){
        return bytes(name);
    }
    function changeName2() {
        // return name[0];
        bytes(name)[0] = 'L';
    }
}

字符串特性：

1. 获取字符串长度需要先将字符串转化为字节数组后再获取字节数组的长度
2. 直接修改字符串的内容会报错要将字符转化为字节数组后才能修改
3. string类型中字母和特殊字符占两个字节，中文占三个字节

将字节数组转化为字符串

pragma solidity ^0.4.0;
contract BytesToString{
    // bytes name = new bytes(2);  //'yh'
    // function init(){
    //     name[0] = 0x79;
    //     name[1] = 0x68;

    // }
    // function bytesToString() view public returns(string){
    //     return string(name);
    // }
    bytes2 name = 0x7a68;
    function changeString() returns(string){
        // return string(name);
    }
    // function bytes32ToString(bytes2 _newName) view public returns(string){
    //     bytes memory newname = new bytes(_newName.length);
    //     for(uint i = 0; i<_newName.length;i++){
    //         newname[i] =_newName[i];
    //     }
    //     return string(newname);
    // }
      function bytes32ToString(bytes _newName) view public returns(string){
          //0x7a68
        uint count=0;
        for(uint i = 0; i<_newName.length;i++){
            bytes1 char = _newName[i];
            if(char!=0){
                count++;
            }
        }
        bytes memory newname = new bytes(count);
        for(uint j=0; j<count;j++){
            newname[j] = _newName[j];
        }
        return string(newname);
    }
}

将固定长度的字节转化为字符串不能直接强制转化，需要先获取到字符串的长度再通过for循环动态地组合成动态字符数组，再将字符数组转化为字符串

固定长度数组

pragma solidity ^0.4.0;
contract fixArray{
    uint[5]  arr = [1,2,3,4,5];
    function init(){
        arr[0] = 100;
        arr[1] = 200;
    }
    function getArrayContent() view public returns(uint[5]){
    
        return arr;
    }
    function getGrade() view public returns (uint){
        uint grade = 0;
        for(uint i=0;i<arr.length;i++){
            grade += arr[i];
        }
        return grade;
    }
    //能够获取固定数组的长度  不能修改  没有push方法
    function getLength() view public returns(uint){
        return arr.length;
    }
    // function changeLength() view public {
    //        //arr.length=3;
    // }
}

1.  固定长度的数组长度只能获取不能修改
2. 没有push方法
3. 如果不赋值，那么默认所有位均为0

动态数组

pragma solidity ^0.4.0;
contract dynamicArray{
    //可变长度数组定义和初始化
    uint[] grade = [1,2,3,4,5];
    //获取动态数组
    function getContent()view public  returns(uint[]){
        return grade;
    }
    //获取长度
    function getLength() view public returns(uint){
        return grade.length;
    }
    //修改数组内容
    function changeContent() public
    {
        grade[0] = 100;
        grade[1] = 200;
    }
    //相加
    function add() view public returns(uint){
        uint count=0;
        for(uint i=0;i<grade.length;i++){
            count+=grade[i];
        }
        return count;
    }
    //动态数组与固定数组的差别   更改长度
    function changeLength() public
    {
        grade.length=1;
    }
    function changeLength2() public
    {
        grade.length = 10;
    }
    //新添加数据
    function pushContent(uint a) public
    {
        grade.push(a);
    }
}

动态数组的长度可以修改，新增的位置默认为0

 固定长度的二维数组

pragma solidity ^0.4.0;
contract twoArray{
    //3个数组  每个数组有2项 与其他语言定义不同 
    uint[2][3] grade = [[1,2],[3,4],[5,6]];
    function getoneLength() view public returns(uint){
        return grade.length;
    } 
    function getTwoLength() view public returns(uint)
    {
           return grade[0].length; 
    }
    function getContent() view public returns(uint [2][3])
    {
    
        return grade;
    }
    //获取数组与其他语言相同
    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(uint i,uint j,uint v)  public returns(uint [2][3]){
        grade[i][j] = v;
        return grade;
    }
    function changeOneLength(){
        //不能修改长度

    }     
}

1. 定义的二维数组的时候与其他语言不相同，第一项为每个数组的元素数量，第二项为数组的数量 
2. 固定的数组不能修改长度
3. 获取数组的时候与其他语言获取二维数组的方式相同

动态二维数组 

pragma solidity ^0.4.0;
contract dynamicTwoArray{
    uint[][] grade = [[1,2],[3,4],[5,6]];
    //目前动态数组不能作为返回值
    // function getContent() returns(uint[][])
    // {
    //     return grade;
    // }
    function changeLength() public
    {
        grade.length=10;
    }
     function changeLength2() public
    {
        grade[0].length=10;
    }
    function getLength() public  view returns(uint)
    {
        return grade.length;
    }
    function getLength2() public view returns(uint){
        return grade[0].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(){
        grade [0][0]=100;
    }
    function getContent() view public returns(uint){
        return grade[0][0];
    }
}

1.  目前动态数组不支持作为函数的返回值
2. 长度可以修改和获取
3. 不支持push方法
4. 不能直接向未声明的值赋值，修改长度后才能赋值

数组 字面量

pragma solidity ^0.4.0;
contract arrayLiterals{
//字面量会自动的进行推断 ，推断出我们数组字面量里面储存的是什么类型  其原则是最小类型
//   function getArrayLiterals1() returns(uint[3])
//     {   
//         //solidity 
//         return [1,2,3];
//     }

    function getArrayLiterals() returns(uint8[3])
    {   
        //solidity 
        return [1,2,3];
    }
    //可以强制转化为相对应的参数
    function getArrayLiterals2() returns(uint[3])
    {   
        //solidity 
        return [uint(1),2,3];
    }
    //字面量最大的作用是放在函数的参数列表中
    function getArrayLiterals6(uint[3] grade) view public returns(uint){
        uint sum=0;
        for(uint i=0;i<grade.length;i++)
        {
            sum+=grade[i];
        }
        return sum;
    }

}