Uniswap-v2 Pair合约分析

企业开发 2022-06-02 15:00:08 阅读次数: 0

原文发布在 https://github.com/33357/smartcontract-apps这是一个面向中文社区，分析市面上智能合约应用的架构与实现的仓库。欢迎关注开源知识项目！

Uniswap-v2 Pair合约分析

Pair 合约是 Uniswap-v2 的资金池的合约，通过分析它可以深入了解 Uniswap-v2 资金池的运行逻辑。

演示代码仓库：https://github.com/33357/uniswap-v2-contract。

合约初始化

  • 公共函数（合约内外部都可以调用）
    • constructor

      • 代码速览

        constructor() public {
          
          
    factory = msg.sender;
}

      • 参数分析

        函数 constructor 的入参有0个，出参有0个。
        在合约初始化时，Pair 合约会将 msg.sender 记录为 factory 地址。

      • 实现分析

        ...
{
          
          
    // 设置 factory 地址
    factory = msg.sender;
}

      • 总结

        Pair 合约初始化时，会记录 factory 地址。

  • 外部函数（仅合约外部可以调用）
    • initialize

      • 代码速览

        function initialize(address _token0, address _token1) external {
          
          
    require(msg.sender == factory, 'UniswapV2: FORBIDDEN');
    token0 = _token0;
    token1 = _token1;
}

      • 参数分析

        函数 initialize 的入参有2个，出参有0个，对应的解释如下：

        function initialize(
    address _token0, // token0 地址
    address _token1 // token1 地址
) external {
          
          
    ...
}

        由于 create2 函数无法传参，因此需要再次调用 initialize 函数来记录 token0 和 token1 的地址。

      • 实现分析

        ...
{
          
          
    // 检查 msg.sender 地址等于 factory 地址
    require(msg.sender == factory, 'UniswapV2: FORBIDDEN');
    // 记录 token0 和 token1 地址
    token0 = _token0;
    token1 = _token1;
}

      • 总结

        由于 initialize 是初始化函数，因此只能由 factory 调用，且只会调用一次。

资金池状态

  • 公共函数（合约内外部都可以调用）
    • getReserves

      • 代码速览

        function getReserves() public view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) {
          
          
    _reserve0 = reserve0;
    _reserve1 = reserve1;
    _blockTimestampLast = blockTimestampLast;
}

      • 参数分析

        函数 getReserves 的入参有0个，出参有3个，对应的解释如下：

        function getReserves() public view returns (
    uint112 _reserve0, // token0 的资金池库存数量
    uint112 _reserve1, // token1 的资金池库存数量
    uint32 _blockTimestampLast // 上次更新库存的时间
) {
          
          
    ...
}

        函数 getReserves 返回了 _reserve0、_reserve1 和 _blockTimestampLast，通过这些变量可以计算资产的价格。

      • 实现分析

        ...
{
          
          
    // 返回 reserve0、reserve1 和 blockTimestampLast
    _reserve0 = reserve0;
    _reserve1 = reserve1;
    _blockTimestampLast = blockTimestampLast;
}

      • 总结

        方便获取当前资金池状态。

更新资金池

  • 内部函数（仅合约内部可以调用）
    • _update

      • 代码速览

        function _update(uint balance0, uint balance1, uint112 _reserve0, uint112 _reserve1) private {
          
          
    require(balance0 <= uint112(-1) && balance1 <= uint112(-1), 'UniswapV2: OVERFLOW');
    uint32 blockTimestamp = uint32(block.timestamp % 2**32);
    uint32 timeElapsed = blockTimestamp - blockTimestampLast;
    if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
          
          
        price0CumulativeLast += uint(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) * timeElapsed;
        price1CumulativeLast += uint(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) * timeElapsed;
    }
    reserve0 = uint112(balance0);
    reserve1 = uint112(balance1);
    blockTimestampLast = blockTimestamp;
    emit Sync(reserve0, reserve1);
}

      • 参数分析

        函数 _update 的入参有4个，出参有0个，对应的解释如下：

        function _update(
    uint balance0, // token0 的余额
    uint balance1, // token1 的余额
    uint112 _reserve0, // token0 的资金池库存数量
    uint112 _reserve1 // token1 的资金池库存数量
) private {
          
          
    ...
}

        函数 _update 的主要作用是对资金池的记录库存和实际余额进行匹配，保证库存和余额统一。

      • 实现分析

        ...
{
          
          
    // 需要 balance0 和 blanace1 不超过 uint112 的上限
    require(balance0 <= uint112(-1) && balance1 <= uint112(-1), 'UniswapV2: OVERFLOW');
    // blockTimestamp 只取最后 32 位
    uint32 blockTimestamp = uint32(block.timestamp % 2**32);
    // 计算时间差 timeElapsed
    uint32 timeElapsed = blockTimestamp - blockTimestampLast;
    // 如果 timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0
    if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
          
          
        // 对 _reserve1 / _reserve0 * timeElapsed 的结果在 price0CumulativeLast 上累加
        price0CumulativeLast += uint(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) * timeElapsed;
        // 对 _reserve0 / _reserve1 * timeElapsed 的结果在 price1CumulativeLast 上累加
        price1CumulativeLast += uint(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) * timeElapsed;
    }
    // reserve0 = balance0
    reserve0 = uint112(balance0);
    // reserve1 = balance1
    reserve1 = uint112(balance1);
    // blockTimestampLast = blockTimestamp
    blockTimestampLast = blockTimestamp;
    // 触发事件 Sync
    emit Sync(reserve0, reserve1);
}

      • 总结

        函数 _update 中对 price0CumulativeLast 和 price1CumulativeLast 进行了与时间成反比的数值累加，可以通过这两个变量计算出相对平衡的市场价格。

