solidity_入门2

solidity的数组操作

pragma solidity ^0.4.16;
contract byteschange{
    
    
    // 固定长度的数组变换，如bytes1-bytes128
    bytes10 testword = 0x68656c6c6f776f726c64; //helloworld
    function tantest1() public view returns (bytes1){
        return bytes1(testword);
    }
    function tantest2() public view returns (bytes5){
        return bytes5(testword);
    }
    function tantest3() public view returns(bytes15){
        return bytes15(testword);
    }
    
    
    
    
    
    
    //固定长度的数组转换成可变长度的数组。bytes test = new bytes;
    
    bytes tanarr = new bytes(testword.length);
    uint public len = testword.length;
    function tanarrtest() public view returns(bytes){
        for(uint i=0;i<testword.length;i++){
            tanarr.push(testword[i]);
        }
        
        return tanarr;
    }
    function tanarrtest1() public view returns(bytes){
        for(uint i=0;i<testword.length;i++){
            tanarr[i]=testword[i];
        }
        
        return tanarr;
    }
    
    
    
    
    
    //可变长度的数组转换为string类型
    function tanarrtest2() public view returns(string){
        for(uint i=0;i<testword.length;i++){
            tanarr[i]=testword[i];
        }
        
        return string(tanarr);
    }
    bytes stringtest = new bytes(2);
    function setvalue() public {
        stringtest[0]=0x68;
        stringtest[1]=0x4d;
    }
    function seearr() public view returns(string){
        return string(stringtest);
    }
    
    
    
    
    
    //固定长度的数组转化为string类型
    //先将固定长度的数组转换为可变长度的数组，再将可变长度的数组转换为string类型
    
    //bytes10 testword = 0x68656c6c6f776f726c64; //helloworld
    function transferstring() public view returns(string){
        bytes memory _string = new bytes(testword.length);
        for(uint i=0;i<testword.length;i++){
            _string[i]=testword[i];
        }
        return string(_string);
    }
    //这里不知道是不是版本问题，函数的参数是强类型，而且不会强制转换，也就是必须传入bytes3的数据。
    function intransferstring(bytes3 _still) public view returns(string){
        uint count=0;
        for(uint i=0;i<_still.length;i++){
    
            if(_still[i]!=0x00){
                count++;
            }
        }
        bytes memory _string = new bytes(count);
        for(uint j=0;j<count;j++){
            _string[j]=_still[j];
        }
        
        return string(_string);
    }
    
    
    
    
    
    
    
    //solidity的数组，一维数组，以为变长数组
    //如果不赋值，那么默认所有位均为0
    uint[3] _arr1 = [1,2,3];
    uint[3] _arr2;
    function showarr() public view returns(uint[3]){
        return _arr2;
    }
    function showarr1() public view returns(uint[3]){
        return _arr1;
    }
    //进行赋值操作
    function initarr()   public{
        _arr2[0]=12;  
    }
    //solidity支持直接查看数组长度
    function lengthtest() public view returns(uint){
        return _arr1.length;     
    }
    
    function changelengthtest() public view returns(uint){
        //testarr1.length=testarr1.length+3;//solidity不支持直接修改数组长度
    }
    
    function pushtest() public view {
        //testarr2.push(2);//solidity不支持直接push数据到数组
    }
    
    
    
    
    //可变长度的数组
    uint[] _arr3=[1,2,3,4,5];
    function showarr3() public view returns(uint[]){
        return _arr3;
    }
     function changearr3() public{
        //for(uint i=0;i<5;i++){
            _arr3[0] = 2;//如果不使0位有值，那么该函数无用
        //}
    }
    
    function _arr3length() public view returns(uint){
        return _arr3.length;
    }
    
    function changelengtharr3() public{
        _arr3.length=1;
    }
    
    function _changelengtharr3() public{
       _arr3.length=10;//变长之_arr3后后面默认置0
    }
    
    function _arr3pushtest() public{
        _arr3.push(6);//可变数组支持此操作
    }
    
    
    
    
    

}

pragma solidity ^0.4.16;

//初始化时，uint[ i ] [ j ]表示有j个元素，每个元素包含i个值（和其他许多语言不同）
//二维数组可以直接获取长度，既可以获得所有元素个数，也可以获得单独元素有多少值
//对二维数组进行增删改等操作时时是与初始化时反过来的，即uint[ i ] [ j ]表示第i个元素的第j个值（和其他许多语言一样）

contract arr{
    uint[2][3] testarr = [[1,3],[2,4],[5,6]];
    function showlength() public view returns(uint){
        return testarr.length;
    }
    function showlength1() public view returns(uint){
        return testarr[1].length;
    }
    function changevalue() public {
        testarr[1][0] = 22;
        testarr[1][0] = 33;
    }
    function returnvalue() public view returns(uint[2][3]){
        return testarr;
    }
    function sunvalue() public view returns(uint){
        uint sum=0;
        for(uint i = 0;i<testarr.length;i++)
            for(uint j=0;i<testarr[0].length;j++){
                sum += testarr[i][j];
            }
            return sum;
    }
    
    
    
    
// 动态长度二位数组（不知道在哪看的=老是说成可变长度二维数组，淦
    uint[][]  testarr2 = [[1,2],[3,4]];
    function showlength2() public view returns (uint){
        return testarr2.length;
    }
    function showlength3() public view returns (uint){
        return testarr2[0].length;
    }
    
    //目前不支持这个动态二维数组作为参数返回
    /*function showall() public view returns(uint[][]){
           return testarr2;
    } */
    function inittest() public{
          //testarr1[0][3]=7;
         testarr2[0][1]=7; //未声明的值仍然不支持直接赋值
        // testarr2[0][3]=8;
          //testarr1.push(7,8);
    }
    // 动态数组改变长度可以直接通过给长度赋值来改变长度
    //不支持过push来增加长度
    /*function pushdata() public view returns (uint[][]){
        testarr2[0].push(99);
        return testarr2;
    } */
    
    
    //数组字面量   ？其实我也不知道这是啥意思
    function getarr1() public view returns(uint[3]){
       // return [1,2,3];  //返回值自动匹配类型，1,2,3均为 uint8；
    }
    function getarr2() public view returns(uint8[3]){
    //    return [1,2,3];报错，此处为uint16，而需要返回的是uint256
    }
    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;
    }
    
}