{
  "assessmentTests": {
    "javascript_test": {
      "name": "JavaScriptテスト",
      "desc": "コア構文と型強制、関数/スコープ/クロージャと this、オブジェクト/配列とデータ構造、イベントループ/async/プロトタイプイディオムに関する30のシナリオ問題——あなたの実JavaScriptが、求人票にいう「JavaScript習熟度」と一致しているかを判定します。",
      "recommendation": "あなたのJavaScriptスキルプロフィール",
      "results": {
        "beginner": {
          "name": "初級者",
          "desc": "動作する関数やオブジェクトを書くことはできますが、あなたが外した問題は、構文というより、型強制と参照セマンティクスに集中しています——== が比較前に静かに型を変換する、配列代入がコピーではなく1つのオブジェクトを共有する、NaN が自分自身と等しくないわけ。これらは「JavaScriptが下手」という話ではなく、言語を「動くコードを書く」で学んだ人が引っかかる固有のルールで、値と参照がどう動くかを学んだ人は引っかかりません。仕事で重要なのは、一見正しいコードがエラーなく動いても、間違ったことをするのがこうした場所だからです。",
          "recommendation": "3つのテーマから始めましょう、この順で。なぜ == が型を強制してから比較するのに対し === がしないのか、1つの配列やオブジェクトを新変数に代入すると値ではなく参照がコピーされるわけ、var がホイストされて undefined に初期化されるのに対し let と const は宣言行まで temporal dead zone に留まるわけ。MDN の JavaScript ガイドは実行例付きでこれら3つをカバーしています。"
        },
        "intermediate": {
          "name": "中級者",
          "desc": "日々のアプリケーションコードは快適にこなします——関数、配列メソッド、単純な制御フロー——既存コードベースの保守タスクや一般的な機能実装に足を引っ張られることもありません。ここから上級への差は、主としてJavaScriptのスコープとタイミングルールが相互作用する場面です：ループコールバック内で var をキャプチャしてすべてが同じ最終値を読む、メソッドがオブジェクトから外されると this が無言でそのオブジェクトを指さなくなる、スプレッド展開が深い複製に見えても実は最上位だけコピーする。これらは読み流しでは見つからず、特定のランタイム条件でだけ起こるバグです。",
          "recommendation": "スコープと this が呼び出しのときに実際にどう解決されるかに焦点を当てましょう：var ベースの for ループがすべてのコールバックに同じ counter 最終値を渡すのに対し let がそうしないわけ、this が書かれた場所ではなく呼び出され方で決まるわけ、スプレッド展開と Object.assign がオブジェクトの最上位だけコピーするわけ。その後イベントループ、個々には promise を知ってる人が引っかかるからです。"
        },
        "advanced": {
          "name": "上級者",
          "desc": "ほぼすべての求人票が「JavaScript得意」とはこのレベルを指しています。filter/map/reduce の鎖を読んで、元の配列を変えずにまさに何を返すか予測でき、同期的な console.log が常にマイクロタスクを勝り、マイクロタスクが常に setTimeout を勝ることを知り、Promise.all を使うとき、残りを待つのではなく即座にいずれかの promise が reject したら reject することを知っています。このランクと最上位を分ける要素は、プロトタイプとオブジェクトモデルの側面です：プロトタイプチェーンがインスタンスにない継承メソッドをどう解決するか、クラスプライベートフィールドが実際に何を隠すか。",
          "recommendation": "状態を他のコードも触れる側面に進みましょう：JavaScriptのプロトタイプチェーンがインスタンス自身にない検索をどう解決するか、クラスの #fields プライベートが外からのアクセスから何を隠すか、JSON.stringify が undefined と関数をプレーンオブジェクト内と配列内で異なるやり方で扱うか。MDN のイベントループとプロトタイプチェーンに関する資料は両方ともの自然な次ステップです。"
        },
        "expert": {
          "name": "エキスパート",
          "desc": "あなたはすべてのセクション——基本構文と型強制、関数とスコープと closure と this、オブジェクトと配列とデータ構造、async とイベントループとプロトタイプとイディオム——で最高点を取りました。実務上、それは他者の関数を渡されて、構文が返すべき出力だけでなく、なぜそれが返されるのかを説明できるということ。これはより難しく、より価値ある技能です。このレベルでは、言語そのものが仕事の制限になることはほぼありません。制限は通常、async の制御フロー、またはその底にあるデータの形です。",
          "recommendation": "リターンは今、設計と診断の側にあります：Promise.all と Promise.race の間の競合状態について推論し、定義を暗唱するのではなく、プライベート状態が closure の正しい選択肢なのか vs クラスプライベートフィールドなのかを選ぶ、本番ログから microtask-vs-macrotask の順序バグを読む。スクリーニングロール受験時は JavaScript 機能を名前で列挙するのではなく、見つけた timing バグ——stale な closure 変数か out-of-order async コールバック——を説明してください。それは言い回しではなく、推論の力を示します。"
        }
      },
      "questions": [
        {
          "question": "console.log(x);\nvar x = 5;\nこれは何を出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "5 ——var 宣言はすべての他のコードの前に実行される"
            },
            {
              "icon": "",
              "label": "ReferenceError: x is not defined"
            },
            {
              "icon": "",
              "label": "undefined ——var 宣言はそのスコープの最上位にホイストされ undefined に初期化されるが、代入は所定の位置で実行される。実行前に変数は存在しますが undefined を保持"
            },
            {
              "icon": "",
              "label": "null"
            }
          ]
        },
        {
          "question": "console.log(y);\nlet y = 5;\nこれは何を起こしますか？",
          "options": [
            {
              "icon": "",
              "label": "ReferenceError: Cannot access 'y' before initialization がスロー——let はスコープ最上位にホイストされますが、宣言行が実行されるまで temporal dead zone に留まる"
            },
            {
              "icon": "",
              "label": "undefined を出力——var と同じ"
            },
            {
              "icon": "",
              "label": "5 を出力"
            },
            {
              "icon": "",
              "label": "パースタイムに SyntaxError がスロー"
            }
          ]
        },
        {
          "question": "const arr = [1, 2, 3];\narr.push(4);\nconsole.log(arr.length);\nこれは何を出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "4 ——const は arr バインディング自体の再代入だけを禁止し、それが指すオブジェクトのミューテーションではない。push は動く"
            },
            {
              "icon": "",
              "label": "TypeError がスロー、arr は const だから"
            },
            {
              "icon": "",
              "label": "3 ——const 配列では push がブロック"
            },
            {
              "icon": "",
              "label": "undefined"
            }
          ]
        },
        {
          "question": "console.log('' == 0);\nconsole.log('' === 0);\n2つの行は何を出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "true そして true"
            },
            {
              "icon": "",
              "label": "false そして false"
            },
            {
              "icon": "",
              "label": "true そして false ——== は比較前に空文字列を 0 に強制しますが、=== は強制なしで型と値を比較し、文字列は決して数値と厳密に等しくない"
            },
            {
              "icon": "",
              "label": "false そして true"
            }
          ]
        },
        {
          "question": "console.log(NaN === NaN);\nconsole.log(Number.isNaN(NaN));\n2つの行は何を出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "true そして true"
            },
            {
              "icon": "",
              "label": "true そして false"
            },
            {
              "icon": "",
              "label": "false そして false"
            },
            {
              "icon": "",
              "label": "false そして true ——NaN は JavaScript で === の下で自身と等しくない唯一の値だが、Number.isNaN() はとにかく正しく検出"
            }
          ]
        },
        {
          "question": "console.log(typeof null);\nこれは何を出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "\"null\""
            },
            {
              "icon": "",
              "label": "\"object\" ——言語内の長年のバグ：typeof null は null がプリミティブであっても \"object\" を返す。後方互換性のために保たれている"
            },
            {
              "icon": "",
              "label": "\"undefined\""
            },
            {
              "icon": "",
              "label": "\"boolean\""
            }
          ]
        },
        {
          "question": "if 条件で使うときにどれが truthy ですか？",
          "options": [
            {
              "icon": "",
              "label": "0"
            },
            {
              "icon": "",
              "label": "\"\" (空文字列)"
            },
            {
              "icon": "",
              "label": "null"
            },
            {
              "icon": "",
              "label": "\"0\" ——空でない文字列は JavaScript では常に truthy、その内容が文字列 \"0\" であっても"
            }
          ]
        },
        {
          "question": "foo();\nfunction foo() { console.log('a'); }\nbar();\nvar bar = function() { console.log('b'); };\nこれは何を起こしますか？",
          "options": [
            {
              "icon": "",
              "label": "どちらの呼び出しも出力、\"a\" そして \"b\""
            },
            {
              "icon": "",
              "label": "foo() は \"a\" を出力；bar() は TypeError: bar is not a function がスロー——関数宣言は本体全体でホイストされるが、var 代入の関数式は var だけがホイストされ（undefined として）、代入はされない"
            },
            {
              "icon": "",
              "label": "どちらの呼び出しも ReferenceError がスロー"
            },
            {
              "icon": "",
              "label": "foo() がスロー；bar() が \"b\" を出力"
            }
          ]
        },
        {
          "question": "function makeCounter() {\n  let count = 0;\n  return function() { count++; return count; };\n}\nconst counter = makeCounter();\nconsole.log(counter());\nconsole.log(counter());\n2つの行は何を出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "1 そして 1"
            },
            {
              "icon": "",
              "label": "0 そして 1"
            },
            {
              "icon": "",
              "label": "undefined そして undefined"
            },
            {
              "icon": "",
              "label": "1 そして 2 ——返された関数は makeCounter スコープの同じ count 変数をクロージャし、その変数は呼び出し間でリセットされずに永続する"
            }
          ]
        },
        {
          "question": "for (var i = 0; i < 3; i++) {\n  setTimeout(() => console.log(i), 0);\n}\nこれは何を出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "0, 1, 2"
            },
            {
              "icon": "",
              "label": "3, 3, 3 ——var は function-scoped であり block-scoped ではない。3つすべてのコールバックが同じ i をクロージャし、ループを終えているのに既に 3 に等しい。それらが実行されるとき"
            },
            {
              "icon": "",
              "label": "0, 0, 0"
            },
            {
              "icon": "",
              "label": "undefined, undefined, undefined"
            }
          ]
        },
        {
          "question": "for (let i = 0; i < 3; i++) {\n  setTimeout(() => console.log(i), 0);\n}\nこれは何を出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "3, 3, 3"
            },
            {
              "icon": "",
              "label": "0, 0, 0"
            },
            {
              "icon": "",
              "label": "undefined, undefined, undefined"
            },
            {
              "icon": "",
              "label": "0, 1, 2 ——let はループの各イテレーション毎に i の新しいバインディングを作り、各コールバックは1つの共有変数ではなく自分自身の独立したコピーをクロージャ"
            }
          ]
        },
        {
          "question": "function greet() { return `Hi, ${this.name}`; }\nconst person = { name: 'Ana' };\nconsole.log(greet.call(person));\nこれは何を出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "\"Hi, Ana\" ——Function.prototype.call は this を最初の引数に明示的にセットして関数を呼び出し、this.name は person に対して解決"
            },
            {
              "icon": "",
              "label": "\"Hi, undefined\" ——call() はオブジェクトのメソッドである関数にだけ働く"
            },
            {
              "icon": "",
              "label": "TypeError がスロー、greet は person のメソッドではないから"
            },
            {
              "icon": "",
              "label": "\"Hi, ${this.name}\" ——call() はテンプレートリテラルを評価しない"
            }
          ]
        },
        {
          "question": "const timer = {\n  seconds: 0,\n  start: function() {\n    setInterval(() => { this.seconds++; }, 1000);\n  },\n};\nなぜ人々は setInterval 内で function() { this.seconds++ } よりアロー関数を好みますか？",
          "options": [
            {
              "icon": "",
              "label": "アロー関数は独自の this を持たない——囲む start 関数から字句的に this をキャプチャ。start が timer.start() で呼ばれたので this は timer で、this.seconds はすべてのティックで正しく timer.seconds を指す"
            },
            {
              "icon": "",
              "label": "アロー関数はランタイムで通常関数より速い"
            },
            {
              "icon": "",
              "label": "アロー関数は自動的に this をグローバルオブジェクトにバインド、それが timer と等しい"
            },
            {
              "icon": "",
              "label": "アロー関数は自動的に this をグローバル変数に変換"
            }
          ]
        },
        {
          "question": "function multiply(a, b) { return a * b; }\nconst double = multiply.bind(null, 2);\nconsole.log(double(5));\nこれは何を出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "エラーがスロー、bind は両方の引数を前もって要求するから"
            },
            {
              "icon": "",
              "label": "10 ——bind は this と先頭の引数がプリセットされた新関数を返す；double(5) を呼ぶと残り引数 b=5 が供給され、multiply(2, 5) が実行"
            },
            {
              "icon": "",
              "label": "NaN"
            },
            {
              "icon": "",
              "label": "7、bind が引数を代替ではなく呼び出しに加えるから"
            }
          ]
        },
        {
          "question": "function outer() {\n  let x = 10;\n  function inner() {\n    let x = 20;\n    console.log(x);\n  }\n  inner();\n  console.log(x);\n}\nouter();\n2つの console.log 呼び出しは何を出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "20 そして 20"
            },
            {
              "icon": "",
              "label": "20 そして 10 ——inner の独自 let x は inner のスコープ内だけで outer の x をシャドウ；outer の独自 x は決して変わらない"
            },
            {
              "icon": "",
              "label": "10 そして 10"
            },
            {
              "icon": "",
              "label": "ReferenceError がスロー、x が2回宣言されてるから"
            }
          ]
        },
        {
          "question": "const a = [1, 2, 3];\nconst b = a;\nb.push(4);\nconsole.log(a.length);\nこれは何を出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "3 ——b は a の独立した複製"
            },
            {
              "icon": "",
              "label": "undefined"
            },
            {
              "icon": "",
              "label": "TypeError がスロー、a は const だから"
            },
            {
              "icon": "",
              "label": "4 ——配列はオブジェクトで、const b = a は配列ではなく参照をコピー；b を push でミューテートすると a が指すのと全く同じ配列もミューテート"
            }
          ]
        },
        {
          "question": "const original = { name: 'Ana', tags: ['x', 'y'] };\nconst copy = { ...original };\ncopy.name = 'Bea';\ncopy.tags.push('z');\nconsole.log(original.name, original.tags.length);\nこれは何を出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "'Ana' 2 ——スプレッド展開はすべてのネストされたオブジェクトと配列をディープクローン"
            },
            {
              "icon": "",
              "label": "'Ana' 3 ——スプレッド展開はシャローコピーだけ：name のようなプリミティブプロパティは値でコピーされ copy.name の再代入は original に影響しない；tags のようなネストされた配列は参照でコピーされ copy.tags へのプッシュは original.tags が指す全く同じ配列をミューテート"
            },
            {
              "icon": "",
              "label": "'Bea' 3 ——スプレッド展開はすべてを参照でコピー、最上位もネストされた変更も original に戻ってくる"
            },
            {
              "icon": "",
              "label": "'Bea' 2"
            }
          ]
        },
        {
          "question": "const { a: x = 10, b: y = 20 } = { a: 5 };\nconsole.log(x, y);\nこれは何を出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "undefined undefined"
            },
            {
              "icon": "",
              "label": "5 undefined"
            },
            {
              "icon": "",
              "label": "10 20"
            },
            {
              "icon": "",
              "label": "5 20 ——a は x に名前変更され存在し、その値 5 を保つ；b は y に名前変更され不在で、デフォルト 20 に落ち着く"
            }
          ]
        },
        {
          "question": "const [first, ...rest] = [1, 2, 3, 4];\nconsole.log(rest);\nこれは何を出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 3, 4]"
            },
            {
              "icon": "",
              "label": "[2, 3, 4] ——rest は first 後のすべての残り要素を新しい配列に集める"
            },
            {
              "icon": "",
              "label": "2"
            },
            {
              "icon": "",
              "label": "[1]"
            }
          ]
        },
        {
          "question": "const nums = [10, 1, 2];\nnums.sort();\nconsole.log(nums);\nこれは何を出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 10] ——sort は常にデフォルトで昇順に数値を数値的に順序付け"
            },
            {
              "icon": "",
              "label": "[10, 1, 2] ——sort は元の配列をミューテートしない"
            },
            {
              "icon": "",
              "label": "[1, 10, 2] ——Array.prototype.sort のデフォルト比較器は要素を文字列に変換して字句比較し、\"10\" が \"2\" の前にソート；sort も新規配列ではなく本所でミューテート"
            },
            {
              "icon": "",
              "label": "[2, 1, 10]"
            }
          ]
        },
        {
          "question": "const user = { profile: { age: 0 } };\nconsole.log(user.profile?.age ?? 'unknown');\nconsole.log(user.address?.city ?? 'unknown');\n2つの行は何を出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "'unknown' そして 'unknown' ——?? は 0 を || と同じやり方で不在として扱う"
            },
            {
              "icon": "",
              "label": "0 そして 'unknown' ——?? は null か undefined だけで落ち着き、0 のような他の falsy 値ではない。age (0) は保たれる；user.address は undefined で、?. は全チェーンを undefined に短絡し ?? は 'unknown' を供給"
            },
            {
              "icon": "",
              "label": "0 そして undefined"
            },
            {
              "icon": "",
              "label": "'unknown' そして 0"
            }
          ]
        },
        {
          "question": "const obj = { a: undefined, b: function(){}, c: NaN, d: [undefined, function(){}, 1] };\nconsole.log(JSON.stringify(obj));\nこれは何を出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "'{\"a\":null,\"b\":null,\"c\":null,\"d\":[null,null,1]}' ——サポートされないすべての値がどこでも null になり、オブジェクトも配列も同じ"
            },
            {
              "icon": "",
              "label": "'{\"a\":undefined,\"b\":undefined,\"c\":NaN,\"d\":[undefined,null,1]}'"
            },
            {
              "icon": "",
              "label": "'{\"c\":null,\"d\":[null,null,1]}' ——値が undefined か関数のオブジェクトプロパティは完全に省略され、NaN は null にシリアライズされるが、配列内ではこれらの同じサポートされない値は削除ではなく null になる。配列要素を削除すると後ろのインデックスすべてがシフト"
            },
            {
              "icon": "",
              "label": "TypeError がスロー、NaN は JSON にシリアライズできないから"
            }
          ]
        },
        {
          "question": "console.log('1');\nsetTimeout(() => console.log('2'), 0);\nPromise.resolve().then(() => console.log('3'));\nconsole.log('4');\nこれらはどの順で出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "1, 2, 3, 4"
            },
            {
              "icon": "",
              "label": "1, 4, 2, 3"
            },
            {
              "icon": "",
              "label": "1, 4, 3, 2 ——同期コードが最初に実行される（1 と 4 が即座に出力）、その後マイクロタスクキュー（Promise コールバック）が次のマクロタスクに移る前に完全にドレイン。3 が setTimeout コールバック 2 の前に出力"
            },
            {
              "icon": "",
              "label": "1, 3, 4, 2"
            }
          ]
        },
        {
          "question": "async function foo() {\n  console.log('a');\n  await null;\n  console.log('b');\n}\nconsole.log('start');\nfoo();\nconsole.log('end');\nこれらはどの順で出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "start, a, end, b ——foo() は最初の await まで同期的に実行され、foo() が呼ばれたとき 'a' が即座にログ；await はその後 foo をサスペンドして呼び出し元に制御を返し 'end' がログ；再開した 'b' はマイクロタスクとして後で実行"
            },
            {
              "icon": "",
              "label": "start, a, b, end"
            },
            {
              "icon": "",
              "label": "start, end, a, b"
            },
            {
              "icon": "",
              "label": "a, start, end, b"
            }
          ]
        },
        {
          "question": "Promise.all([\n  Promise.resolve(1),\n  Promise.reject('err'),\n  Promise.resolve(3),\n]).then(r => console.log('ok', r)).catch(e => console.log('fail', e));\nこれは何を出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "'fail err' ——Promise.all は入力 promise のいずれかが reject された瞬間に reject し、他の結果を無視；catch ハンドラがその reject の理由で実行"
            },
            {
              "icon": "",
              "label": "'ok' [1, 3]"
            },
            {
              "icon": "",
              "label": "'ok' [1, undefined, 3]"
            },
            {
              "icon": "",
              "label": "同期的にスロー、ハンドラは実行されない"
            }
          ]
        },
        {
          "question": "const fast = new Promise(res => setTimeout(() => res('fast'), 10));\nconst slow = new Promise(res => setTimeout(() => res('slow'), 100));\nPromise.race([fast, slow]).then(v => console.log(v));\nこれは何を出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "'slow'"
            },
            {
              "icon": "",
              "label": "['fast', 'slow']"
            },
            {
              "icon": "",
              "label": "'fast' ——Promise.race は入力 promise のいずれかが settle された瞬間に settle し、10ms タイマーが 100ms タイマーをはるか前に解決"
            },
            {
              "icon": "",
              "label": "エラーがスロー、race は正確に2つの promise を要求するから"
            }
          ]
        },
        {
          "question": "function Animal(name) { this.name = name; }\nAnimal.prototype.speak = function() { return `${this.name} makes a sound`; };\nconst dog = new Animal('Rex');\nconsole.log(dog.speak());\nconsole.log(dog.hasOwnProperty('speak'));\n2つの行は何を出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "'Rex makes a sound' そして true"
            },
            {
              "icon": "",
              "label": "undefined そして false"
            },
            {
              "icon": "",
              "label": "TypeError がスロー、dog は独自の speak メソッドを持たないから"
            },
            {
              "icon": "",
              "label": "'Rex makes a sound' そして false ——speak は dog インスタンス自体ではなく Animal.prototype で定義；dog は呼ばれたときプロトタイプチェーンを通じて見つけるが、hasOwnProperty はインスタンスの独自プロパティだけチェックし、継承は何もしない"
            }
          ]
        },
        {
          "question": "class Counter {\n  #count = 0;\n  increment() { this.#count++; return this.#count; }\n}\nconst c = new Counter();\nconsole.log(c.increment());\nconsole.log(c.count);\n2つの行は何を出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "1 そして undefined ——#count はプライベートクラスフィールド、読み書きはクラス自身のメソッド内だけ；c.count (# なし) は全く別の普通のプロパティで、セットされず undefined"
            },
            {
              "icon": "",
              "label": "1 そして 0"
            },
            {
              "icon": "",
              "label": "1 そして 1"
            },
            {
              "icon": "",
              "label": "c.count にアクセス時に SyntaxError がスロー"
            }
          ]
        },
        {
          "question": "const items = ['a', 'b'];\nconst label = `Items: ${items.length > 0 ? items.join(', ') : 'none'}`;\nconsole.log(label);\nこれは何を出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "'Items: ${items.length > 0 ? items.join(\\', \\') : \\'none\\'}'"
            },
            {
              "icon": "",
              "label": "'Items: none'"
            },
            {
              "icon": "",
              "label": "'Items: a, b' ——テンプレートリテラルは ${...} に置かれた任意の式を評価し、完全な三項を含む；その結果を文字列に直接挿入"
            },
            {
              "icon": "",
              "label": "SyntaxError がスロー、三項はテンプレートリテラル内で許可されないから"
            }
          ]
        },
        {
          "question": "const nums = [1, 2, 3, 4, 5];\nconst result = nums.filter(n => n % 2 === 0).map(n => n * 10).reduce((sum, n) => sum + n, 0);\nconsole.log(result, nums);\nこれは何を出力しますか？",
          "options": [
            {
              "icon": "",
              "label": "60 [1, 2, 3, 4, 5] ——filter、map、reduce はそれぞれ元の配列をミューテートせずに新規配列か値を返す；nums は変わらず result は最終的に削減された sum (2 と 4、20 と 40 に2倍、60 に合計)"
            },
            {
              "icon": "",
              "label": "60 [2, 4, 20, 40]"
            },
            {
              "icon": "",
              "label": "150 [1, 2, 3, 4, 5]"
            },
            {
              "icon": "",
              "label": "60 [20, 40]"
            }
          ]
        }
      ],
      "optionOrderVersion": "50fc0eba818f2d72"
    }
  }
}