1
// 固定长度为2的静态数组定义
2
uint[2] fixedArray;
3
//定长数组实例化
4
fixedArray = [4, 6];

1
//声明
2
uint[] dynamicArray;
3
//初始化，这里实例化一个长度为2的数组，值为0。
4
dynamicArray = new uint[](2);

1
// SPDX-License-Identifier: MIT
2
pragma solidity ^0.8.9;
3

4
library Array {
5
    function push(uint256[] memory _nums, uint256 _num) internal pure {
6
        assembly {
7
            // 在可变数组的 末尾追加 一个value (_num)
8
            mstore(add(_nums, mul(add(mload(_nums), 1), 0x20)), _num)
9

10
            // 可变数组的length 加 1
11
            mstore(_nums, add(mload(_nums), 1))
12

13
            // 0x40 是空闲内存指针的预定义位置 (value 为 空闲指针开始位)
14
            mstore(0x40, add(mload(0x40), 0x20))
15
        }
16
    }
17

18
    function pop(uint256[] memory _nums) internal pure returns (uint256 num_) {
19
        assembly {
20
            // 取出可变数组的最后一个value
21
            num_ := mload(add(_nums, mul(mload(_nums), 0x20)))
22
            // length - 1
23
            mstore(_nums, sub(mload(_nums), 1))
24
        }
25
    }
26

27
    function del(uint256[] memory _nums, uint256 _index) internal pure {
28
        assembly {
29
            // 下标位置需 小于 数组.length
30
            if lt(_index, mload(_nums)) {
31
                // 将最后一个value 移到 _index 下标处
32
                mstore(
33
                    add(_nums, mul(add(_index, 1), 0x20)),
34
                    mload(add(_nums, mul(mload(_nums), 0x20)))
35
                )
36
                // length - 1
37
                mstore(_nums, sub(mload(_nums), 1))
38
            }
39
        }
40
    }
41

42
    function update(
43
        uint256[] memory _nums,
44
        uint256 _index,
45
        uint256 _num
46
    ) internal pure {
47
        _nums[_index] = _num;
48
    }
49

50
    function get(uint256[] memory _nums, uint256 _index)
51
        internal
52
        pure
53
        returns (uint256)
54
    {
55
        return _nums[_index];
56
    }
57
}
58

59
contract testArr {
60
    using Array for uint256[];
61

62
    function push(uint256[] memory _nums, uint256 num)
63
        external
64
        pure
65
        returns (uint256[] memory)
66
    {
67
        _nums.push(num);
68
        return _nums;
69
    }
70

71
    function pop(uint256[] memory _nums)
72
        external
73
        pure
74
        returns (uint256[] memory, uint256)
75
    {
76
        uint256 num_ = _nums.pop();
77
        return (_nums, num_);
78
    }
79

80
    function del(uint256[] memory _nums, uint256 _index)
81
        external
82
        pure
83
        returns (uint256[] memory)
84
    {
85
        _nums.del(_index);
86
        return _nums;
87
    }
88

89
    function update(
90
        uint256[] memory _nums,
91
        uint256 _index,
92
        uint256 _num
93
    ) external pure returns (uint256[] memory) {
94
        _nums.update(_index, _num);
95
        return _nums;
96
    }
97

98
    function get(uint256[] memory _nums, uint256 _index)
99
        external
100
        pure
101
        returns (uint256)
102
    {
103
        return _nums.get(_index);
104
    }
105
}