[
    {
        "name": "ABS",
        "desc": "数値から符号を除いた絶対値を返す。",
        "form": "ABS(数値)",
        "arg": [
            "数値"
        ],
        "arg_desc": [
            "必須。絶対値を求める実数を指定する。"
        ],
        "example": [
            ["=ABS(5)", "=ABS(-5)"]
        ],
        "example_sup": "実行結果はどちらも5になる。",
        "tag": ["ABS", "絶対", "絶対数", "絶対値", "実数", "符号"]
    },
    {
        "name": "AGGREGATE",
        "desc": "範囲内の集計値を返す。",
        "form": "AGGREGATE(集計方法, オプション, 範囲1, [範囲2], …)",
        "arg": [
            "集計方法",
            "オプション",
            "範囲1",
            "範囲2"
        ],
        "arg_desc": [
            "必須。使用する関数を指定する1～19の番号。「1=AVERAGE」「2=COUNT」「3=COUNTA」「4=MAX」「5=MIN」「6=PRODUCT」「7=STDEV.S」「8=STDEV.P」「9=SUM」「10=VAR.S」「11=VAR.P」「12=MEDIAN」「13=MODE.SNGL」「14=LARGE」「15=SMALL」「16=PERCENTILE.INC」「17=QUARTILE.INC」「18=PERCENTILE.EXC」「19=QUARTILE.EXC」",
            "必須。無視する値を指定する数値。「0または省略=ネストされたSUBTOTAL関数とAGGREGATE関数を無視」「1=非表示の行、ネストされたSUBTOTAL関数とAGGREGATE関数を無視」「2=エラー値、ネストされたSUBTOTAL関数とAGGREGATE関数を無視」「3=非表示の行、エラー値、ネストされたSUBTOTAL関数とAGGREGATE関数を無視」「4=何も無視しない」「5=非表示の行を無視」「6=エラー値を無視」「7=非表示の行とエラー値を無視」",
            "必須。複数の数値引数を受け取る関数の数値引数。",
            "任意。数値引数2～253を指定。"
        ],
        "example": [
            ["1", "2"],
            ["3", "4"],
            ["=AGGREGATE(14,6,A1:B2,2)"]
        ],
        "example_sup": "実行結果は2番目に大きい数値である3になる。",
        "tag": ["AGGREGATE", "集計"]
    },
    {
        "name": "AND",
        "desc": "すべての条件がTRUEかどうかを調べる。",
        "form": "AND(論理式1, [論理式2], …)",
        "arg": [
            "論理式1",
            "論理式2, …"
        ],
        "arg_desc": [
            "必須",
            "任意"
        ],
        "example": [
            ["100"],
            ["=AND(A1>0,A1<101)"]
        ],
        "example_sup": "実行結果はTRUEになる。",
        "tag": ["AND", "条件", "TRUE"]
    },
    {
        "name": "ARABIC",
        "desc": "ローマ数字をアラビア数字に変換する。",
        "form": "ARABIC(文字列)",
        "arg": [
            "文字列"
        ],
        "arg_desc": [
            "必須。半角の文字列、または文字列を含むセル。"
        ],
        "example": [
            ["=ARABIC(\"V\")"]
        ],
        "example_sup": "実行結果は5になる。",
        "tag": ["ARABIC", "変換", "ローマ", "ローマ字", "ローマ数字", "アラビア", "アラビア数字"]
    },
    {
        "name": "AVERAGE",
        "desc": "引数の平均（算術平均）を返す。",
        "form": "AVERAGE(数値1, [数値2], …)",
        "arg": [
            "数値1",
            "数値2, …"
        ],
        "arg_desc": [
            "必須。数値、セル参照またはセル範囲。",
            "任意。追加の数値、セル参照または範囲。（最大255）"
        ],
        "example": [
            ["1"],
            ["2"],
            ["=AVERAGE(A1:A2)"]
        ],
        "example_sup": "実行結果は1.5になる。",
        "tag": ["AVERAGE", "平均", "算術平均"]
    },
    {
        "name": "AVERAGEA",
        "desc": "引数の平均（算術平均）を返す。TRUEは1、FALSEは0、文字列は0として判定する。",
        "form": "AVERAGEA(値1, [値2], …)",
        "arg": [
            "値1",
            "値2, …"
        ],
        "arg_desc": [
            "必須。数値、セル参照またはセル範囲。",
            "任意。追加の数値、セル参照または範囲。（最大255）"
        ],
        "example": [
            ["0"],
            ["100"],
            ["TRUE"],
            ["FALSE"],
            ["失格"],
            ["=AVERAGEA(A1:A5)"]
        ],
        "example_sup": "実行結果は20.2になる。",
        "tag": ["AVERAGEA", "平均", "算術平均"]
    },
    {
        "name": "BIN2DEC",
        "desc": "2進数を10進数に変換する。",
        "form": "BIN2DEC(数値)",
        "arg": [
            "数値"
        ],
        "arg_desc": [
            "必須。変換する2進数を指定。数値に指定できる文字数は10文字（10ビット）まで。"
        ],
        "example": [
            ["=BIN2DEC(1010)"]
        ],
        "example_sup": "実行結果は10になる。",
        "tag": ["BIN2DEC", "2進数", "10進数", "変換"]
    },
    {
        "name": "BIN2HEX",
        "desc": "2進数を16進数に変換します。",
        "form": "BIN2HEX(数値, [桁数])",
        "arg": [
            "数値",
            "桁数"
        ],
        "arg_desc": [
            "必須。変換する2進数を指定。数値に指定できる文字数は10文字（10ビット）まで。",
            "任意。使用する文字数を指定。桁数を省略すると、必要最小限の桁数で結果が返される。"
        ],
        "example": [
            ["=BIN2HEX(1010,5)"]
        ],
        "example_sup": "実行結果は0000Aになる。",
        "tag": ["BIN2HEX", "2進数", "16進数", "変換"]
    },
    {
        "name": "BIN2OCT",
        "desc": "2進数を8進数に変換する。",
        "form": "BIN2OCT(数値, [桁数])",
        "arg": [
            "数値",
            "桁数"
        ],
        "arg_desc": [
            "必須。変換する2進数を指定する。数値に指定できる文字数は10文字（10ビット）まで。",
            "任意。使用する文字数を指定する。桁数を省略すると、必要最小限の桁数で結果が返される。"
        ],
        "example": [
            ["=BIN2OCT(1010,5)"]
        ],
        "example_sup": "実行結果は00012になる。",
        "tag": ["BIN2OCT", "2進数", "8進数", "変換"]
    },
    {
        "name": "CEILING.MATH",
        "desc": "数値を最も近い整数、または基準値の倍数で最も近い数に切り上げる。",
        "form": "CEILING.MATH(数値, [基準値], [モード])",
        "arg": [
            "数値",
            "基準値",
            "モード"
        ],
        "arg_desc": [
            "必須",
            "任意。切り上げの対象となる数値の倍数を指定。",
            "任意。0以外の数値の場合は、0から離れ他整数に切り上げられる。"
        ],
        "example": [
            ["=CEILING.MATH(10.2, 2)"],
            ["=CEILING.MATH(-10.2, 2, 1)"]
        ],
        "example_sup": "A1の実行結果は12、A2の実行結果は-12になる。",
        "tag": ["CEILING.MATH", "整数", "倍数", "切り上げ"]
    },
    {
        "name": "CELL",
        "desc": "セルの書式、位置、または内容に関する情報を返す。",
        "form": "CELL(検査の種類, [対象範囲])",
        "arg": [
            "検査の種類",
            "対象範囲"
        ],
        "arg_desc": [
            "必須。返すセル情報の種類。",
            "任意。情報が必要なセル。省略した場合、最後に変更されたセルについての情報を返す。対象範囲がセル範囲の場合、左上隅のセルについての情報だけを返す。"
        ],
        "example": [
            ["1"],
            ["=CELL(\"address\",A1)"],
            ["=CELL(\"col\",A1)"],
            ["=CELL(\"color\",A1)"],
            ["=CELL(\"contents\",A1)"],
            ["=CELL(\"filename\",A1)"],
            ["=CELL(\"format\",A1)"],
            ["=CELL(\"parentheses\",A1)"],
            ["=CELL(\"prefix\",A1)"],
            ["=CELL(\"protect\",A1)"],
            ["=CELL(\"row\",A1)"],
            ["=CELL(\"type\",A1)"],
            ["=CELL(\"width\",A1)"]
        ],
        "example_sup": "A2の実行結果は$A$1、A3は1、A4は0、A5は5、A6は空文字、A7はG、A8は0、A9は空文字、A10は1、A11は1、A12はv、A13は8になる。",
        "tag": ["CELL", "セル", "書式", "位置", "情報"]
    },
    {
        "name": "CHOOSE",
        "desc": "インデックスを使用して値引数のリストから値を返す。",
        "form": "CHOOSE(インデックス, 値1, [値2], …)",
        "arg": [
            "インデックス",
            "値1, 値2, …"
        ],
        "arg_desc": [
            "必須。どの値引数が選択されるかを指定。",
            "値1は必須。値2以降は任意。数値、セル参照、定義名、数式、関数、文字列を指定。"
        ],
        "example": [
            ["日"],
            ["月"],
            ["火"],
            ["水"],
            ["木"],
            ["金"],
            ["土"],
            ["=CHOOSE(2,A1,A2,A3,A4,A5,A6,A7)"]
        ],
        "example_sup": "A8の実行結果は月になる。",
        "tag": ["CHOOSE", "インデックス", "値"]
    },
    {
        "name": "COMBIN",
        "desc": "指定された個数を選択するときの組み合わせの数を返す。",
        "form": "COMBIN(総数, 抜き取り数)",
        "arg": [
            "総数",
            "抜き取り数"
        ],
        "arg_desc": [
            "必須。抜き取る対象の全体の数。",
            "必須。抜き取る組み合わせ1組に含まれる項目の数。"
        ],
        "example": [
            ["佐藤", ""],
            ["鈴木", ""],
            ["高橋", ""],
            ["田中", ""],
            ["伊藤", ""],
            ["=COUNTA(A1:A5)", "=COMBIN(A6,2)"]
        ],
        "example_sup": "B6の実行結果は10になる。（A6の実行結果は5）",
        "tag": ["COMBIN", "個数", "組み合わせ", "組合せ", "組合わせ"]
    },
    {
        "name": "COMBINA",
        "desc": "指定された個数を選択するときの組み合わせ（反復あり）の数を返す。",
        "form": "COMBINA(総数, 抜き取り数)",
        "arg": [
            "総数",
            "抜き取り数"
        ],
        "arg_desc": [
            "必須。抜き取る対象の全体の数。",
            "必須。抜き取る組み合わせ1組に含まれる項目の数。"
        ],
        "example": [
            ["佐藤", ""],
            ["鈴木", ""],
            ["高橋", ""],
            ["田中", ""],
            ["伊藤", ""],
            ["=COUNTA(A1:A5)", "=COMBINA(A6,2)"]
        ],
        "example_sup": "B6の実行結果は15になる。（A6の実行結果は5）",
        "tag": ["COMBINA", "個数", "組み合わせ", "組合せ", "組合わせ", "反復"]
    },
    {
        "name": "CONCAT",
        "desc": "テキストを結合する。",
        "form": "CONCAT(テキスト1, [テキスト2], …)",
        "arg": [
            "テキスト1",
            "テキスト2, …"
        ],
        "arg_desc": [
            "必須。結合するテキスト項目。文字列またはセルの範囲などの文字列の配列。",
            "任意。結合する追加のテキスト項目。"
        ],
        "example": [
            ["佐藤", "太郎", "=CONCAT(A1,B1)"]
        ],
        "example_sup": "C1の実行結果は佐藤太郎になる。",
        "tag": ["CONCAT", "テキスト", "結合"]
    },
    {
        "name": "CONVERT",
        "desc": "数値の単位を変換する。",
        "form": "CONVERT(数値, 変換前単位, 変換後単位)",
        "arg": [
            "数値",
            "変換前単位",
            "変換後単位"
        ],
        "arg_desc": [
            "必須。変換する値。",
            "必須。変換する値の単位。",
            "必須。変換後の単位。"
        ],
        "example": [
            ["1", "日"],
            ["=CONVERT(A1, \"d\", \"min\")", "分"]
        ],
        "example_sup": "A2の実行結果は1440になる。",
        "tag": ["CONVERT", "数値", "単位", "変換"]
    },
    {
        "name": "COUNT",
        "desc": "数値を含むセルの個数、および引数リストに含まれる数値の個数を返す。",
        "form": "COUNT(値1, [値2], …)",
        "arg": [
            "値1",
            "値2, …"
        ],
        "arg_desc": [
            "必須。数値の個数を調べる1つ目の項目、セル参照、またはセル範囲。",
            "任意"
        ],
        "example": [
            ["1"],
            ["2"],
            ["2019/1/1"],
            ["#DIV/0!"],
            ["=COUNT(A1:A4)"]
        ],
        "example_sup": "A5の実行結果は3になる。",
        "tag": ["COUNT", "数値", "セル", "個数", "含まれる", "含む"]
    },
    {
        "name": "COUNTA",
        "desc": "範囲に含まれる空白ではないセルの個数を返します。",
        "form": "COUNTA(値1, [値2], …)",
        "arg": [
            "値1",
            "値2, …"
        ],
        "arg_desc": [
            "必須。個数を調べる1つ目の項目、セル参照、またはセル範囲。",
            "任意"
        ],
        "example": [
            ["1"],
            ["2"],
            ["2019/1/1"],
            ["#DIV/0!"],
            [""],
            ["=COUNTA(A1:A5)"]
        ],
        "example_sup": "A6の実行結果は4になる。",
        "tag": ["COUNTA", "範囲", "空白", "セル", "個数", "含まれる", "含む"]
    },
    {
        "name": "COUNTBLANK",
        "desc": "範囲に含まれる空白セルの個数を返す。",
        "form": "COUNTBLANK(範囲)",
        "arg": [
            "範囲"
        ],
        "arg_desc": [
            "必須。空白セルの個数を求めるセル範囲。"
        ],
        "example": [
            ["1"],
            ["2"],
            ["2019/1/1"],
            ["#DIV/0!"],
            [""],
            ["=COUNTBLANK(A1:A5)"]
        ],
        "example_sup": "A6の実行結果は1になる。",
        "tag": ["COUNTBLANK", "範囲", "空白", "セル", "個数", "含まれる", "含む"]
    },
    {
        "name": "COUNTIF",
        "desc": "1つの検索条件に一致するセルの個数を返す。",
        "form": "COUNTIF(範囲, 検索条件)",
        "arg": [
            "範囲",
            "検索条件"
        ],
        "arg_desc": [
            "必須。数えるセルの範囲。",
            "必須。検索条件を数値、式、セル参照、または文字列で指定。"
        ],
        "example": [
            ["iPhone", "iPad"],
            ["iPad", ""],
            ["iPhone", ""],
            ["=COUNTIF(A1:A3, B1)", ""]
        ],
        "example_sup": "A4の実行結果は1になる。",
        "tag": ["COUNTIF", "1つ", "検索条件", "検索", "条件", "一致", "セル", "個数"]
    },
    {
        "name": "COUNTIFS",
        "desc": "すべての検索条件に一致するセルの個数を返す。",
        "form": "COUNTIFS(条件範囲1, 検索条件1, [条件範囲2, 検索条件2], …)",
        "arg": [
            "条件範囲1",
            "検索条件1",
            "条件範囲2, 検索条件2, …"
        ],
        "arg_desc": [
            "必須。対象となる最初の範囲。",
            "必須。検索条件を数値、式、セル参照、または文字列で指定。",
            "任意。追加の検索条件。"
        ],
        "example": [
            ["1", "2", "3", "4", "5"],
            ["=COUNTIFS(A1:E1, \">3\", A1:E1, \"<5\")"]
        ],
        "example_sup": "A2の実行結果は1になる。",
        "tag": ["COUNTIF", "すべて", "全て", "検索条件", "検索", "条件", "一致", "セル", "個数"]
    },
    {
        "name": "DATEDIF",
        "desc": "日付間の日数、月数、または年数を計算する。",
        "form": "DATEDIF(開始日, 終了日, 単位)",
        "arg": [
            "開始日",
            "終了日",
            "単位"
        ],
        "arg_desc": [
            "必須。開始日を表す日付。",
            "必須。終了日の日付を表す日付。",
            "必須。単位。"
        ],
        "example": [
            ["2000/1/1", "2010/2/2"],
            ["=DATEDIF(A1, B1, \"Y\")"],
            ["=DATEDIF(A1, B1, \"M\")"],
            ["=DATEDIF(A1, B1, \"D\")"],
            ["=DATEDIF(A1, B1, \"MD\")"],
            ["=DATEDIF(A1, B1, \"YM\")"],
            ["=DATEDIF(A1, B1, \"YD\")"]
        ],
        "example_sup": "A2の実行結果は10、A3は121、A4は3685、A5は1、A6は1、A7は32になる。",
        "tag": ["DATEDIF", "日付間", "日付", "日数", "月数", "年数", "計算"]
    },
    {
        "name": "DAYS",
        "desc": "2つの日付間の日数を返します。",
        "form": "DAYS(終了日, 開始日)",
        "arg": [
            "終了日",
            "開始日"
        ],
        "arg_desc": [
            "必須。終了日の日付を表す日付。",
            "必須。開始日を表す日付。"
        ],
        "example": [
            ["=DAYS(\"2010/2/2\", \"2000/1/1\")"]
        ],
        "example_sup": "A1の実行結果は3685になる。",
        "tag": ["DAYS", "2つ", "日付間", "日数"]
    },
    {
        "name": "DEC2BIN",
        "desc": "10進数を2進数に変換する。",
        "form": "DEC2BIN(数値, [桁数])",
        "arg": [
            "数値",
            "桁数"
        ],
        "arg_desc": [
            "必須。変換する10進数の整数。",
            "任意。使用する文字数。"
        ],
        "example": [
            ["=DEC2BIN(10, 5)"]
        ],
        "example_sup": "A1の実行結果は01010になる。",
        "tag": ["DEC2BIN", "10進数", "2進数", "変換"]
    },
    {
        "name": "DEC2HEX",
        "desc": "10進数を16進数に変換する。",
        "form": "DEC2HEX(数値, [桁数])",
        "arg": [
            "数値",
            "桁数"
        ],
        "arg_desc": [
            "必須。変換する10進数の整数。",
            "任意。使用する文字数。"
        ],
        "example": [
            ["=DEC2HEX(10, 5)"]
        ],
        "example_sup": "A1の実行結果は0000Aになる。",
        "tag": ["DEC2HEX", "10進数", "16進数", "変換"]
    },
    {
        "name": "DEC2OCT",
        "desc": "10進数を8進数に変換する。",
        "form": "DEC2OCT(数値, [桁数])",
        "arg": [
            "数値",
            "桁数"
        ],
        "arg_desc": [
            "必須。変換する10進数の整数。",
            "任意。使用する文字数。"
        ],
        "example": [
            ["=DEC2OCT(10, 5)"]
        ],
        "example_sup": "A1の実行結果は00012になる。",
        "tag": ["DEC2OCT", "10進数", "8進数", "変換"]
    },
    {
        "name": "DELTA",
        "desc": "2つの値が等しいかどうかを調べる。",
        "form": "DELTA(数値1, [数値2])",
        "arg": [
            "数値1",
            "数値2"
        ],
        "arg_desc": [
            "必須",
            "任意。省略すると0扱いになる。"
        ],
        "example": [
            ["=DELTA(1, 1)"],
            ["=DELTA(1, 0)"],
            ["=DELTA(1)"]
        ],
        "example_sup": "A1の実行結果は1、A2は0、A3は0になる。",
        "tag": ["DELTA", "2つ", "値", "等しい", "調べる"]
    },
    {
        "name": "ENCODEURL",
        "desc": "URLでエンコードされた文字列を返す。",
        "form": "ENCODEURL(文字列)",
        "arg": [
            "文字列"
        ],
        "arg_desc": [
            "必須。URL形式でエンコードする文字列。"
        ],
        "example": [
            ["=ENCODEURL(\"http://example.com/\")"]
        ],
        "example_sup": "A1の実行結果はhttp%3A%2F%2Fexample.com%2F0になる。",
        "tag": ["ENCODEURL", "URL", "エンコード", "文字列"]
    },
    {
        "name": "EVEN",
        "desc": "指定した数値を最も近い偶数に切り上げた数値を返す。",
        "form": "EVEN(数値)",
        "arg": [
            "数値"
        ],
        "arg_desc": [
            "必須。丸めの対象となる数値。"
        ],
        "example": [
            ["=EVEN(1.2)"],
            ["=EVEN(-1.2)"],
            ["=EVEN(2.8)"],
            ["=EVEN(-2.8)"]
        ],
        "example_sup": "A1の実行結果は2、A2は-2、A3は4、A4は-4になる。",
        "tag": ["EVEN", "数値", "偶数", "切り上げ"]
    },
    {
        "name": "EXACT",
        "desc": "2つの文字列を比較して同じの場合はTRUE、そうでない場合はFALSEを返す。",
        "form": "EXACT(文字列1, 文字列2)",
        "arg": [
            "文字列1",
            "文字列2"
        ],
        "arg_desc": [
            "必須",
            "必須"
        ],
        "example": [
            ["○", ""],
            ["○", "=EXACT(A1, A2)"],
            ["×", "=EXACT(A1, A3)"]
        ],
        "example_sup": "A2の実行結果はTRUE、A3はFALSEになる。",
        "tag": ["EXACT", "2つ", "文字列", "比較", "同じ", "TRUE", "FALSE"]
    },
    {
        "name": "FIXED",
        "desc": "数値を四捨五入し、結果をピリオドとカンマで整形した文字列に変換する。",
        "form": "FIXED(数値, [桁数], [桁区切り])",
        "arg": [
            "数値",
            "桁数",
            "桁区切り"
        ],
        "arg_desc": [
            "必須。変換する数値。",
            "任意。小数点以下の桁数。",
            "任意。桁区切りするかどうか。"
        ],
        "example": [
            ["1000.567"],
            ["=FIXED(A1)"],
            ["=FIXED(A1, 0)"],
            ["=FIXED(A3, 0, TRUE)"]
        ],
        "example_sup": "A2の実行結果は1,000.57、A3は1,001、A4は1001になる。",
        "tag": ["FIXED", "数値", "四捨五入", "ピリオド", "カンマ", "整形", "文字列", "変換"]
    },
    {
        "name": "FLOOR.MATH",
        "desc": "数値を、指定された倍数のうち最も近い値に切り捨てる。",
        "form": "FLOOR.MATH(数値, [基準値], [モード])",
        "arg": [
            "数値",
            "基準値",
            "モード"
        ],
        "arg_desc": [
            "必須。丸める数値。",
            "任意。基準になる倍数。",
            "任意。0または負の数値を指定すると0とは逆の方向に丸める。"
        ],
        "example": [
            ["=FLOOR.MATH(3.5, 2)"]
        ],
        "example_sup": "A1の実行結果は2になる。",
        "tag": ["FLOOR.MATH", "FLOOR", "MATH", "数値", "基準値", "倍数", "切り捨て", "切捨"]
    },
    {
        "name": "GCD",
        "desc": "最大公約数を返す。",
        "form": "GCD(数値1, [数値2], …)",
        "arg": [
            "数値1",
            "[数値2], …"
        ],
        "arg_desc": [
            "必須",
            "任意"
        ],
        "example": [
            ["=GCD(4, 10)"]
        ],
        "example_sup": "A1の実行結果は2になる。",
        "tag": ["GCD", "数値", "最大公約数", "公約数"]
    },
    {
        "name": "HEX2BIN",
        "desc": "16進数を2進数に変換する。",
        "form": "HEX2BIN(数値, [桁数])",
        "arg": [
            "数値",
            "桁数"
        ],
        "arg_desc": [
            "必須。変換する16進数",
            "任意。使用する文字数"
        ],
        "example": [
            ["=HEX2BIN(2, 5)"]
        ],
        "example_sup": "A1の実行結果は00010になる。",
        "tag": ["HEX2BIN", "数値", "桁数", "16進数", "2進数"]
    },
    {
        "name": "HEX2DEC",
        "desc": "16進数を10進数に変換する。",
        "form": "HEX2DEC(数値, [桁数])",
        "arg": [
            "数値"
        ],
        "arg_desc": [
            "必須。変換する16進数"
        ],
        "example": [
            ["=HEX2DEC(10)"]
        ],
        "example_sup": "A1の実行結果は16になる。",
        "tag": ["HEX2DEC", "数値", "桁数", "16進数", "10進数"]
    },
    {
        "name": "HEX2OCT",
        "desc": "16進数を8進数に変換する。",
        "form": "HEX2OCT(数値, [桁数])",
        "arg": [
            "数値",
            "桁数"
        ],
        "arg_desc": [
            "必須。変換する16進数",
            "任意。使用する文字数"
        ],
        "example": [
            ["=HEX2OCT(10)"]
        ],
        "example_sup": "A1の実行結果は20になる。",
        "tag": ["HEX2OCT", "数値", "桁数", "16進数", "8進数"]
    },
    {
        "name": "HLOOKUP",
        "desc": "テーブルまたは配列内の指定行を検索して値を返す。",
        "form": "HLOOKUP(検索値, 範囲, 行番号, [検索の型])",
        "arg": [
            "検索値",
            "範囲",
            "行番号",
            "検索の型"
        ],
        "arg_desc": [
            "必須。検索する値、参照、文字列",
            "必須。検索範囲",
            "必須。検索範囲の行番号",
            "任意。TRUEまたは省略で近似値、FALSEで完全一致"
        ],
        "example": [
            ["ミカン", "=HLOOKUP(A1, A3:C4, 2,  FALSE)"],
            ["", ""],
            ["リンゴ", "ミカン"],
            ["100円", "200円"]
        ],
        "example_sup": "B1の実行結果は200円になる。",
        "tag": ["HLOOKUP", "LOOKUP", "検索", "行", "近似値", "完全一致"]
    },
    {
        "name": "HYPERLINK",
        "desc": "リンクを設定する。",
        "form": "HYPERLINK(リンク先, [別名])",
        "arg": [
            "リンク先",
            "別名"
        ],
        "arg_desc": [
            "必須。URL、ドキュメントのパスとファイル名、セルなど",
            "任意。セルに表示する文字列または数値"
        ],
        "example": [
            ["=HYPERLINK(\"http://example.com/\", \"リンク\")"]
        ],
        "example_sup": "A1の実行結果はリンクになる。",
        "tag": ["HYPERLINK", "リンク", "URL", "パス", "LINK"]
    },
    {
        "name": "IF",
        "desc": "条件によって処理をわける。",
        "form": "IF(論理式, [値が真の場合], [値が偽の場合])",
        "arg": [
            "論理式",
            "値が真の場合",
            "値が偽の場合"
        ],
        "arg_desc": [
            "必須。条件",
            "必須。条件に合う場合に返す値",
            "任意。条件に合わない場合に返す値"
        ],
        "example": [
            ["=IF(A2>1, \"2以上です\", \"1以下です\")"],
            ["2"]
        ],
        "example_sup": "A1の実行結果は2以上ですになる。",
        "tag": ["IF", "条件", "もしも", "真", "偽"]
    },
    {
        "name": "IFERROR",
        "desc": "エラーの場合に指定した値を返す。",
        "form": "IFERROR(値, エラーの場合の値)",
        "arg": [
            "値",
            "エラーの場合の値"
        ],
        "arg_desc": [
            "必須。条件",
            "任意。エラーの場合の値"
        ],
        "example": [
            ["=IFERROR(A2, \"間違っています\")"],
            ["#DIV/0!"]
        ],
        "example_sup": "A1の実行結果は間違っていますになる。",
        "tag": ["IF", "ERROR", "IFERROR", "条件", "もしも", "真", "偽", "エラー"]
    },
    {
        "name": "IFS",
        "desc": "条件によって処理をわける。複数の条件に一致しているかどうかを調べる。",
        "form": "IF(論理式, 値が真の場合, [論理式], [値が真の場合], …)",
        "arg": [
            "論理式",
            "値が真の場合",
            "[論理式], [値が真の場合], …"
        ],
        "arg_desc": [
            "必須。条件",
            "必須。条件に合う場合に返す値",
            "任意"
        ],
        "example": [
            ["10", "=IFS(A1>99, \"上\", A1>9, \"下\")"],
            ["100", "=IFS(A2>99, \"上\", A2>9, \"下\")"]
        ],
        "example_sup": "B1の実行結果は下、B2の実行結果は上になる。",
        "tag": ["IF", "IFS", "条件", "もしも", "真", "偽", "複数"]
    },
    {
        "name": "INDEX",
        "desc": "指定した行番号と列番号に一致する要素の値を返す。",
        "form": "INDEX(配列, 行番号, [列番号])",
        "arg": [
            "配列",
            "行番号",
            "列番号"
        ],
        "arg_desc": [
            "必須。セル範囲",
            "必須。行番号",
            "任意。列番号"
        ],
        "example": [
            ["=INDEX(A2:B3, 2, 1)", ""],
            ["赤", "青"],
            ["黄", "緑"]
        ],
        "example_sup": "A1の実行結果は黄になる。",
        "tag": ["INDEX", "行", "列", "行番号", "列番号"]
    },
    {
        "name": "INDIRECT",
        "desc": "文字列への参照を返す。",
        "form": "INDIRECT(参照文字列, [参照形式])",
        "arg": [
            "参照文字列",
            "参照形式"
        ],
        "arg_desc": [
            "必須。参照先を文字列で指定。",
            "任意。TRUEまたは省略でA1形式、FALSEでR1C1形式のセル参照。"
        ],
        "example": [
            ["=INDIRECT(B1)", "A3"],
            ["田中", "山田"],
            ["佐藤", "鈴木"]
        ],
        "example_sup": "A1の実行結果は佐藤になる。",
        "tag": ["INDIRECT", "参照", "文字列"]
    },
    {
        "name": "INT",
        "desc": "数値を最も近い整数に切り捨てる。",
        "form": "INT(数値)",
        "arg": [
            "数値"
        ],
        "arg_desc": [
            "必須"
        ],
        "example": [
            ["1.1", "=INT(A1)"],
            ["-1.1", "=INT(A2)"]
        ],
        "example_sup": "B1の実行結果は1、B2の実行結果は-2になる。",
        "tag": ["INT", "数値", "整数", "切り捨て", "切捨"]
    },
    {
        "name": "ISBLANK",
        "desc": "対象のセルが空白の場合にTRUEを返す。",
        "form": "ISBLANK(対象)",
        "arg": [
            "対象"
        ],
        "arg_desc": [
            "必須"
        ],
        "example": [
            ["=ISBLANK(A3)", ""],
            ["○", "○"],
            ["", "○"]
        ],
        "example_sup": "A1の実行結果はTRUEになる。",
        "tag": ["ISBLANK", "BLANK", "空白"]
    },
    {
        "name": "ISERR",
        "desc": "対象が#N/A以外のエラーの場合にTRUEを返す。",
        "form": "ISERR(対象)",
        "arg": [
            "対象"
        ],
        "arg_desc": [
            "必須"
        ],
        "example": [
            ["#N/A", "=ISERR(A1)"],
            ["#DIV/0!", "=ISERR(A2)"],
            ["#REF!", "=ISERR(A3)"],
            ["#VALUE!", "=ISERR(A4)"],
            ["#NUM!", "=ISERR(A5)"],
            ["#NAME?", "=ISERR(A6)"],
            ["#NULL!", "=ISERR(A7)"]
        ],
        "example_sup": "B1の実行結果はFALSE、それ以外はTRUEになる。",
        "tag": ["ISERR", "ERR", "エラー", "#N/A"]
    },
    {
        "name": "ISERROR",
        "desc": "対象がエラーの場合にTRUEを返す。",
        "form": "ISERROR(対象)",
        "arg": [
            "対象"
        ],
        "arg_desc": [
            "必須"
        ],
        "example": [
            ["#N/A", "=ISERROR(A1)"],
            ["#DIV/0!", "=ISERROR(A2)"],
            ["#REF!", "=ISERROR(A3)"],
            ["#VALUE!", "=ISERROR(A4)"],
            ["#NUM!", "=ISERROR(A5)"],
            ["#NAME?", "=ISERROR(A6)"],
            ["#NULL!", "=ISERROR(A7)"]
        ],
        "example_sup": "B1～B7の実行結果は全てTRUEになる。",
        "tag": ["ISERROR", "ERROR", "エラー", "#N/A", "#DIV/0!", "#REF!", "#VALUE!", "#NUM!", "#NAME?", "#NULL!"]
    },
    {
        "name": "ISEVEN",
        "desc": "数値が偶数の場合にTRUEを返す。",
        "form": "ISEVEN(数値)",
        "arg": [
            "数値"
        ],
        "arg_desc": [
            "必須。小数点以下は切り捨て"
        ],
        "example": [
            ["1", "=ISEVEN(A1)"],
            ["-1", "=ISEVEN(A2)"],
            ["2", "=ISEVEN(A3)"],
            ["2.2", "=ISEVEN(A4)"]
        ],
        "example_sup": "B1とB2の実行結果はFALSE、B3とB4の実行結果はTRUEになる。",
        "tag": ["ISEVEN", "EVEN", "偶数"]
    },
    {
        "name": "ISFORMULA",
        "desc": "数式を含むセル参照の場合にTRUEを返す。",
        "form": "ISFORMULA(範囲)",
        "arg": [
            "範囲"
        ],
        "arg_desc": [
            "必須"
        ],
        "example": [
            ["=TODAY()", "=ISFORMULA(A1)"],
            ["リンゴ", "=ISFORMULA(A2)"],
            ["=A2", "=ISFORMULA(A3)"]
        ],
        "example_sup": "B1とB3の実行結果はTRUE、B2の実行結果はFALSEになる。",
        "tag": ["ISFORMULA", "FORMULA", "数式"]
    },
    {
        "name": "ISLOGICAL",
        "desc": "対象が論理値の場合にTRUEを返す。",
        "form": "ISLOGICAL(対象)",
        "arg": [
            "対象"
        ],
        "arg_desc": [
            "必須"
        ],
        "example": [
            ["TRUE", "=ISLOGICAL(A1)"],
            ["FALSE", "=ISLOGICAL(A2)"],
            ["1", "=ISLOGICAL(A3)"],
            ["0", "=ISLOGICAL(A4)"]
        ],
        "example_sup": "B1とB2の実行結果はTRUE、B3とB4の実行結果はFALSEになる。",
        "tag": ["ISLOGICAL", "LOGICAL", "論理"]
    },
    {
        "name": "ISNA",
        "desc": "対象が#N/Aの場合にTRUEを返す。",
        "form": "ISNA(対象)",
        "arg": [
            "対象"
        ],
        "arg_desc": [
            "必須"
        ],
        "example": [
            ["#N/A", "=ISNA(A1)"],
            ["#DIV/0!", "=ISNA(A2)"],
            ["#REF!", "=ISNA(A3)"],
            ["#VALUE!", "=ISNA(A4)"],
            ["#NUM!", "=ISNA(A5)"],
            ["#NAME?", "=ISNA(A6)"],
            ["#NULL!", "=ISNA(A7)"]
        ],
        "example_sup": "B1の実行結果はTRUE、それ以外は全てFALSEになる。",
        "tag": ["ISNA", "#N/A"]
    },
    {
        "name": "ISNONTEXT",
        "desc": "対象が文字列以外の場合にTRUEを返す。",
        "form": "ISNONTEXT(対象)",
        "arg": [
            "対象"
        ],
        "arg_desc": [
            "必須"
        ],
        "example": [
            ["1", "=ISNONTEXT(A1)"],
            ["リンゴ", "=ISNONTEXT(A2)"]
        ],
        "example_sup": "B1の実行結果はTRUE、B2の実行結果はFALSEになる。",
        "tag": ["ISNONTEXT", "TEXT", "文字列"]
    },
    {
        "name": "ISNUMBER",
        "desc": "対象が数値の場合にTRUEを返す。",
        "form": "ISNUMBER(対象)",
        "arg": [
            "対象"
        ],
        "arg_desc": [
            "必須"
        ],
        "example": [
            ["1", "=ISNUMBER(A1)"],
            ["リンゴ", "=ISNUMBER(A2)"]
        ],
        "example_sup": "B1の実行結果はTRUE、B2の実行結果はFALSEになる。",
        "tag": ["ISNUMBER", "NUMBER", "数値"]
    },
    {
        "name": "ISODD",
        "desc": "数値が奇数の場合にTRUEを返す。",
        "form": "ISODD(数値)",
        "arg": [
            "数値"
        ],
        "arg_desc": [
            "必須。小数点以下は切り捨て"
        ],
        "example": [
            ["1", "=ISODD(A1)"],
            ["-1", "=ISODD(A2)"],
            ["2", "=ISODD(A3)"],
            ["2.2", "=ISODD(A4)"]
        ],
        "example_sup": "B1とB2の実行結果はTRUE、B3とB4の実行結果はFALSEになる。",
        "tag": ["ISODD", "ODD", "奇数"]
    },
    {
        "name": "ISREF",
        "desc": "対象がセル参照の場合にTRUEを返す。",
        "form": "ISREF(対象)",
        "arg": [
            "対象"
        ],
        "arg_desc": [
            "必須"
        ],
        "example": [
            ["リンゴ", "=ISREF(A1)"],
            ["", "=ISREF(\"リンゴ\")"]
        ],
        "example_sup": "B1の実行結果はTRUE、B2の実行結果はFALSEになる。",
        "tag": ["ISREF", "REF", "セル", "参照"]
    },
    {
        "name": "ISTEXT",
        "desc": "対象が文字列の場合にTRUEを返す。",
        "form": "ISTEXT(対象)",
        "arg": [
            "対象"
        ],
        "arg_desc": [
            "必須"
        ],
        "example": [
            ["リンゴ", "=ISTEXT(A1)"],
            ["1", "=ISTEXT(A2)"]
        ],
        "example_sup": "B1の実行結果はTRUE、B2の実行結果はFALSEになる。",
        "tag": ["ISTEXT", "TEXT", "セル", "参照"]
    },
    {
        "name": "JIS",
        "desc": "文字列内の半角文字を全角文字に変換する。",
        "form": "JIS(文字列)",
        "arg": [
            "文字列"
        ],
        "arg_desc": [
            "必須"
        ],
        "example": [
            ["ｴｸｾﾙ", "=JIS(A1)"]
        ],
        "example_sup": "B1の実行結果はエクセルになる。",
        "tag": ["JIS", "半角", "全角", "変換", "文字列"]
    },
    {
        "name": "LARGE",
        "desc": "範囲内のn番目に大きなデータを返す。",
        "form": "LARGE(範囲, 率)",
        "arg": [
            "範囲",
            "率"
        ],
        "arg_desc": [
            "必須",
            "必須。大きい方から数えた順位"
        ],
        "example": [
            ["=LARGE(A2:A4, 2)"],
            ["10"],
            ["20"],
            ["30"]
        ],
        "example_sup": "A1の実行結果は20になる。",
        "tag": ["LARGE", "n番目", "順位", "順番"]
    },
    {
        "name": "LCM",
        "desc": "複数の整数の最小公倍数を返す。",
        "form": "LCM(数値1, [数値2], …)",
        "arg": [
            "数値1",
            "[数値2], …"
        ],
        "arg_desc": [
            "必須",
            "任意"
        ],
        "example": [
            ["=LCM(A2:A4)"],
            ["10"],
            ["20"],
            ["30"]
        ],
        "example_sup": "A1の実行結果は60になる。",
        "tag": ["LCM", "倍数", "最小", "公倍数", "最小公倍数"]
    },
    {
        "name": "LEFT",
        "desc": "文字列の先頭から指定された数の文字を返す。",
        "form": "LEFT(文字列, [文字数])",
        "arg": [
            "文字列",
            "文字数"
        ],
        "arg_desc": [
            "必須",
            "任意"
        ],
        "example": [
            ["リンゴ", "=LEFT(A1, 2)"]
        ],
        "example_sup": "B1の実行結果はリンになる。",
        "tag": ["LEFT", "文字列", "文字", "文字数"]
    },
    {
        "name": "LEFTB",
        "desc": "文字列の先頭から指定された数のバイト数の文字を返す。",
        "form": "LEFTB(文字列, [バイト数])",
        "arg": [
            "文字列",
            "バイト数"
        ],
        "arg_desc": [
            "必須",
            "任意"
        ],
        "example": [
            ["リンゴ", "=LEFTB(A1, 2)"],
            ["apple", "=LEFTB(A2, 2)"]
        ],
        "example_sup": "B1の実行結果はリ、B2の実行結果はapになる。",
        "tag": ["LEFTB", "文字列", "バイト", "バイト数"]
    },
    {
        "name": "LEN",
        "desc": "文字列の文字数を返す。",
        "form": "LEN(文字列)",
        "arg": [
            "文字列"
        ],
        "arg_desc": [
            "必須"
        ],
        "example": [
            ["リンゴ", "=LEN(A1)"]
        ],
        "example_sup": "B1の実行結果は3になる。",
        "tag": ["LEN", "文字列", "文字数", "文字"]
    },
    {
        "name": "LENB",
        "desc": "文字列のバイト数を返す。",
        "form": "LENB(文字列)",
        "arg": [
            "文字列"
        ],
        "arg_desc": [
            "必須"
        ],
        "example": [

            ["リンゴ", "=LENB(A1)"]
        ],
        "example_sup": "B1の実行結果は6になる。",
        "tag": ["LENB", "文字列", "バイト数", "バイト"]
    },
    {
        "name": "LOWER",
        "desc": "英大文字を小文字に変換する。",
        "form": "LOWER(文字列)",
        "arg": [
            "文字列"
        ],
        "arg_desc": [
            "必須"
        ],
        "example": [

            ["APPLE", "=LOWER(A1)"]
        ],
        "example_sup": "B1の実行結果はappleになる。",
        "tag": ["LOWER", "文字列", "英字", "大文字", "小文字", "変換"]
    },
    {
        "name": "MATCH",
        "desc": "範囲内で値を検索して相対的な位置を返す。",
        "form": "MATCH(検査値, 範囲, [照合の型])",
        "arg": [
            "検索値",
            "範囲",
            "照合の型"
        ],
        "arg_desc": [
            "必須",
            "必須",
            "任意。1または省略で検査値以下の最大の値、0で一致する値、-1で検査値以上の最小の値"
        ],
        "example": [
            ["=MATCH(20, A2:A4)"],
            ["11"],
            ["22"],
            ["33"]
        ],
        "example_sup": "A1の実行結果は1になる。",
        "tag": ["MATCH", "検索", "位置", "マッチ"]
    },
    {
        "name": "MAX",
        "desc": "範囲内の最大の数値を返す。",
        "form": "MAX(数値1, [数値2], …)",
        "arg": [
            "数値1",
            "[数値2], …"
        ],
        "arg_desc": [
            "必須",
            "任意"
        ],
        "example": [
            ["=MAX(A2:A4)"],
            ["11"],
            ["22"],
            ["33"]
        ],
        "example_sup": "A1の実行結果は33になる。",
        "tag": ["MAX", "最大", "数値"]
    },
    {
        "name": "MAXA",
        "desc": "範囲内の最大の値を返す。",
        "form": "MAX(値1, [値2], …)",
        "arg": [
            "値1",
            "[値2], …"
        ],
        "arg_desc": [
            "必須",
            "任意"
        ],
        "example": [
            ["=MAXA(A2:A4)"],
            ["0.1"],
            ["0.2"],
            ["TRUE"]
        ],
        "example_sup": "A1の実行結果は1（TRUE）になる。",
        "tag": ["MAXA", "最大", "値"]
    },
    {
        "name": "MEDIAN",
        "desc": "範囲内の中央値を返す。",
        "form": "MEDIAN(数値1, [数値2], …)",
        "arg": [
            "数値1",
            "[数値2], …"
        ],
        "arg_desc": [
            "必須",
            "任意"
        ],
        "example": [
            ["=MEDIAN(A2:A4)"],
            ["1"],
            ["2"],
            ["100"]
        ],
        "example_sup": "A1の実行結果は2になる。",
        "tag": ["MEDIAN", "中央値", "中央"]
    },
    {
        "name": "MID",
        "desc": "指定された位置から指定された文字数の文字を返す。",
        "form": "MID(文字列, 開始位置, 文字数)",
        "arg": [
            "文字列",
            "開始位置",
            "文字数"
        ],
        "arg_desc": [
            "必須",
            "必須",
            "必須"
        ],
        "example": [
            ["リンゴ", "=MID(A1, 1, 2)"]
        ],
        "example_sup": "B1の実行結果はリンになる。",
        "tag": ["MID", "位置", "文字", "文字数", "文字列"]
    },
    {
        "name": "MIDB",
        "desc": "指定された位置から指定されたバイト数の文字を返す。",
        "form": "MID(文字列, 開始位置, バイト数)",
        "arg": [
            "文字列",
            "開始位置",
            "バイト数"
        ],
        "arg_desc": [
            "必須",
            "必須",
            "必須"
        ],
        "example": [
            ["リンゴ", "=MIDB(A1, 1, 2)"]
        ],
        "example_sup": "B1の実行結果はリになる。",
        "tag": ["MIDB", "位置", "バイト", "バイト数", "文字列"]
    },
    {
        "name": "MIN",
        "desc": "範囲内の最小の数値を返す。",
        "form": "MIN(数値1, [数値2], …)",
        "arg": [
            "数値1",
            "[数値2], …"
        ],
        "arg_desc": [
            "必須",
            "任意"
        ],
        "example": [
            ["=MIN(A2:A4)"],
            ["2"],
            ["1"],
            ["3"]
        ],
        "example_sup": "A1の実行結果は1になる。",
        "tag": ["MIN", "最小", "数値"]
    },
    {
        "name": "MINA",
        "desc": "範囲内の最小の値を返す。",
        "form": "MINA(値1, [値2], …)",
        "arg": [
            "値1",
            "[値2], …"
        ],
        "arg_desc": [
            "必須",
            "任意"
        ],
        "example": [
            ["=MINA(A2:A4)"],
            ["FALSE"],
            ["0.1"],
            ["0.2"]
        ],
        "example_sup": "B1の実行結果は0（FALSE）になる。",
        "tag": ["MINA", "最小", "値"]
    },
    {
        "name": "MOD",
        "desc": "割り算（除算）の余り（剰余）を返す。",
        "form": "MOD(数値, 除数)",
        "arg": [
            "数値",
            "除数"
        ],
        "arg_desc": [
            "必須",
            "必須"
        ],
        "example": [
            ["3"],
            ["2"],
            ["=MOD(A1, A2)"]
        ],
        "example_sup": "A3の実行結果は1になる。",
        "tag": ["MOD", "割り算", "割算", "除算", "余り", "剰余"]
    },
    {
        "name": "MODE.MULT",
        "desc": "最も頻繁に出現する値を縦方向の配列として返す。",
        "form": "MODE.MULT(数値1, [数値2], …)",
        "arg": [
            "数値1",
            "[数値2], …"
        ],
        "arg_desc": [
            "必須",
            "任意"
        ],
        "example": [
            ["1", ""],
            ["1", ""],
            ["2", ""],
            ["2", ""],
            ["3", ""],
            ["最多", "{=MODE.MULT(A1:A5)}"],
            ["最多", "{=MODE.MULT(A1:A5)}"]
        ],
        "example_sup": "B6の実行結果は1、B7の実行結果は2になる。",
        "tag": ["MODE.MULT", "MULT", "MODE", "頻繁", "出現", "最多"]
    },
    {
        "name": "MODE.SNGL",
        "desc": "最も頻繁に出現する値を返す。",
        "form": "MODE.SNGL(数値1, [数値2], …)",
        "arg": [
            "数値1",
            "[数値2], …"
        ],
        "arg_desc": [
            "必須",
            "任意"
        ],
        "example": [
            ["=MODE.SNGL(A2:A5)"],
            ["1"],
            ["2"],
            ["2"],
            ["3"]
        ],
        "example_sup": "A1の実行結果は2になる。",
        "tag": ["MODE.SNGL", "SNGL", "MODE", "頻繁", "出現", "最多"]
    },
    {
        "name": "MROUND",
        "desc": "指定された値の倍数になるように、数値を切り上げまたは切り捨てる。",
        "form": "MROUND(数値, 倍数)",
        "arg": [
            "数値",
            "倍数"
        ],
        "arg_desc": [
            "必須",
            "必須"
        ],
        "example": [
            ["=MROUND(5, 2)"]
        ],
        "example_sup": "A1の実行結果は6になる。",
        "tag": ["MROUND", "倍数", "切り上げ", "切上", "切り捨て", "切捨"]
    },
    {
        "name": "NOT",
        "desc": "論理値を逆にして返す。",
        "form": "NOT(論理値)",
        "arg": [
            "論理値"
        ],
        "arg_desc": [
            "必須。TRUEとFALSEどちらかに評価できる値または式"
        ],
        "example": [
            ["=NOT(A2>A3)"],
            ["1"],
            ["2"]
        ],
        "example_sup": "A1の実行結果はTRUEになる。",
        "tag": ["NOT", "否定", "逆", "論理値"]
    },
    {
        "name": "OCT2BIN",
        "desc": "8進数を2進数に変換する。",
        "form": "OCT2BIN(数値, [桁数])",
        "arg": [
            "数値",
            "桁数"
        ],
        "arg_desc": [
            "必須。2進数に変換する数値",
            "任意"
        ],
        "example": [
            ["=OCT2BIN(10, 5)"]
        ],
        "example_sup": "A1の実行結果は01000になる。",
        "tag": ["OCT2BIN", "8進数", "2進数", "変換"]
    },
    {
        "name": "OCT2DEC",
        "desc": "8進数を10進数に変換する。",
        "form": "OCT2DEC(数値)",
        "arg": [
            "数値"
        ],
        "arg_desc": [
            "必須。10進数に変換する数値"
        ],
        "example": [
            ["=OCT2DEC(10)"]
        ],
        "example_sup": "A1の実行結果は8になる。",
        "tag": ["OCT2DEC", "8進数", "10進数", "変換"]
    },
    {
        "name": "OCT2HEX",
        "desc": "8進数を16進数に変換する。",
        "form": "OCT2HEX(数値, [桁数])",
        "arg": [
            "数値",
            "桁数"
        ],
        "arg_desc": [
            "必須。16進数に変換する数値",
            "任意"
        ],
        "example": [
            ["=OCT2HEX(10, 5)"]
        ],
        "example_sup": "A1の実行結果は00008になる。",
        "tag": ["OCT2HEX", "8進数", "16進数", "変換"]
    },
    {
        "name": "ODD",
        "desc": "指定した数値を最も近い奇数に切り上げた数値を返す。",
        "form": "ODD(数値)",
        "arg": [
            "数値"
        ],
        "arg_desc": [
            "必須。丸めの対象となる数値。"
        ],
        "example": [
            ["=ODD(1.2)"],
            ["=ODD(-1.2)"],
            ["=ODD(2.8)"],
            ["=ODD(-2.8)"]
        ],
        "example_sup": "A1とA3の実行結果は3、A2とA4は-3になる。",
        "tag": ["ODD", "数値", "奇数", "切り上げ"]
    },
    {
        "name": "OFFSET",
        "desc": "指定された行数と列数だけ移動した位置にある範囲の参照を返す。",
        "form": "OFFSET(基準, 行数, 列数, [高さ], [幅])",
        "arg": [
            "基準",
            "行数",
            "列数",
            "高さ",
            "幅"
        ],
        "arg_desc": [
            "必須",
            "必須",
            "必須",
            "任意",
            "任意"
        ],
        "example": [
            ["=OFFSET(A2, 1, 1)"],
            ["1", "2"],
            ["3", "4"]
        ],
        "example_sup": "A1の実行結果は4になる。",
        "tag": ["OFFSET", "行数", "列数", "位置", "オフセット", "基準", "移動"]
    },
    {
        "name": "OR",
        "desc": "いずれかの条件がTRUEの場合にTRUEを返す。",
        "form": "OR(論理式1, [論理式2], …)",
        "arg": [
            "論理式1",
            "[論理式2], …"
        ],
        "arg_desc": [
            "必須",
            "任意"
        ],
        "example": [
            ["=OR(A2>A3, A4=3)"],
            ["1"],
            ["2"],
            ["3"]
        ],
        "example_sup": "A1の実行結果はTRUEになる。",
        "tag": ["OR", "または", "条件"]
    },
    {
        "name": "PHONETIC",
        "desc": "文章からフリガナを取り出す。",
        "form": "PHONETIC(参照)",
        "arg": [
            "参照"
        ],
        "arg_desc": [
            "必須。文字列またはセル参照"
        ],
        "example": [
            ["田中", "=PHONETIC(A1)"]
        ],
        "example_sup": "B1の実行結果はタナカになる。※エクセル上で田中を入力した場合。",
        "tag": ["PHONETIC", "フリガナ", "ふりがな"]
    },
    {
        "name": "PI",
        "desc": "円周率πの近似値を15桁で返す。",
        "form": "PI()",
        "arg": [
            "なし"
        ],
        "arg_desc": [
            "なし"
        ],
        "example": [
            ["=PI()"]
        ],
        "example_sup": "A1の実行結果は3.14159265358979になる。",
        "tag": ["PI", "円周率", "π", "パイ", "3.14"]
    },
    {
        "name": "POWER",
        "desc": "数値のべき乗を返す。",
        "form": "POWER(数値, 指数)",
        "arg": [
            "数値",
            "指数"
        ],
        "arg_desc": [
            "必須。べき乗の底",
            "必須。数値を底とするべき乗の指数"
        ],
        "example": [
            ["=POWER(5, 2)"],
            ["=5^2"]
        ],
        "example_sup": "A1とA2の実行結果はどちらも25になる。",
        "tag": ["POWER", "べき乗", "冪乗"]
    },
    {
        "name": "PROPER",
        "desc": "英字の先頭の文字、および記号の次の英字を大文字に変換する。",
        "form": "PROPER(文字列)",
        "arg": [
            "文字列"
        ],
        "arg_desc": [
            "必須"
        ],
        "example": [
            ["This is a pen", "=PROPER(A1)"]
        ],
        "example_sup": "A1の実行結果はThis Is A Penになる。",
        "tag": ["PROPER", "英字", "英語", "大文字", "変換"]
    },
    {
        "name": "QUOTIENT",
        "desc": "除算の商の整数部を返す。",
        "form": "QUOTIENT(分子, 分母)",
        "arg": [
            "分子",
            "分母"
        ],
        "arg_desc": [
            "必須",
            "必須"
        ],
        "example": [
            ["=QUOTIENT(2, 1)"],
            ["=QUOTIENT(3, 2)"]
        ],
        "example_sup": "A1の実行結果は2、A2は1になる。",
        "tag": ["QUOTIENT", "除算", "商", "分子", "分母"]
    },
    {
        "name": "RAND",
        "desc": "0以上1未満のランダムな実数を返す。",
        "form": "RAND()",
        "arg": [
            "なし"
        ],
        "arg_desc": [
            "なし"
        ],
        "example": [
            ["=RAND()"],
            ["=INT(RAND()*100)"]
        ],
        "example_sup": "A1の実行結果は0.962568767489897など0以上1未満の範囲で可変、A2は52など0以上100未満の整数の範囲で可変になる。",
        "tag": ["RAND", "ランダム", "乱数", "可変"]
    },
    {
        "name": "RANDBETWEEN",
        "desc": "指定した範囲内でランダムな整数を返す。",
        "form": "RANDBETWEEN(最小値, 最大値)",
        "arg": [
            "最小値",
            "最大値"
        ],
        "arg_desc": [
            "必須",
            "必須"
        ],
        "example": [
            ["=RANDBETWEEN(1, 100)"]
        ],
        "example_sup": "A1の実行結果は52など1以上100以下の範囲で可変になる。",
        "tag": ["RANDBETWEEN", "ランダム", "乱数", "可変", "範囲", "整数"]
    },
    {
        "name": "RANK.AVG",
        "desc": "範囲内の指定した数値の順位を返す。同じ数値が複数ある場合は平均順位を返す。",
        "form": "RANK.AVG(数値, 範囲, [順序])",
        "arg": [
            "数値",
            "範囲",
            "順序"
        ],
        "arg_desc": [
            "必須",
            "必須",
            "任意。0または省略で降順、0以外で昇順になる"
        ],
        "example": [
            ["10"],
            ["30"],
            ["20"],
            ["20"],
            ["=RANK.AVG(20, A1:A4)"]
        ],
        "example_sup": "A5の実行結果は2.5になる。",
        "tag": ["RANK.AVG", "RANK", "AVG", "平均", "順位", "平均順位"]
    },
    {
        "name": "RANK.EQ",
        "desc": "範囲内の指定した数値の順位を返す。同じ数値が複数ある場合は最上位の順位を返す。",
        "form": "RANK.EQ(数値, 範囲, [順序])",
        "arg": [
            "数値",
            "範囲",
            "順序"
        ],
        "arg_desc": [
            "必須",
            "必須",
            "任意。0または省略で降順、0以外で昇順になる"
        ],
        "example": [
            ["10"],
            ["30"],
            ["20"],
            ["20"],
            ["=RANK.EQ(20, A1:A4)"]
        ],
        "example_sup": "A5の実行結果は2になる。",
        "tag": ["RANK.EQ", "RANK", "EQ", "平均", "順位", "平均順位"]
    },
    {
        "name": "REPLACE",
        "desc": "文字列に含まれる指定された文字数の文字を置き換える。",
        "form": "REPLACE(文字列, 開始位置, 文字数, 置換文字列)",
        "arg": [
            "文字列",
            "開始位置",
            "文字数",
            "置換文字列"
        ],
        "arg_desc": [
            "必須",
            "必須",
            "必須",
            "必須"
        ],
        "example": [
            ["2010"],
            ["=REPLACE(A1, 3, 1, \"2\")"]
        ],
        "example_sup": "A2の実行結果は2020になる。",
        "tag": ["REPLACE", "置換", "置き換え", "文字"]
    },
    {
        "name": "REPT",
        "desc": "文字列を指定された回数だけ繰り返す。",
        "form": "REPT(文字列, 繰り返し回数)",
        "arg": [
            "文字列",
            "繰り返し回数"
        ],
        "arg_desc": [
            "必須",
            "必須"
        ],
        "example": [
            ["excel"],
            ["=REPT(A1, 2)"]
        ],
        "example_sup": "A2の実行結果はexcelexcelになる。",
        "tag": ["REPT", "文字列", "繰り返し", "繰り返す"]
    },
    {
        "name": "RIGHT",
        "desc": "文字列の末尾 (右端) から指定された文字数の文字を返す。",
        "form": "RIGHT(文字列, [文字数])",
        "arg": [
            "文字列",
            "文字数"
        ],
        "arg_desc": [
            "必須",
            "任意"
        ],
        "example": [
            ["2020"],
            ["=RIGHT(A1, 2)"]
        ],
        "example_sup": "A2の実行結果は20になる。",
        "tag": ["RIGHT", "末尾", "右端", "切り抜き", "文字列"]
    },
    {
        "name": "ROMAN",
        "desc": "アラビア数字をローマ数字に変換する。",
        "form": "ROMAN(数値, [書式])",
        "arg": [
            "数値",
            "書式"
        ],
        "arg_desc": [
            "必須",
            "任意"
        ],
        "example": [
            ["=ROMAN(499)"],
            ["=ROMAN(499, 1)"],
            ["=ROMAN(499, 2)"],
            ["=ROMAN(499, 3)"],
            ["=ROMAN(499, 4)"]
        ],
        "example_sup": "A1の実行結果はCDXCIX、A2はLDVLIV、A3はXDIX、A4はVDIV、A5はIDになる。",
        "tag": ["ROMAN", "アラビア", "ローマ", "数字", "変換"]
    },
    {
        "name": "ROUND",
        "desc": "数値を四捨五入して指定された桁数にする。",
        "form": "ROUND(数値, 桁数)",
        "arg": [
            "数値",
            "桁数"
        ],
        "arg_desc": [
            "必須",
            "必須"
        ],
        "example": [
            ["=ROUND(1.05, 1)"]
        ],
        "example_sup": "A1の実行結果は1.1になる。",
        "tag": ["ROUND", "数値", "四捨五入", "桁数"]
    },
    {
        "name": "ROUNDDOWN",
        "desc": "数値を指定された桁数で切り捨てる。",
        "form": "ROUNDDOWN(数値, 桁数)",
        "arg": [
            "数値",
            "桁数"
        ],
        "arg_desc": [
            "必須",
            "必須"
        ],
        "example": [
            ["=ROUNDDOWN(1.15, 1)"]
        ],
        "example_sup": "A1の実行結果は1.1になる。",
        "tag": ["ROUNDDOWN", "数値", "切り捨て", "切捨", "桁数"]
    },
    {
        "name": "ROUNDUP",
        "desc": "数値を指定された桁数で切り上げる。",
        "form": "ROUNDUP(数値, 桁数)",
        "arg": [
            "数値",
            "桁数"
        ],
        "arg_desc": [
            "必須",
            "必須"
        ],
        "example": [
            ["=ROUNDUP(1.11, 1)"]
        ],
        "example_sup": "A1の実行結果は1.2になる。",
        "tag": ["ROUNDUP", "数値", "切り上げ", "切上", "桁数"]
    },
    {
        "name": "SEARCH",
        "desc": "指定された文字列を検索して最初に現れる位置を番号で返す。",
        "form": "SEARCH(検索文字列, 対象, [開始位置])",
        "arg": [
            "検索文字列",
            "対象",
            "開始位置"
        ],
        "arg_desc": [
            "必須",
            "必須",
            "任意"
        ],
        "example": [
            ["excel"],
            ["=SEARCH(\"x\", A1)"]
        ],
        "example_sup": "A2の実行結果は2になる。",
        "tag": ["SEARCH", "検索", "位置"]
    },
    {
        "name": "SIGN",
        "desc": "数値の正負を調べる。",
        "form": "SIGN(数値)",
        "arg": [
            "数値"
        ],
        "arg_desc": [
            "必須"
        ],
        "example": [
            ["=SIGN(5)"],
            ["=SIGN(-5)"]
        ],
        "example_sup": "A1の実行結果は1、A2は-1になる。",
        "tag": ["SIGN", "数値", "正", "負"]
    },
    {
        "name": "SMALL",
        "desc": "範囲内のn番目に小さなデータを返す。",
        "form": "SMALL(範囲, 率)",
        "arg": [
            "範囲",
            "率"
        ],
        "arg_desc": [
            "必須",
            "必須。小さい方から数えた順位"
        ],
        "example": [
            ["=SMALL(A2:A4, 2)"],
            ["10"],
            ["20"],
            ["30"]
        ],
        "example_sup": "A1の実行結果は20になる。",
        "tag": ["SMALL", "n番目", "順位", "順番"]
    },
    {
        "name": "SUBSTITUTE",
        "desc": "文字列内の文字列を置換する。",
        "form": "SUBSTITUTE(文字列, 検索文字列, 置換文字列, [置換対象])",
        "arg": [
            "文字列",
            "検索文字列",
            "置換文字列",
            "置換対象"
        ],
        "arg_desc": [
            "必須",
            "必須",
            "必須",
            "任意"
        ],
        "example": [
            ["excel関数"],
            ["=SUBSTITUTE(A1, \"excel\", \"エクセル\")"]
        ],
        "example_sup": "A2の実行結果はエクセル関数になる。",
        "tag": ["SUBSTITUTE", "置換", "置き換え", "文字列"]
    },
    {
        "name": "SUM",
        "desc": "値を合計する。",
        "form": "SUM(数値1, [数値2], …)",
        "arg": [
            "数値1",
            "[数値2], …"
        ],
        "arg_desc": [
            "必須",
            "任意"
        ],
        "example": [
            ["1"],
            ["2"],
            ["=SUM(A1:A2)"]
        ],
        "example_sup": "A3の実行結果は3になる。",
        "tag": ["SUM", "合計", "加算", "足し算", "足算"]
    },
    {
        "name": "SUMIF",
        "desc": "条件に一致する範囲内の値を合計する。",
        "form": "SUMIF(条件範囲, 条件, [合計範囲])",
        "arg": [
            "条件範囲",
            "条件",
            "合計範囲"
        ],
        "arg_desc": [
            "必須。条件に使用する範囲",
            "必須",
            "任意。合計する値の範囲"
        ],
        "example": [
            ["×", "99"],
            ["○", "100"],
            ["○", "100"],
            ["=SUMIF(A1:A3, \"○\", B1:B3)"]
        ],
        "example_sup": "A4の実行結果は200になる。",
        "tag": ["SUMIF", "SUM", "IF", "合計", "加算", "足し算", "足算", "条件"]
    },
    {
        "name": "SUMIFS",
        "desc": "複数の条件に一致する範囲内の値を合計する。",
        "form": "SUMIFS(合計範囲, 条件範囲1, 条件1, [条件範囲2, 条件2], …)",
        "arg": [
            "合計範囲",
            "条件範囲1",
            "条件1",
            "[条件範囲2, 条件2], …"
        ],
        "arg_desc": [
            "必須。合計する値の範囲",
            "必須。条件に使用する範囲",
            "必須",
            "任意"
        ],
        "example": [
            ["×", "99"],
            ["×", "100"],
            ["○", "100"],
            ["○", "100"],
            ["=SUMIFS(B1:B4, B1:B4, \">99\", A1:A4, \"○\")"]
        ],
        "example_sup": "A5の実行結果は200になる。",
        "tag": ["SUMIFS", "SUM", "IF", "IFS", "合計", "加算", "足し算", "足算", "条件", "複数"]
    },
    {
        "name": "SUMPRODUCT",
        "desc": "範囲内の積を合計する。",
        "form": "SUMPRODUCT(範囲1, [範囲2], [範囲3], …)",
        "arg": [
            "範囲1",
            "範囲2",
            "[範囲3], …"
        ],
        "arg_desc": [
            "必須",
            "必須",
            "任意"
        ],
        "example": [
            ["100", "2"],
            ["200", "2"],
            ["=SUMPRODUCT(A1:A2, B1:B2)"]
        ],
        "example_sup": "A3の実行結果は600になる。",
        "tag": ["SUMPRODUCT", "SUM", "PRODUCT", "積", "掛け算", "掛算", "乗法", "合計"]
    },
    {
        "name": "SWITCH",
        "desc": "条件に一致する値を返す。",
        "form": "SWITCH(式, 値1, 結果1, [値2, 結果2], …)",
        "arg": [
            "式",
            "値1",
            "結果1",
            "[値2, 結果2], …"
        ],
        "arg_desc": [
            "必須。検索する値またはセル",
            "必須。検索する値と一致するかを確認する値",
            "必須。一致した場合の結果",
            "任意"
        ],
        "example": [
            ["○", "=SWITCH(A1, \"○\", \"丸\", \"×\", \"バツ\")"],
            ["×", "=SWITCH(A2, \"○\", \"丸\", \"×\", \"バツ\")"]
        ],
        "example_sup": "B1の実行結果は丸、B2はバツになる。",
        "tag": ["SWITCH", "検索", "条件", "一致", "複数"]
    },
    {
        "name": "TEXTJOIN",
        "desc": "文字列を結合して区切り記号を追加する。",
        "form": "TEXTJOIN(区切り記号, 空のセル判定、結合する文字列1, [結合する文字列2], …)",
        "arg": [
            "区切り記号",
            "空のセル判定",
            "結合する文字列1",
            "[結合する文字列2], …"
        ],
        "arg_desc": [
            "必須",
            "必須。TRUEを指定すると空のセルを無視する",
            "必須",
            "任意"
        ],
        "example": [
            ["リンゴ"],
            ["ミカン"],
            ["=TEXTJOIN(\"/\", TRUE, A1:A2)", ""]
        ],
        "example_sup": "A3の実行結果はリンゴ/ミカンになる。",
        "tag": ["TEXTJOIN", "TEXT", "JOIN", "文字列", "結合", "区切り", "記号"]
    },
    {
        "name": "TRANSPOSE",
        "desc": "指定したセル範囲のデータの行と列を入れ替えた配列を返す。",
        "form": "TRANSPOSE(配列)",
        "arg": [
            "配列"
        ],
        "arg_desc": [
            "必須"
        ],
        "example": [
            ["リンゴ", "100円"],
            ["=TRANSPOSE(A1:B1)", ""],
            ["", ""]
        ],
        "example_sup": "A2とA3を選択した状態でA2の内容を入力してCtrl+Shift+Enterで実行すると、A2がリンゴ、A3が100円になる。",
        "tag": ["TRANSPOSE", "行", "列", "入れ替え", "入れ替える", "入替"]
    },
    {
        "name": "TRIM",
        "desc": "不要なスペースを削除する。",
        "form": "TRIM(文字列)",
        "arg": [
            "文字列"
        ],
        "arg_desc": [
            "必須"
        ],
        "example": [
            ["=TRIM(\" This is a pen\")"]
        ],
        "example_sup": "A1の実行結果はThis is a penになる。",
        "tag": ["TRIM", "不要", "スペース", "空白", "削除", "取り除く"]
    },
    {
        "name": "TRUNC",
        "desc": "数値の小数部を切り捨てて、指定した桁数に変換する。",
        "form": "TRUNC(数値, [桁数])",
        "arg": [
            "数値",
            "桁数"
        ],
        "arg_desc": [
            "必須",
            "任意。小数点以下の桁数"
        ],
        "example": [
            ["=TRUNC(1.567, 1)"]
        ],
        "example_sup": "A1の実行結果は1.5になる。",
        "tag": ["TRUNC", "小数", "切り捨て", "切捨", "桁"]
    },
    {
        "name": "UPPER",
        "desc": "文字列を大文字に変換する。",
        "form": "UPPER(文字列)",
        "arg": [
            "文字列"
        ],
        "arg_desc": [
            "必須"
        ],
        "example": [
            ["=UPPER(\"excel\")"]
        ],
        "example_sup": "A1の実行結果はEXCELになる。",
        "tag": ["UPPER", "大文字", "変換"]
    },
    {
        "name": "VLOOKUP",
        "desc": "テーブルまたは配列内の指定列を検索して値を返す。",
        "form": "VLOOKUP(検索値, 範囲, 列番号, [検索の型])",
        "arg": [
            "検索値",
            "範囲",
            "列番号",
            "検索の型"
        ],
        "arg_desc": [
            "必須。検索する値、参照、文字列",
            "必須。検索範囲",
            "必須。検索範囲の列番号",
            "任意。TRUEまたは省略で近似値、FALSEで完全一致"
        ],
        "example": [
            ["ミカン", "=VLOOKUP(A1, A3:B4, 2, FALSE)"],
            ["", ""],
            ["リンゴ", "100円"],
            ["ミカン", "200円"]
        ],
        "example_sup": "B1の実行結果は200円になる。",
        "tag": ["VLOOKUP", "LOOKUP", "検索", "列", "近似値", "完全一致"]
    }
]