Solidity 关键词说明（payable transfer event modifier msg external public view pure memory）

一、payable

在 Solidity 中，payable 是一个关键字，用于表示函数可以接收以太币（ether）的转账。如果一个函数被声明为 payable，那么它就可以接收以太币的转账，而不仅仅是使用以太币作为参数进行函数调用。

例如，下面是一个声明了 payable 关键字的函数：

function buyToken() public payable {
    // 程序逻辑...
}

在上面的代码中，函数 buyToken() 会接收以太币的转账，并且转账的数量会作为函数的参数 msg.value 被传递进来。如果这个函数没有被声明为 payable，那么在进行转账时就会出现错误。

需要注意的是，在接收以太币的函数中，你需要确保对于接收到的以太币进行处理，以避免以太币被失误转移到了错误的地址。在处理以太币时，应该使用 Solidity 提供的 address.transfer() 函数来进行，例如：

function buyToken() public payable {
    require(msg.value >= 1 ether);
    // 进行购买逻辑...
    address payable recipient = msg.sender;
    recipient.transfer(msg.value);
}

在上面的代码中，使用了 require() 函数来确保转账的值大于等于 1 ether，同时使用 recipient.transfer(msg.value) 来将以太币转移到了接收方的地址中。

总之，在Solidity中，通过 payable 关键字声明函数为可接受以太币转账的函数，需要自己注意在处理以太币时的安全性。

二、transfer

在 Solidity 中，transfer 是一个函数，用于将以太币（ether）从一个地址转移到另一个地址。它的作用是将指定数量的以太币从当前合约的余额转移到指定的地址中。

transfer 函数的语法如下：

address payable recipient = 0x1234567890123456789012345678901234567890;
uint256 amountInWei = 1 ether;

recipient.transfer(amountInWei);

在上面的代码中，首先定义了一个要转移的以太币数量 amountInWei 和一个接收方地址 recipient。然后，通过调用 transfer() 函数将 amountInWei 数量的以太币转移到了 recipient 所代表的地址中。

需要注意的是，在调用 transfer 函数时，必须确保合约的余额足够支付转移的金额。否则，转移将会失败，并将抛出异常。为了避免这种情况的发生，可以使用 address 对象的 .balance 属性来检查余额是否充足，例如：

require(address(this).balance >= amountInWei);
recipient.transfer(amountInWei);

在上面的代码中，通过 require 语句来检查合约余额是否充足，如果余额充足，则会进行转移；如果余额不足，则会抛出异常并终止函数执行。

总之，transfer 函数是 Solidity 中用于转移以太币的重要函数，但需要注意余额充足性和安全性的问题。

三、event

在 Solidity 中，event 是一种用于在智能合约中记录日志的特殊数据类型。通过使用 event，你可以在合约中定义一些事件，并在特定条件发生时触发这些事件。定义的 event 可以被合约内外的代码监听，并且当事件被触发时，就会触发监听器函数执行相应的操作。

下面是一个具体的 event 定义示例：

event Aborted();

在上面的代码中，我们定义了一个 event 名称叫做 Aborted，表示在智能合约中某些特定场景下（比如某些条件不满足时），合约将会触发 Aborted 事件，并在该事件被触发时，通知外部代码执行相应的操作。

在定义 event 后，我们可以通过在智能合约的函数中使用 emit 语句来触发该事件，例如：

function abort() public {
    // 程序逻辑...
    emit Aborted();
}

在上述代码中，emit 语句将会触发名为 Aborted 的事件，并将相关信息记录到智能合约日志中。然后外部的代码可以监控该事件，以便更好地了解合约的运行情况。

需要注意的是，event 只能用于记录日志，并不能够改变合约的状态。因此，使用 event 应该注意在智能合约中进行适当的逻辑处理，避免不必要的浪费和异常发生。

四、modifier

在 Solidity 中，modifier 是一种用于修改函数行为的特殊类型。使用 modifier 可以在函数执行前或执行后添加额外的逻辑，例如检查函数参数的有效性、检查函数调用者是否有足够的权限、更新合约的状态、记录合约日志等等。

下面是一个具体的 modifier 定义示例：

modifier checkOwner {
    require(msg.sender == owner, "Only owner can call this function.");
    _;
}

在上面的代码中，我们定义了一个名称为 checkOwner 的 modifier，其中包含了 require 语句来确保只有合约拥有者才可以调用该函数。

