// 布尔值

    bool public _bool = true;

// 整型

    int public _int = -1; // 整数，包括负数

    uint public _uint = 1; // 正整数

    uint256 public _number = 20220330; // 256 位正整数

// 地址

    address public _address = 0x7A58c0Be72BE218B41C608b7Fe7C5bB630736C71;

    address payable public _address1 = payable(_address); //payable address，可以转账、查余额

    // 地址类型的成员

    uint256 public balance = _address1.balance; // balance of address

// 固定长度的字节数组

    bytes32 public _byte32 = "MiniSolidity"; 

    bytes1 public _byte = _byte32[0];

// 用 enum 将 uint 0， 1， 2 表示为 Buy, Hold, Sell

    enum ActionSet { Buy, Hold, Sell }

    // 创建 enum 变量 action

    ActionSet action = ActionSet.Buy;

function <function name> (<parameter types>) {internal|external|public|private} [pure|view|payable] [returns (<return types>)]

// 返回多个变量

    function returnMultiple() public pure returns(uint256, bool, uint256[3] memory){

            return(1, true, [uint256(1),2,5]);

        }

// 命名式返回

    function returnNamed() public pure returns(uint256 _number, bool _bool, uint256[3] memory _array){

        _number = 2;

        _bool = false; 

        _array = [uint256(3),2,1];

			//return (1, true, [uint256 (1),2,5]); 也可以直接用 return 返回值

    }

function fCalldata(uint[] calldata _x) public pure returns(uint[] calldata){

        // 参数为 calldata 数组，不能被修改

        //_x [0] = 0 // 这样修改会报错

        return(_x);

    }

uint[] x = [1,2,3]; // 状态变量：数组 x

    function fStorage() public{

        // 声明一个 storage 的变量 xStorage，指向 x。修改 xStorage 也会影响 x

        uint[] storage xStorage = x;

        xStorage[0] = 100;

    }

uint[] x = [1,2,3]; // 状态变量：数组 x

    function fMemory() public view{

        // 声明一个 Memory 的变量 xMemory，复制 x。修改 xMemory 不会影响 x

        uint[] memory xMemory = x;

        xMemory[0] = 100;

        xMemory[1] = 200;

        uint[] memory xMemory2 = x;

        xMemory2[0] = 300;

    }

function fMemory2() public returns(uint8[3] memory){

		uint8[3] memory x_tmp=[1,2,3];

        uint8[3] memory xMemory = x_tmp;

        xMemory[0] = 100;

        xMemory[1] = 200;

        return x_tmp;

}

function fStorage() public returns(uint){

        uint  xMemory;

        xMemory=123456;

        x[0]=xMemory;

				xMemory=66666666;

        return x[0];

    }

//SPDX-License-Identifier:MIT

pragma solidity ^0.8.7;

contract dataStorageRule{ 

    uint[] x=[1,2,3]; // 类型为 storage

    function RuleOne() public returns(uint){

            x=[1,2,3];

            uint[] storage xstorage = x;

            xstorage[0]=111;

            return x[0];

    }

    function Ruletwo() public returns(uint,uint,uint){

        x=[1,2,3];

        uint[] memory xstorage = x;

        xstorage[0]=111;

        xstorage[1]=222;

        xstorage[2]=333;

        return (x[0],x[1],x[2]);

    }

    function Rulethree() public returns(uint8[3] memory){

		uint8[3] memory x_tmp=[1,2,3];

        uint8[3] memory xMemory = x_tmp;

        xMemory[0] = 100;

        xMemory[1] = 200;

        return x_tmp;

    }

    function Rulefour() public returns(uint){

        uint  xMemory;

        xMemory=123456;

        x[0]=xMemory;

				xMemory=66666666;

        return x[0];

    }

}

