小迪上课笔记之Web3——Sodility基础篇1

helloworld

文件创建

变量申明

'message' 是一个公共的状态变量，存储着字符串"Hello World!"。
'fn1'函数 是一个公共的视图函数(view)，用于返回状态变量'message' 的值。因为它只读取数据而不修改状态，所以被声明为视图函数。
'fn2'函数 是一个公共的纯函数(pure)，用于返回字符串 "Hello World!"。因为它不读取状态变量，所以被声明为纯函数。纯函数不访问合约的状态变量，只依赖于输入参数或其他纯函数的输出
'fn3'函数 是一个公共的纯函数(pure)，它调用了函数fn2并返回其结果。

public ：链上状态变量能读能写

public pure：链上状态变量不能读写

public view：链上状态变量可读不写

memory：临时变量存储内存不上链

storage：合约变量存储链上

复制代码

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

contract Hello {
    string public message="hello world";

    function fn1() public view returns (string memory){
        return message;
    }//view可读（message）不可写

    function fn2() public pure  returns (string memory){
        return "hello world";
    }//pure不可读不可写,可以返回内部数据，不可读写外部数据

    function fn3() public pure  returns (string memory){
        return fn2();
    }
}

编译

运行

合约结构

复制代码

pragma solidity ^0.8.17;

contract TestStorage {
    uint256 storedData;

    function set(uint256 _x) public{
        storedData = _x;
    }
	
    function get() public view returns(uint256){
        return storedData;
    }
	
}

set 设置值，get取得值

构造函数/合约地址/合约创建者地址/合约调用者地址

msg.sender 是一个全局变量，代表当前调用这个函数（或发起这笔交易）的账户的地址。

构造函数：constructor

复制代码

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

contract demo{
    address public xiaodi;
    address public xiaodisec;
    address public xiaodisecgay;

    constructor (){//初始化构造函数
        xiaodi = address(this);//合约地址
        xiaodisec = msg.sender;//创始者地址
        xiaodisecgay=fn();//合约调用地址
    }

    function fn() public view returns (address){
        return msg.sender;
    }
}

可见xiaodi（合约地址）与其他三个返回不一样

import导入使用

导入本地文件：import "./ERC20.sol";
导入网络文件：import "https://github.com/aaa/tools.sol";
导入本地NPM库：
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "filename" as symbolName;
import {symbol1 as aliasName, symbol2} from "filename";

//创建可导入的文件h.sol

h.sol 复制代码

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
contract demo{
    string public message="helloworld";
}

//导入h.sol到h_import.sol

h_import.sol 复制代码

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "./h.sol";

contract importdemo is demo{
    function fn() public view returns(string memory){
        return message;
    }
}

interface接口

先执行获取Cat,Dog,Animal地址，

给Animal执行test方法地址后调用接口

复制代码

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

//创建一个cat合约
contract Cat{
    uint256 public age;

    function eat() public returns (string memory){
        age++;
        return "cat eat fish";
    }

    function sleep1() public pure returns (string memory){
        return "sleep1";
    }
}

//创建一个dog合约
contract Dog{
    uint256 public age;
    function eat() public returns (string memory){
        age += 2;
        return "dog miss you";
    }

    function sleep2() public pure returns (string memory){
        return "sleep2";
    }
}

//定义一个animaleat接口，用于接收eat的值
interface AnimalEat {
    function eat() external returns (string memory);
}

//定义一个Animal合约，接收合约的地址
contract Animal {
    function test(address _addr) external returns (string memory){
        AnimalEat general = AnimalEat(_addr);
        return  general.eat();
    }
}

全局单位

原生支持的所有货币单位

wei,gwei,ether,finney

1 wei = 1 wei

1 gwei = 10^9 wei

1 finney = 10^15 wei

1 ether = 10^18 wei

复制代码

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

contract ethdemo{
    uint256 public amount;

    constructor(){
        amount = 1;
    }

    function fnGWei() public view returns (uint256){
        return amount + 1 gwei;//1000000001
    }

    function fnEth() public view returns (uint256){
        return amount + 1 ether;//1000000000000000001
    }

    // 这些后缀不能直接用在变量后边。如果想用以太币单位来计算输入参数，你可以用如下方式来完成：
    function testVar(uint256 amountEth) public view returns (uint256) {
        return amount + amountEth * 1 ether;
    }
}

接受ETH

receive()是在合约收到ETH转账时被调用的函数,一个合约最多有一个receive()函数，声明方式不一样，不需要function，关键字：receive() external payable { ... }，receive()函数不能有任何的参数，不能返回任何值，必须包含external和payable。

fallback()会在调用合约不存在的函数时被触发，可用于接收ETH，也可以用于代理合约proxy contract fallback()声明时不需要function关键字，必须由external修饰，一般也会用payable修饰，用于接收ETH:fallback() external payable { ... }。

涉及全局变量：

msg.sender address payable当前调用直接发起者权限控制、身份标识

msg.value uint 随调用发送的ETH数量（wei）支付处理、收款逻辑

复制代码

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

contract Fallback{
    //定义事件
    event receivedCalled(address Sender,uint Value);
    event fallbackCalled(address Sender,uint Value,bytes Data);

    //接收ETH时释放Received事件
    receive() external payable { 
        emit receivedCalled(msg.sender,msg.value);
    }

    //fallback
    fallback() external payable{
        emit fallbackCalled(msg.sender,msg.value,msg.data);
    }
}