手续费

  • 内部函数（仅合约内部可以调用）
    • _mintFee

      • 代码速览

        function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) {
          
          
    address feeTo = IUniswapV2Factory(factory).feeTo();
    feeOn = feeTo != address(0);
    uint _kLast = kLast;
    if (feeOn) {
          
          
        if (_kLast != 0) {
          
          
            uint rootK = Math.sqrt(uint(_reserve0).mul(_reserve1));
            uint rootKLast = Math.sqrt(_kLast);
            if (rootK > rootKLast) {
          
          
                uint numerator = totalSupply.mul(rootK.sub(rootKLast));
                uint denominator = rootK.mul(5).add(rootKLast);
                uint liquidity = numerator / denominator;
                if (liquidity > 0) _mint(feeTo, liquidity);
            }
        }
    } else if (_kLast != 0) {
          
          
        kLast = 0;
    }
}

      • 参数分析

        函数 _mintFee 的入参有2个，出参有1个，对应的解释如下：

        function _mintFee(
    uint112 _reserve0, // token0 的资金池库存数量
    uint112 _reserve1 // token1 的资金池库存数量
) private returns (
    bool feeOn // 是否开启手续费
) {
          
          
    ...
}

        函数 _mintFee 实现了添加和移除流动性时，向 feeTo 地址发送手续费的逻辑。

      • 实现分析

        ...
{
          
          
    // 获取手续费接收地址 feeTo
    address feeTo = IUniswapV2Factory(factory).feeTo();
    // 如果 feeTo 不是全0地址，那么 feeOn = true
    feeOn = feeTo != address(0);
    // 获取 kLast
    uint _kLast = kLast;
    // 如果 feeOn == true
    if (feeOn) {
          
          
        // 如果 _kLast != 0
        if (_kLast != 0) {
          
          
            // rootK = (_reserve0*_reserve1)**2
            uint rootK = Math.sqrt(uint(_reserve0).mul(_reserve1));
            // rootKLast = _kLast**2
            uint rootKLast = Math.sqrt(_kLast);
            // 如果 rootK > rootKLast
            if (rootK > rootKLast) {
          
          
                // 这里计算逻辑不是很清楚，希望有知道的补充一下
                uint numerator = totalSupply.mul(rootK.sub(rootKLast));
                uint denominator = rootK.mul(5).add(rootKLast);
                uint liquidity = numerator / denominator;
                // 向 feeTo 地址增发数量为 liquidity 的 LP
                if (liquidity > 0) _mint(feeTo, liquidity);
            }
        }
    } else if (_kLast != 0) {
          
          
        // 如果 _kLast != 0，kLast = 0
        kLast = 0;
    }
}

      • 总结

        虽然在这里实现了向 feeTo 地址发送手续费，但是直到现在（2022年3月2日），feeTo 地址都是全0地址，也就是说没有收取任何手续费。