使用 modifier 可以使得代码更加简洁和可读，也可以提高代码的安全性和健壮性。在调用带有 modifier 的函数时， Solidity 编译器会自动将该函数的执行流程插入到 modifier 中定义的逻辑中。因此，可以很容易地在函数逻辑的不同位置添加多个 modifier，以实现一个复杂的函数流程。

下面是一个示例，展示了如何在函数中使用 modifier：

address public owner;

function setName(string memory _newName) public checkOwner {
    // 执行函数逻辑...
}

在上述代码中，setName 是一个公共函数，它包含了一个名为 checkOwner 的 modifier。每次该函数被调用时， Solidity 编译器都会先执行 checkOwner 中的逻辑，然后在执行函数自身的逻辑。

总之，modifier 是 Solidity 中非常有用和常见的特性之一，可以帮助开发者在代码中添加各种额外的逻辑和安全检查。尤其在复杂的智能合约应用中，使用 modifier 可以提高代码的可读性和可维护性。

五、msg

在 Solidity 中，msg 是一个全局变量，代表着包含当前函数调用的交易信息。通过这个变量，我们可以获取到交易发送者的地址、以太币价值和交易哈希等信息。

在 Solidity 的函数内部，可以直接使用 msg 对象访问这些信息。例如，msg.sender 可以获取当前交易的发送者的地址，msg.value 可以获取当前交易的价值，msg.data 可以获取当前交易的数据。

这些信息在 Solidity 中非常重要，因为智能合约是在以太坊网络上运行的，而且每个交易都需要计算，执行和验证。因此，我们需要使用 msg 对象来获取这些交易信息，并在智能合约中进行合适的处理。

需要注意的是，在一些特殊情况下，msg 对象可能会被篡改。例如，攻击者可能会使用自定义的调用数据来尝试欺骗智能合约代码。因此，在编写智能合约时，我们需要谨慎地处理 msg 对象，并编写相应的安全检查逻辑，以确保合约正确处理这些交易信息。

六、external

在 Solidity 合约中，external 是一个可见性修饰符，用于改变函数的访问性质。

使用 external 修饰的函数可以被外部合约或交易调用，但不能在合约内部被直接调用。这意味着，external 函数只能被外部合约或交易调用，不能被当前合约的其他函数所调用。

同时，使用 external 修饰的函数也不能访问当前合约的状态变量，包括存储在存储器和状态变量中的数据。这是因为，使用 external 修饰的函数被调用时，它们不会访问当前合约的上下文，而只会接收参数和返回结果。

external 修饰符可以帮助开发者编写更清晰的智能合约代码，尤其是对于与其他合约或交易进行交互的函数。它还可以提高安全性，避免出现一些意外情况，例如在当前合约内部意外调用了一个本应该被外部合约或交易调用的函数。

以下是一个使用 external 修饰符的示例：

function setPrice(uint256 _price) external {
  // 在函数体内部处理 _price 参数，但不能直接访问当前合约的状态变量
}

在上述示例中，我们使用 external 修饰符来限制 setPrice 函数只能被外部合约或交易调用，而不能在当前合约内部直接调用。

七、Public

在 Solidity 合约中，public 和 external 都是可见性修饰符，但它们的含义是不同的。

使用 public 修饰的函数可以被外部合约或交易调用，同时也可以被当前合约的其他函数调用。它们可以访问当前合约的状态变量，包括存储在存储器和状态变量中的数据。这意味着，在 public 函数内部，我们可以读取和修改当前合约的状态变量。

使用 external 修饰的函数，如我之前所述，不能在当前合约内部被直接调用，也不能访问当前合约的状态变量。这种行为使得 external 函数成为纯粹的外部函数，可被其他合约或交易调用。

使用 public 还是 external 主要取决于函数的用途。如果一个函数需要在当前合约内部使用，并且需要访问当前合约的状态变量，则应该使用 public。相反，如果一个函数只需要在当前合约以外被调用，并且不需要访问当前合约的状态变量，则应该使用 external。

以下是一个示例，展示了如何使用 public 来声明一个函数：

uint256 public price;

function setPrice(uint256 _price) public {
  price = _price;
}

