以太坊==给合约转入/查询合约剩余/合约转给某账户/结构体/MAP

转入

必须要定义该函数，或者定义fallback

// 接收以太币

    receive() external payable {} // Corrected Line

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SimpleStorage {
    uint256 private storedData;

    // 事件，用于通知数据变更
    event DataStored(uint256 indexed data);

    // 存储数据的函数
    function set(uint256 x) public payable {
        storedData = storedData+x;
        emit DataStored(x);
    }

    // 检索数据的函数
    function get() public view returns (uint256) {
        return storedData;
    }

    // 接收以太币
    receive() external payable {} // Corrected Line

    function getBalance() public view returns (uint256) {
        return address(this).balance;
    }
}

查询

合约转给某账户

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SimpleStorage {
    uint256 private storedData;

    // 事件，用于通知数据变更
    event DataStored(uint256 indexed data);

    // 存储数据的函数
    function set(uint256 x) public payable {
        storedData = storedData+x;
        emit DataStored(x);
    }

    // 检索数据的函数
    function get() public view returns (uint256) {
        return storedData;
    }

    // 接收以太币
    receive() external payable {} // Corrected Line

    function getBalance() public view returns (uint256) {
        return address(this).balance;
    }

    
 // 从合约转账以太币到指定账户的函数
    function transferTo(address payable _to) public {
        uint256 amount = 10 ether; // 转账金额为10以太币
        _to.transfer(amount); // 使用 transfer 方法转账
    }

}

在 Solidity 中，有三种常用的方法可以将以太币转账到另一个地址：transfer、send 和 call。它们各自有不同的特性和用法，

transfer：安全性高，适用于简单转账，不需要处理失败情况。
send：灵活性较高，需要手动处理失败。
call：最灵活和通用的方法，适用于复杂的场景，允许指定 Gas 和调用其他合约方法。

结构体/MAP

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract UserManager {
    // 定义用户结构体
    struct User {
        string name;
        uint256 age;
        address userAddress;
    }

    // 存储用户的映射
    mapping(address => User) public users;
    // 存储所有用户地址的数组
    address[] public userAddresses;

    // 事件，用于通知用户信息变更
    event UserAdded(address indexed userAddress, string name, uint256 age);
    event UserUpdated(address indexed userAddress, string name, uint256 age);

    // 添加用户信息的函数
    function addUser(string memory _name, uint256 _age) public {
        // 检查用户是否已存在
        require(users[msg.sender].userAddress == address(0), "User already exists");

        // 创建新的用户结构体并存储在映射中
        users[msg.sender] = User(_name, _age, msg.sender);
        // 将用户地址添加到数组中
        userAddresses.push(msg.sender);

        // 触发事件，通知前端
        emit UserAdded(msg.sender, _name, _age);
    }

    // 更新用户信息的函数
    function updateUser(string memory _name, uint256 _age) public {
        // 检查用户是否已存在
        require(users[msg.sender].userAddress != address(0), "User does not exist");

        // 更新用户信息
        users[msg.sender].name = _name;
        users[msg.sender].age = _age;

        // 触发事件，通知前端
        emit UserUpdated(msg.sender, _name, _age);
    }

    // 获取用户信息的函数
    function getUser(address _userAddress) public view returns (string memory, uint256, address) {
        // 检查用户是否存在
        require(users[_userAddress].userAddress != address(0), "User does not exist");

        // 返回用户信息
        User memory user = users[_userAddress];
        return (user.name, user.age, user.userAddress);
    }

    // 返回所有用户信息的函数
    function getAllUsers() public view returns (User[] memory) {
        // 创建一个大小为 userAddresses.length 的动态数组
        User[] memory allUsers = new User[](userAddresses.length);

        // 遍历用户地址数组，并将用户信息存储到动态数组中
        for (uint256 i = 0; i < userAddresses.length; i++) {
            allUsers[i] = users[userAddresses[i]];
        }

        // 返回包含所有用户信息的动态数组
        return allUsers;
    }
}