提供流动性

  • 外部函数（仅合约外部可以调用）
    • burn

      • 代码速览

        function mint(address to) external lock returns (uint liquidity) {
          
          
    (uint112 _reserve0, uint112 _reserve1,) = getReserves();
    uint balance0 = IERC20(token0).balanceOf(address(this));
    uint balance1 = IERC20(token1).balanceOf(address(this));
    uint amount0 = balance0.sub(_reserve0);
    uint amount1 = balance1.sub(_reserve1);
    bool feeOn = _mintFee(_reserve0, _reserve1);
    uint _totalSupply = totalSupply;
    if (_totalSupply == 0) {
          
          
        liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
    _mint(address(0), MINIMUM_LIQUIDITY);
    } else {
          
          
        liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1);
    }
    require(liquidity > 0, 'UniswapV2: INSUFFICIENT_LIQUIDITY_MINTED');
    _mint(to, liquidity);
    _update(balance0, balance1, _reserve0, _reserve1);
    if (feeOn) kLast = uint(reserve0).mul(reserve1);
    emit Mint(msg.sender, amount0, amount1);
}

      • 参数分析
        函数 mint 的入参有1个，出参有1个，对应的解释如下：

        function mint(
    address to // LP 接收地址
) external lock returns (
    uint liquidity // LP 数量
) {
          
          
    ...
}

        函数 mint 的主要作用是用户存入流动性代币，提取 LP。流动性代币在调用 mint 之前就已经存入了资金池，因此需要计算存入代币数量。

      • 实现分析

        ...
{
          
          
    // 获取记录库存 _reserve0，_reserve1
    (uint112 _reserve0, uint112 _reserve1,) = getReserves();
    // 获取代币余额 balance0，balance1
    uint balance0 = IERC20(token0).balanceOf(address(this));
    uint balance1 = IERC20(token1).balanceOf(address(this));
    // 获取用户质押余额 amount0，amount1
    uint amount0 = balance0.sub(_reserve0);
    uint amount1 = balance1.sub(_reserve1);
    // 发送手续费
    bool feeOn = _mintFee(_reserve0, _reserve1);
    uint _totalSupply = totalSupply;
    // 如果 _totalSupply == 0
    if (_totalSupply == 0) {
          
          
        // LP 代币数量 liquidity = (amount0 * amount1)**2 - MINIMUM_LIQUIDITY
        liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
        // 向全0地址发送数量为 MINIMUM_LIQUIDITY 的 LP 代币
        _mint(address(0), MINIMUM_LIQUIDITY);
    } else {
          
          
        // LP 代币数量 liquidity = min(_totalSupply * amount0 / _reserve0, _totalSupply * amount1 / _reserve1)
        liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1);
    }
    // 需要 liquidity > 0
    require(liquidity > 0, 'UniswapV2: INSUFFICIENT_LIQUIDITY_MINTED');
    // 向 to 地址发送数量为 liquidity
    _mint(to, liquidity);
    // 更新库存
    _update(balance0, balance1, _reserve0, _reserve1);
    // 如果 feeOn == true，更新 kLast
    if (feeOn) kLast = uint(reserve0).mul(reserve1);
    // 触发事件 Mint
    emit Mint(msg.sender, amount0, amount1);
}

      • 总结

        为了避免创建流动性的数值太小引发计算错误，创建流动性需要大于 MINIMUM_LIQUIDITY。

