[Solidity 入門] データ型 徹底攻略！

// SPDX-License-Identifier: MIT

pragma solidity 0.5.2
pragma solidity ^0.5.2;
pragma solidity >=0.8.2 < 0.9.0;

import "CommonLibrary.sol";

import * as symbolName from "CommonLibrary.sol";
import "CommonLibrary.sol" as symbolName;

// 単一行コメント

/*
複数行
コメント
*/

// ↓Natspecコメント
/// @title A simulator for trees
/// @author Larry A. Gardner
/// @notice You can use this contract for only the most basic simulation
/// @dev All function calls are currently implemented without side effects
/// @custom:experimental This is an experimental contract.
contract Tree {
    /// @notice Calculate tree age in years, rounded up, for live trees
    /// @dev The Alexandr N. Tetearing algorithm could increase precision
    /// @param rings The number of rings from dendrochronological sample
    /// @return Age in years, rounded up for partial years
    function age(uint256 rings) external virtual pure returns (uint256) {
        return rings + 1;
    }

    /// @notice Returns the amount of leaves the tree has.
    /// @dev Returns only a fixed number.
    function leaves() external virtual pure returns(uint256) {
        return 2;
    }
}

pragma solidity 0.4.19;

contract firstContract {
}
contract secondContract {
}
library stringLibrary {
}
library mathLibrary {
}
interface IBank {
}
interface IAccount {
}

int[5] intArrays; // 5つのサイズが割り当てられたint型固定配列
byte[128] flags; // 128のサイズが割り当てられたbyte型固定配列

// 宣言時に初期化するパターン
int[5] intArrays = [int(10),20,30,40,50];

// 変数宣言と初期化を分けるパターン
int[5] intArrays;
intArrays = [int(10),20,30,40,50];

int[] intArrays; // int型動的配列の宣言
byte[] flags; // byte型動的配列の宣言

// 宣言時に初期化するパターン
int[] intArrays = [int(10),20,30,40,50,60,70,80,90,100];
int[] intArrays = new int[](10);

// 変数宣言と初期化を分けるパターン
int[] intArrays;
intArrays = new int[](10);

bytes localBytes = new bytes(0); // 初期データ長を指定して状態変数として宣言する例
localBytes = new bytes(10); // 配列の割り当て
localBytes = "4engineer.net" // 文字列を代入する
localBytes.push(0x32); // 値の追加
localBytes.length; // 長さの取得
localBytes.length = 4; // 長さを4バイトに設定する

string name = "Goichi"; // 文字列の宣言
bytes bytesName = bytes(name); // バイト配列への変換

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.9.0;

// Defines a new type with two fields.
// Declaring a struct outside of a contract allows
// it to be shared by multiple contracts.
// Here, this is not really needed.
struct Funder {
    address addr;
    uint amount;
}

contract CrowdFunding {
    // Structs can also be defined inside contracts, which makes them
    // visible only there and in derived contracts.
    struct Campaign {
        address payable beneficiary;
        uint fundingGoal;
        uint numFunders;
        uint amount;
        mapping (uint => Funder) funders;
    }

    uint numCampaigns;
    mapping (uint => Campaign) campaigns;

    function newCampaign(address payable beneficiary, uint goal) public returns (uint campaignID) {
        campaignID = numCampaigns++; // campaignID is return variable
        // We cannot use "campaigns[campaignID] = Campaign(beneficiary, goal, 0, 0)"
        // because the right hand side creates a memory-struct "Campaign" that contains a mapping.
        Campaign storage c = campaigns[campaignID];
        c.beneficiary = beneficiary;
        c.fundingGoal = goal;
    }

    function contribute(uint campaignID) public payable {
        Campaign storage c = campaigns[campaignID];
        // Creates a new temporary memory struct, initialised with the given values
        // and copies it over to storage.
        // Note that you can also use Funder(msg.sender, msg.value) to initialise.
        c.funders[c.numFunders++] = Funder({addr: msg.sender, amount: msg.value});
        c.amount += msg.value;
    }

    function checkGoalReached(uint campaignID) public returns (bool reached) {
        Campaign storage c = campaigns[campaignID];
        if (c.amount < c.fundingGoal)
            return false;
        uint amount = c.amount;
        c.amount = 0;
        c.beneficiary.transfer(amount);
        return true;
    }
}

contract MappingExample {
    mapping (uint => string) map;

    function put(uint key, string memory value) public {
        map[key] = value;
    }

    function get(uint key) public view returns(string memory) {
        return map[key];
    }
}