contract Variables {

    uint public x = 1;

    uint public y;

    string public z;

function bar() external pure returns(uint){

        uint xx = 1;

        uint yy = 3;

        uint zz = xx + yy;

        return(zz);

    }

function global() external view returns(address, uint, bytes memory){

        address sender = msg.sender;

        uint blockNum = block.number;

        bytes memory data = msg.data;

        return(sender, blockNum, data);

	    }

// 固定长度 Array

    uint[8] array1;

    bytes1[5] array2;

    address[100] array3;

// 可变长度 Array

    uint[] array4;

    bytes1[] array5;

    address[] array6;

    bytes array7;

//memory 动态数组

    uint[] memory array8 = new uint[](5);

    bytes memory array9 = new bytes(9);

uint[] memory x = new uint[](3);

    x[0] = 1;

    x[1] = 3;

    x[2] = 4;

// 结构体

    struct Student{

        uint256 id;

        uint256 score; 

    }

Student student; // 初始一个 student 结构体

function initStudent1() external{

        Student storage _student = student; // assign a copy of student

        _student.id = 11;

        _student.score = 100;

    }

function initStudent2() external{

        student.id = 1;

        student.score = 80;

    }

mapping(uint => address) public idToAddress; //id 映射到地址

    mapping(address => address) public swapPair; // 币对的映射，地址到地址

// 我们定义一个结构体 Struct

    struct Student{

        uint256 id;

        uint256 score; 

    }

     mapping(Student => uint) public testVar;

function writeMap (uint _Key, address _Value) public{

        idToAddress[_Key] = _Value;

    }

//delete 操作符

    bool public _bool2 = true; 

    function d() external {

        delete _bool2; //delete 会让_bool2 变为默认值，false

    }

//constant 变量必须在声明的时候初始化，之后不能改变

    uint256 constant CONSTANT_NUM = 10;

    string constant CONSTANT_STRING = "0xAA";

    bytes constant CONSTANT_BYTES = "WTF";

    address constant CONSTANT_ADDRESS = 0x0000000000000000000000000000000000000000;

//immutable 变量可以在 constructor 里初始化，之后不能改变

    uint256 public immutable IMMUTABLE_NUM = 9999999999;

    address public immutable IMMUTABLE_ADDRESS;

    uint256 public immutable IMMUTABLE_BLOCK;

    uint256 public immutable IMMUTABLE_TEST;

// 利用 constructor 初始化 immutable 变量，因此可以利用

    constructor(){

        IMMUTABLE_ADDRESS = address(this);

        IMMUTABLE_BLOCK = block.number;

        IMMUTABLE_TEST = test();

    }

    function test() public pure returns(uint256){

        uint256 what = 9;

        return(what);

    }

function ifElseTest(uint256 _number) public pure returns(bool){

    if(_number == 0){

    return(true);

    }else{

    return(false);

    }

}

function forLoopTest() public pure returns(uint256){

    uint sum = 0;

    for(uint i = 0; i < 10; i++){

    sum += i;

    }

    return(sum);

}

function whileTest() public pure returns(uint256){

    uint sum = 0;

    uint i = 0;

    while(i < 10){

    sum += i;

    i++;

    }

    return(sum);

}

function doWhileTest() public pure returns(uint256){

    uint sum = 0;

    uint i = 0;

    do{

    sum += i;

    i++;

    }while(i < 10);

    return(sum);

}

// 三元运算符 ternary/conditional operator

function ternaryTest(uint256 x, uint256 y) public pure returns(uint256){

// return the max of x and y

    return x >= y ? x: y;

}

address owner; // 定义 owner 变量

   // 构造函数

   constructor() {

      owner = msg.sender; // 在部署合约的时候，将 owner 设置为部署者的地址

   }

// 定义 modifier

   modifier onlyOwner {

      require(msg.sender == owner);// 检查调用者是否为 owner 地址

      _;// 如果是的话，继续运行函数主体；否则报错并 revert 交易

   }

function changeOwner(address _newOwner) external onlyOwner{

      owner = _newOwner;// 只有 owner 地址运行这个函数，并改变 owner

   }

event Transfer(address indexed from, address indexed to, uint256 value);

// 定义_transfer 函数，执行转账逻辑

    function _transfer(

        address from,

        address to,

        uint256 amount

    ) external {

        _balances[from] = 10000000; // 给转账地址一些初始代币

        _balances[from] -=  amount; //from 地址减去转账数量

        _balances[to] += amount; //to 地址加上转账数量

        // 释放事件

        emit Transfer(from, to, amount);

    }

contract Yeye {

    event Log(string msg);

// 定义 3 个 function: hip (), pop (), man ()，Log 值为 Yeye。

    function hip() public virtual{

        emit Log("Yeye");

    }

    function pop() public virtual{

        emit Log("Yeye");

    }

    function yeye() public virtual {

        emit Log("Yeye");

    }

}

contract Baba is Yeye{

// 继承两个 function: hip () 和 pop ()，输出改为 Baba。

    function hip() public virtual override{

        emit Log("Baba");

    }

    function pop() public virtual override{

        emit Log("Baba");

    }

    function baba() public virtual{

        emit Log("Baba");

    }

}

contract Erzi is Yeye, Baba{

// 继承两个 function: hip () 和 pop ()，输出值为 Erzi。

    function hip() public virtual override(Yeye, Baba){

        emit Log("Erzi");

    }

    function pop() public virtual override(Yeye, Baba) {

        emit Log("Erzi");

    }

contract Base1 {

    modifier exactDividedBy2And3(uint _a) virtual {

        require(_a % 2 == 0 && _a % 3 == 0);

        _;

    }

}

contract Identifier is Base1 {

// 计算一个数分别被 2 除和被 3 除的值，但是传入的参数必须是 2 和 3 的倍数

    function getExactDividedBy2And3(uint _dividend) public exactDividedBy2And3(_dividend) pure returns(uint, uint) {

        return getExactDividedBy2And3WithoutModifier(_dividend);

    }

// 计算一个数分别被 2 除和被 3 除的值

    function getExactDividedBy2And3WithoutModifier(uint _dividend) public pure returns(uint, uint){

        uint div2 = _dividend / 2;

        uint div3 = _dividend / 3;

        return (div2, div3);

    }

}

modifier exactDividedBy2And3(uint _a) override {

        _;

        require(_a % 2 == 0 && _a % 3 == 0);

    }

// 构造函数的继承

abstract contract A {

    uint public a;

    constructor(uint _a) {

        a = _a;

    }

}

contract C is A {

    constructor(uint _c) A(_c * _c) {}

}

function callParent() public{

        Yeye.pop();

    }

function callParentSuper() public{

        // 将调用最近的父合约函数，Baba.pop ()

        super.pop();

    }

// Errors 用来定义失败

 // 以下称为 natspec 注释，可以通过三个斜杠来识别。

 // 当用户被要求确认交易时或错误发生时将显示。

/// you are not the owner

error TransferNotOwner();// 自定义 error

function transferOwner1(uint256 tokenId, address newOwner) public {

        if(_owners[tokenId] != msg.sender){

            revert TransferNotOwner();

        }

        _owners[tokenId] = newOwner;

    }

function transferOwner2(uint256 tokenId, address newOwner) public {

        require(_owners[tokenId] == msg.sender, "Transfer Not Owner");

        _owners[tokenId] = newOwner;

    }

function transferOwner3(uint256 tokenId, address newOwner) public {

        assert(_owners[tokenId] == msg.sender);

        _owners[tokenId] = newOwner;

    }

if(msg.sender != owner) { throw; }

- if(msg.sender != owner) { revert(); }// 如果不等则异常

- assert(msg.sender == owner);// 校验是否等于

- require(msg.sender == owner);

//SPDX-License-Identifier:GPL-3.0

pragma solidity ^0.8.7;

contract HelloWorldContract{

    function helloWorld()external pure returns(string memory){

        return "hello world";

    }

}

/**

 *Submitted for verification at Etherscan.io on 2022-09-09

*/

// SPDX-License-Identifier: MIT

pragma solidity >=0.8.7;

contract CSAWDonation {

    mapping(address => uint256) public balances;

    mapping(address => bool) public doneDonating;

    event sendToAuthor(bytes32 token);

    function newAccount() public payable{

        require(msg.value >= 0.0001 ether); 

        balances[msg.sender] = 10;

        doneDonating[msg.sender] = false;

    }

    function donateOnce() public {

        require(balances[msg.sender] >= 1);

        if(doneDonating[msg.sender] == false) {

            balances[msg.sender] += 10;

            msg.sender.call{value: 0.0001 ether}("");

            doneDonating[msg.sender] = true;

        }

    }

    function getBalance() public view returns (uint256 donatorBalance) {

        return balances[msg.sender];

    }

    function getFlag(bytes32 _token) public {

        require(balances[msg.sender] >= 30);

        emit sendToAuthor(_token); //sends the token 

    }

}

// 插入排序 错误版

    function insertionSortWrong(uint[] memory a) public pure returns(uint[] memory) {

        for (uint i = 1;i < a.length;i++){

            uint temp = a[i];

            uint j=i-1;

            while( (j >= 0) && (temp < a[j])){

                a[j+1] = a[j];

                j--;

            }

            a[j+1] = temp;

        }

        return(a);

    }

// 插入排序 正确版

    function insertionSort(uint[] memory a) public pure returns(uint[] memory) {

        // note that uint can not take negative value

        for (uint i = 1;i < a.length;i++){

            uint temp = a[i];

            uint j=i;

            while( (j >= 1) && (temp < a[j-1])){

                a[j] = a[j-1];

                j--;

            }

            a[j] = temp;

        }

        return(a);

    }

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

/// @title 委托投票

contract Ballot {

    // 这里声明了一个新的复合类型用于稍后的变量

    // 它用来表示一个选民

    struct Voter {

        uint weight; // 计票的权重

        bool voted;  // 若为真，代表该人已投票

        address delegate; // 被委托人

        uint vote;   // 投票提案的索引

    }

    // 提案的类型

    struct Proposal {

        bytes32 name;   // 简称（最长 32 个字节）

        uint voteCount; // 得票数

    }

    address public chairperson;

    // 这声明了一个状态变量，为每个可能的地址存储一个 `Voter`。

    mapping(address => Voter) public voters;

    // 一个 `Proposal` 结构类型的动态数组

    Proposal[] public proposals;

    /// 为 `proposalNames` 中的每个提案，创建一个新的（投票）表决

    constructor(bytes32[] memory proposalNames) {

        chairperson = msg.sender;

        voters[chairperson].weight = 1;

        // 对于提供的每个提案名称，

        // 创建一个新的 Proposal 对象并把它添加到数组的末尾。

        for (uint i = 0; i < proposalNames.length; i++) {

            // `Proposal ({...})` 创建一个临时 Proposal 对象，

            // `proposals.push (...)` 将其添加到 `proposals` 的末尾

            proposals.push(Proposal({

                name: proposalNames[i],

                voteCount: 0

            }));

        }

    }

    // 授权 `voter` 对这个（投票）表决进行投票

    // 只有 `chairperson` 可以调用该函数。

    function giveRightToVote(address voter) external {

        // 若 `require` 的第一个参数的计算结果为 `false`，

        // 则终止执行，撤销所有对状态和以太币余额的改动。

        // 在旧版的 EVM 中这曾经会消耗所有 gas，但现在不会了。

        // 使用 require 来检查函数是否被正确地调用，是一个好习惯。

        // 你也可以在 require 的第二个参数中提供一个对错误情况的解释。

        require(

            msg.sender == chairperson,

            "Only chairperson can give right to vote."

        );

        require(

            !voters[voter].voted,

            "The voter already voted."

        );

        require(voters[voter].weight == 0);

        voters[voter].weight = 1;

    }

    /// 把你的投票委托到投票者 `to`。

    function delegate(address to) external {

        // 传引用

        Voter storage sender = voters[msg.sender];

        require(sender.weight != 0, "You have no right to vote");

        require(!sender.voted, "You already voted.");

        require(to != msg.sender, "Self-delegation is disallowed.");

        // 委托是可以传递的，只要被委托者 `to` 也设置了委托。

        // 一般来说，这种循环委托是危险的。因为，如果传递的链条太长，

        // 则可能需消耗的 gas 要多于区块中剩余的（大于区块设置的 gasLimit），

        // 这种情况下，委托不会被执行。

        // 而在另一些情况下，如果形成闭环，则会让合约完全卡住。

        while (voters[to].delegate != address(0)) {

            to = voters[to].delegate;

            // 不允许闭环委托

            require(to != msg.sender, "Found loop in delegation.");

        }

        // `sender` 是一个引用，相当于对 `voters [msg.sender].voted` 进行修改

        Voter storage delegate_ = voters[to];

        // Voters cannot delegate to accounts that cannot vote.

        require(delegate_.weight >= 1);

        // Since `sender` is a reference, this

        // modifies `voters[msg.sender]`.

        sender.voted = true;

        sender.delegate = to;

        if (delegate_.voted) {

            // 若被委托者已经投过票了，直接增加得票数

            proposals[delegate_.vote].voteCount += sender.weight;

        } else {

            // 若被委托者还没投票，增加委托者的权重

            delegate_.weight += sender.weight;

        }

    }

    /// 把你的票 (包括委托给你的票)，

    /// 投给提案 `proposals [proposal].name`.

    function vote(uint proposal) external {

        Voter storage sender = voters[msg.sender];

        require(!sender.voted, "Already voted.");

        sender.voted = true;

        sender.vote = proposal;

        // 如果 `proposal` 超过了数组的范围，则会自动抛出异常，并恢复所有的改动

        proposals[proposal].voteCount += sender.weight;

    }

    /// @dev 结合之前所有的投票，计算出最终胜出的提案

    function winningProposal() external view

            returns (uint winningProposal_)

    {

        uint winningVoteCount = 0;

        for (uint p = 0; p < proposals.length; p++) {

            if (proposals[p].voteCount > winningVoteCount) {

                winningVoteCount = proposals[p].voteCount;

                winningProposal_ = p;

            }

        }

    }

    // 调用 winningProposal () 函数以获取提案数组中获胜者的索引，并以此返回获胜者的名称

    function winnerName() public view

            returns (bytes32 winnerName_)

    {

        winnerName_ = proposals[winningProposal()].name;

    }

}

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.4;

contract SimpleAuction {

    // 拍卖的参数。

    address payable public beneficiary;

    // 时间是 unix 的绝对时间戳（自 1970-01-01 以来的秒数）

    // 或以秒为单位的时间段。

    uint public auctionEnd;

    // 拍卖的当前状态

    address public highestBidder;

    uint public highestBid;

    // 可以取回的之前的出价

    mapping(address => uint) pendingReturns;

    // 拍卖结束后设为 true，将禁止所有的变更

    bool ended;

    // 变更触发的事件

    event HighestBidIncreased(address bidder, uint amount);

    event AuctionEnded(address winner, uint amount);

    // Errors 用来定义失败

    // 以下称为 natspec 注释，可以通过三个斜杠来识别。

    // 当用户被要求确认交易时或错误发生时将显示。

    /// The auction has already ended.

    error AuctionAlreadyEnded();

    /// There is already a higher or equal bid.

    error BidNotHighEnough(uint highestBid);

    /// The auction has not ended yet.

    error AuctionNotYetEnded();

    /// The function auctionEnd has already been called.

    error AuctionEndAlreadyCalled();

    /// 以受益者地址 `beneficiaryAddress` 的名义，

    /// 创建一个简单的拍卖，拍卖时间为 `biddingTime` 秒。

    constructor(

        uint biddingTime,

        address payable beneficiaryAddress

    ) {

        beneficiary = beneficiaryAddress;

        auctionEnd = block.timestamp + biddingTime;

    }

    /// 对拍卖进行出价，具体的出价随交易一起发送。

    /// 如果没有在拍卖中胜出，则返还出价。

    function bid() external payable {

        // 参数不是必要的。因为所有的信息已经包含在了交易中。

        // 对于能接收以太币的函数，关键字 payable 是必须的。

        // 如果拍卖已结束，撤销函数的调用。

        if (block.timestamp > auctionEndTime)

            revert AuctionAlreadyEnded();

        // 如果出价不够高，返还你的钱

        if (msg.value <= highestBid)

            revert BidNotHighEnough(highestBid);

        if (highestBid != 0) {

            // 返还出价时，简单地直接调用 highestBidder.send (highestBid) 函数，

            // 是有安全风险的，因为它有可能执行一个非信任合约。

            // 更为安全的做法是让接收方自己提取金钱。

            pendingReturns[highestBidder] += highestBid;

        }

        highestBidder = msg.sender;

        highestBid = msg.value;

        emit HighestBidIncreased(msg.sender, msg.value);

    }

    /// 取回出价（当该出价已被超越）

    function withdraw() external returns (bool) {

        uint amount = pendingReturns[msg.sender];

        if (amount > 0) {

            // 这里很重要，首先要设零值。

            // 因为，作为接收调用的一部分，

            // 接收者可以在 `send` 返回之前，重新调用该函数。

            pendingReturns[msg.sender] = 0;

            // msg.sender is not of type `address payable` and must be

            // explicitly converted using `payable(msg.sender)` in order

            // use the member function `send()`.

            if (!payable(msg.sender).send(amount)) {

                // 这里不需抛出异常，只需重置未付款

                pendingReturns[msg.sender] = amount;

                return false;

            }

        }

        return true;

    }

    /// 结束拍卖，并把最高的出价发送给受益人

    function auctionEnd() external {

        // 对于可与其他合约交互的函数（意味着它会调用其他函数或发送以太币），

        // 一个好的指导方针是将其结构分为三个阶段：

        // 1. 检查条件

        // 2. 执行动作 (可能会改变条件)

        // 3. 与其他合约交互

        // 如果这些阶段相混合，其他的合约可能会回调当前合约并修改状态，

        // 或者导致某些效果（比如支付以太币）多次生效。

        // 如果合约内调用的函数包含了与外部合约的交互，

        // 则它也会被认为是与外部合约有交互的。

        // 1. 条件

        if (block.timestamp < auctionEndTime)

            revert AuctionNotYetEnded();

        if (ended)

            revert AuctionEndAlreadyCalled();

        // 2. 生效

        ended = true;

        emit AuctionEnded(highestBidder, highestBid);

        // 3. 交互

        beneficiary.transfer(highestBid);

    }

}