移除流动性

  • 外部函数（仅合约外部可以调用）
    • burn

      • 代码速览

        function burn(address to) external lock returns (uint amount0, uint amount1) {
          
          
    (uint112 _reserve0, uint112 _reserve1,) = getReserves();
    address _token0 = token0;
    address _token1 = token1;
    uint balance0 = IERC20(_token0).balanceOf(address(this));
    uint balance1 = IERC20(_token1).balanceOf(address(this));
    uint liquidity = balanceOf[address(this)];
    bool feeOn = _mintFee(_reserve0, _reserve1);
    uint _totalSupply = totalSupply;
    amount0 = liquidity.mul(balance0) / _totalSupply;
    amount1 = liquidity.mul(balance1) / _totalSupply;
    require(amount0 > 0 && amount1 > 0, 'UniswapV2: INSUFFICIENT_LIQUIDITY_BURNED');
    _burn(address(this), liquidity);
    _safeTransfer(_token0, to, amount0);
    _safeTransfer(_token1, to, amount1);
    balance0 = IERC20(_token0).balanceOf(address(this));
    balance1 = IERC20(_token1).balanceOf(address(this));
    _update(balance0, balance1, _reserve0, _reserve1);
    if (feeOn) kLast = uint(reserve0).mul(reserve1);
    emit Burn(msg.sender, amount0, amount1, to);
}

      • 参数分析
        函数 burn 的入参有1个，出参有2个，对应的解释如下：

        function burn(
    address to // 资产接收地址
) external lock returns (
    uint amount0, // 获得的 token0 数量
    uint amount1 // 获得的 token1 数量
) {
          
          
    ...
}

        函数 burn 的主要作用是用户销毁 LP，从资金池提取流动性代币。同样在调用 burn 之前，LP 已经发送给资金池，资金池中 LP 余额就是需要销毁的 LP 数量。

      • 实现分析

        ...
{
          
          
    // 获取记录库存 _reserve0，_reserve1
    (uint112 _reserve0, uint112 _reserve1,) = getReserves();
    // 获取 _token0，_token1
    address _token0 = token0;
    address _token1 = token1;
    // 获取代币余额 balance0，balance1
    uint balance0 = IERC20(_token0).balanceOf(address(this));
    uint balance1 = IERC20(_token1).balanceOf(address(this));
    // 获取 liquidity
    uint liquidity = balanceOf[address(this)];
    // 发送手续费
    bool feeOn = _mintFee(_reserve0, _reserve1);
    uint _totalSupply = totalSupply;
    // amount0 = liquidity * balance0 / _totalSupply
    amount0 = liquidity.mul(balance0) / _totalSupply;
    // amount1 = liquidity * balance1 / _totalSupply
    amount1 = liquidity.mul(balance1) / _totalSupply;
    // 需要 amount0 > 0 && amount1 > 0
    require(amount0 > 0 && amount1 > 0, 'UniswapV2: INSUFFICIENT_LIQUIDITY_BURNED');
    // 销毁 liquidity 数量的 LP代币
    _burn(address(this), liquidity);
    // 将 amount0 数量的 _token0 发送到 to 地址
    _safeTransfer(_token0, to, amount0);
    // 将 amount1 数量的 _token1 发送到 to 地址
    _safeTransfer(_token1, to, amount1);
    // 重新获取 balance0 和 balance1
    balance0 = IERC20(_token0).balanceOf(address(this));
    balance1 = IERC20(_token1).balanceOf(address(this));
    // 更新库存
    _update(balance0, balance1, _reserve0, _reserve1);
    // 如果 feeOn == true，更新 kLast
    if (feeOn) kLast = uint(reserve0).mul(reserve1);
    // 触发事件 Burn
    emit Burn(msg.sender, amount0, amount1, to);
}

      • 总结

        如果有人向资金池发送 LP，那么实际上并没有销毁该 LP，而是送给了下一个销毁 LP 的人。因为虽然没人能提取出来，但任何人都可以销毁该 LP 并获得相应的流动性代币。

交易

  • 外部函数（仅合约外部可以调用）
    • swap

      • 代码速览

        function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external lock {
          
          
    require(amount0Out > 0 || amount1Out > 0, 'UniswapV2: INSUFFICIENT_OUTPUT_AMOUNT');
    (uint112 _reserve0, uint112 _reserve1,) = getReserves();
    require(amount0Out < _reserve0 && amount1Out < _reserve1, 'UniswapV2: INSUFFICIENT_LIQUIDITY');
    uint balance0;
    uint balance1;
    {
          
          
        address _token0 = token0;
        address _token1 = token1;
        require(to != _token0 && to != _token1, 'UniswapV2: INVALID_TO');
        if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out);
        if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out);
        if (data.length > 0) IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data);
        balance0 = IERC20(_token0).balanceOf(address(this));
        balance1 = IERC20(_token1).balanceOf(address(this));
    }
    uint amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
    uint amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
    require(amount0In > 0 || amount1In > 0, 'UniswapV2: INSUFFICIENT_INPUT_AMOUNT');
    {
          
          
        uint balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(3));
        uint balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(3));
        require(balance0Adjusted.mul(balance1Adjusted) >= uint(_reserve0).mul(_reserve1).mul(1000**2), 'UniswapV2: K');
    }
    _update(balance0, balance1, _reserve0, _reserve1);
    emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
}

      • 参数分析
        函数 swap 的入参有4个，出参有0个，对应的解释如下：

        function swap(
    uint amount0Out, // 预期获得的 token0 数量
    uint amount1Out, // 预期获得的 token1 数量
    address to, // 资产接收地址
    bytes calldata data // 闪电贷调用数据
) external lock {
          
          
    ...
}

        函数 swap 的主要功能是执行代币交换，并支持了闪电贷的功能。

      • 实现分析

        ...
{
          
          
    // 需要 amount0Out > 0 || amount1Out > 0
    require(amount0Out > 0 || amount1Out > 0, 'UniswapV2: INSUFFICIENT_OUTPUT_AMOUNT');
    // 获取记录库存 _reserve0，_reserve1
    (uint112 _reserve0, uint112 _reserve1,) = getReserves();
    // 需要 amount0Out < _reserve0 && amount1Out < _reserve1
    require(amount0Out < _reserve0 && amount1Out < _reserve1, 'UniswapV2: INSUFFICIENT_LIQUIDITY');
    uint balance0;
    uint balance1;
    {
          
          
        address _token0 = token0;
        address _token1 = token1;
        // 需要 to 地址不是 token0 地址和 token1 地址
        require(to != _token0 && to != _token1, 'UniswapV2: INVALID_TO');
        // 如果 amount0Out > 0，向 to 地址发送数量为 amount0Out 的 _token0 代币
        if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out);
        // 如果 amount1Out > 0，向 to 地址发送数量为 amount1Out 的 _token1 代币
        if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out);
        // 如果 data.length > 0，执行闪电贷
        if (data.length > 0) IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data);
        // 获取 _token0 余额 balance0
        balance0 = IERC20(_token0).balanceOf(address(this));
        // 获取 _token1 余额 balance1
        balance1 = IERC20(_token1).balanceOf(address(this));
    }
    // 如果 balance0 > _reserve0 - amount0Out，需要支付的 token0 数量 amount0In = balance0 - (_reserve0 - amount0Out)，否则为0
    uint amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
    // 如果 balance1 > _reserve1 - amount1Out，需要支付的 token1 数量 amount1In = balance1 - (_reserve1 - amount1Out)，否则为0
    uint amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
    // 需要 amount0In > 0 || amount1In > 0
    require(amount0In > 0 || amount1In > 0, 'UniswapV2: INSUFFICIENT_INPUT_AMOUNT');
    {
          
          
        // 需要交易之后的 K 值不能变小
        uint balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(3));
        uint balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(3));
        require(balance0Adjusted.mul(balance1Adjusted) >= uint(_reserve0).mul(_reserve1).mul(1000**2), 'UniswapV2: K');
    }
    // 更新库存
    _update(balance0, balance1, _reserve0, _reserve1);
    // 触发 Swap 事件
    emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
}

      • 总结

        比较巧妙的一点是，swap 没有在交易之前进行数量计算，取而代之的是在交易完成之后进行检查。这减少了区块链上的计算量，并很好地支持了闪电贷功能。