在上面的示例中，我们使用 public 修饰符声明了 setPrice 函数，使其可以被外部合约或交易调用，并且可以访问当前合约的状态变量 price，并将其设置为函数参数 _price 的值。

八、view

view 是 Solidity 合约中的一个可见性修饰符，通常用于在读取合约状态时标记函数。使用 view 修饰符可以让函数不修改合约状态，仅仅查看并返回数据给调用者。

具体来说，使用 view 标记的函数可以读取合约中的数据，并根据传入的参数计算出返回值，但是它不会在计算过程中修改任何合约状态。这也就意味着，这些函数是“纯函数”，即每次使用相同的参数调用 view 函数时，都会返回相同的结果。

由于这些 view 函数不修改合约状态，因此它们可以在任何时间、任何地点被安全地调用，而不会对合约的状态或网络中的其他事物产生任何影响。这使得 Solidity 合约能够更加安全和可靠地进行数据处理和计算。

需要指出的是，在 Solidity 0.5.0 版本之前，view 关键词是 constant。因此，我们可能会在某些旧代码中看到 constant 关键词被用来表示可读取但不会修改状态的函数。

九、pure

1、在 Solidity 中，pure 是一种函数状态修饰符，用于声明该函数是“纯函数”，即该函数的执行不会修改合约状态（即不会修改存储器和状态变量），也不会读取外部环境的数据（如区块时间戳、帐户余额等）。因此，纯函数的返回值只取决于其输入参数，与合约的状态和环境无关。

使用 pure 关键字有两个好处。首先，声明函数为纯函数可以方便编译器对代码进行优化，从而提高代码的执行效率。其次，它让调用者知道该函数不会对合约状态或外部环境产生任何影响，提高了代码的可读性和可维护性。

以下是一个使用 pure 关键字声明的示例函数：

function multiply(uint a, uint b) public pure returns (uint) {
    return a * b;
}

在这个例子中，multiply 函数的执行不依赖任何合约状态或外部环境，因此它被声明为纯函数。注意，如果一个函数被声明为纯函数而实际又产生了副作用，编译器会报错。

2、而与 pure 类似，view 也是一种函数状态修饰符，用于声明该函数不会修改合约状态，但可以读取外部环境（如区块信息、合约地址等）。

与 pure 不同的是，view 函数不一定是纯函数，它可以读取外部环境状态，因此它的返回值可以取决于外部环境的状态。不过，view 函数不会对外部环境造成影响，可以安全地在任何地方被调用，而不担心改变合约状态。

以下是一个使用 view 关键字声明的示例函数：

function getBalance(address _address) public view returns (uint) {
    return _address.balance;
}

在这个例子中，getBalance 函数不修改合约状态，但它读取了 _address 的账户余额，因此被声明为 view 函数。

需要注意的是，view 和 pure 只适用于函数本身，而不适用于函数调用时传递的参数。如果在调用 view 或 pure 函数时传递了状态变量或存储器引用，编译器会报错。

十、memory

在 Solidity 中，memory 是一种特殊类型的数据存储位置。当我们在函数内部声明一个变量时，这个变量的数据通常被存储在函数的栈帧内。但是，如果我们声明一个类型为 memory 的变量，则数据将存储在函数的临时内存中，而不是栈帧中。

通常情况下，memory 数据存储位置通常用于处理临时变量和临时数据数组，这些数据只需要在函数调用期间存储，并且不需要被存储在区块链上。

例如，以下是一个示例函数，该函数使用 memory 存储位置声明了一个字符串变量：

function concatenate(string memory a, string memory b) pure public returns (string memory) {
    bytes memory bytes_a = bytes(a);
    bytes memory bytes_b = bytes(b);
    string memory result = new string(bytes_a.length + bytes_b.length);
    bytes memory bytes_result = bytes(result);
    uint k = 0;
    for (uint i = 0; i < bytes_a.length; i++) bytes_result[k++] = bytes_a[i];
    for (uint i = 0; i < bytes_b.length; i++) bytes_result[k++] = bytes_b[i];
    return string(bytes_result);
}

在这个示例中，我们使用 memory 存储位置声明了三个字符串变量：a、b 和 result。这些变量的数据将被存储在函数的临时内存中，并在函数调用完成后销毁。

需要注意的是，memory 变量只能在函数内部使用，并且不能被存储在区块链上。如果我们需要在智能合约中存储数据，我们应该使用 storage 存储位置。