再平衡

  • 外部函数（仅合约外部可以调用）
    • skim

      • 代码速览

        function skim(address to) external lock {
          
          
    address _token0 = token0;
    address _token1 = token1;
    _safeTransfer(_token0, to, IERC20(_token0).balanceOf(address(this)).sub(reserve0));
    _safeTransfer(_token1, to, IERC20(_token1).balanceOf(address(this)).sub(reserve1));
}

      • 参数分析
        函数 skim 的入参有1个，出参有0个，对应的解释如下：

        function skim(
    address to // 资产接收地址
) external lock {
          
          
    ...
}

        函数 skim 可以让调用者获得多于库存的代币。

      • 实现分析

        ...
{
          
          
    address _token0 = token0;
    address _token1 = token1;
    // 将多于库存 reserve0 的代币 _token0 发送到 to 地址
    _safeTransfer(_token0, to, IERC20(_token0).balanceOf(address(this)).sub(reserve0));
    // 将多于库存 reserve1 的代币 _token1 发送到 to 地址
    _safeTransfer(_token1, to, IERC20(_token1).balanceOf(address(this)).sub(reserve1));
}

      • 总结

        任何人都可以调用这个函数获取多于库存的代币。

    • skim

      • 代码速览

        function sync() external lock {
          
          
    _update(IERC20(token0).balanceOf(address(this)), IERC20(token1).balanceOf(address(this)), reserve0, reserve1);
}

      • 参数分析
        函数 sync 的入参有0个，出参有0个。
        函数 sync 用于强制匹配库存和代币余额。

      • 实现分析

        ...
{
          
          
    // 更新库存
    _update(IERC20(token0).balanceOf(address(this)), IERC20(token1).balanceOf(address(this)), reserve0, reserve1);
}

      • 总结

        任何人都可以调用这个函数强制更新库存。

猜你喜欢

转载自blog.csdn.net/qq_41943430/article/details/123227861
今日推荐
Apache Doris 2.0.10 版本正式发布！
开源日报 | 大模型开战；大模型独角兽被曝卖身；周鸿祎建议谷歌开源所有产品；最大开源AI社区提供1000万美元共享GPU
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
周排行
阿里云短信服务平台注册
Windows下的字符串处理(1)
sqoop: mysql导入数据到hdfs, hive, hbase
commons.lang中常用的工具类
离线安装PostgreSQL11.6
使用PyTorch简单实现卷积神经网络模型
一文彻底搞定谱聚类
一道面试题引发的血案
One Chat for Mac(聊天工具)
TCP/IP的底层队列是如何实现的？
每日归档
更多
2024-05-17(34)
2024-05-16(6)
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022