{
  "assessmentTests": {
    "javascript_test": {
      "name": "JavaScript Testi",
      "desc": "Temel söz dizimi ve tür dönüştürme, işlevler/kapsam/kapanışlar ve bu, nesneler/diziler ve veri yapıları ve olay döngüsü/eşzamansız/prototip idiomları hakkında 30 senaryoya dayalı soru — JavaScript'inizin bir işverenin JavaScript yeterliliği ile kastettiği şeyle eşleşip eşleşmediğini öğrenin.",
      "recommendation": "JavaScript beceri profiliniz",
      "results": {
        "beginner": {
          "name": "Başlangıç",
          "desc": "Çalışan işlevler ve nesneler yazabiliyor olabilirsiniz, ancak kaçırdığınız sorular tür dönüştürme ve referans semantiğine değil söz dizimine değil merkezlidir — == sessizce karşılaştırmadan önce türleri dönüştürür, dizi ataması kopyalamak yerine bir başvuruyu paylaştırır, NaN neden asla kendisine eşit değildir. Bu JavaScript'te kötü olmakla ilgili değildir; bunlar, dili, çalışan kodu yazarak öğrenen insanları yanıltmak için özel kurallar — değerlerin ve referansların gerçekten nasıl davrandığını anlaşmak yerine. Çalışmada önemlidirler çünkü her biri kodun hatasız çalıştığı ve yine de yanlış şey yaptığı bir yerdir.",
          "recommendation": "Üç şeyle başlayın, bu sırayla: == neden türleri karşılaştırmadan önce dönüştürür === yapmazken; bir diziyi veya nesneyi yeni bir değişkene atamak başvuruyu neden kopyalar değeri değil; var nasıl kaldırılır ve tanımsız olarak başlatılırken ve let ile const çalıştırma kapsama girene kadar ölü bölgede kalır. MDN'nin JavaScript kılavuzu çalıştırılabilir örneklerle üçünü de kapsar."
        },
        "intermediate": {
          "name": "Orta Seviye",
          "desc": "Günlük uygulama kodunu rahatça yönetiyorsunuz — işlevler, dizi yöntemleri, basit kontrol akışı — ve rutin özellik geliştirmelerinden yavaşlamayacaksınız. Buradaki ile İleri Seviye arasındaki boşluk çoğunlukla JavaScript'in kapsam ve zamanlama kurallarının nasıl etkileşime girdiğinde yatmaktadır: bir döngünün geri çağırma içinde yakalanan var beklediğiniz aynı nihai değeri; bu bir nesneyi işaret etmeyi bırakır bir yöntem ayrıldığında; derin görünen ancak sadece bir seviyeyi kopyalayan spread-kopyası. Bu tür hatalar hızlı bir okumayı geçer ve sadece belirli bir runtime koşulu altında görünür.",
          "recommendation": "Kapsamın ve bunun aslında çağrı zamanında nasıl çözüldüğüne odaklanın, tanım zamanında değil: bir var tabanlı for döngüsü neden her geri çağırmaya aynı nihai sayaç değerini iletir, let değil; bu nasıl belirlenir bir işlev çağrılır, yazıldığı yer değil; neden bir spread veya Object.assign sadece bir nesnenin en üst seviyesini kopyalar. Sonra olay döngüsü, çünkü bu promises'i bireysel olarak zaten anlayan insanları karıştıran şeydir."
        },
        "advanced": {
          "name": "İleri Seviye",
          "desc": "Bu, çoğu iş ilanının \"güçlü JavaScript\" ile kastettiği seviyedir. Bir filter/map/reduce zincirini okursunuz ve orijinal diziyi değiştirmeden tam olarak ne döndüreceğini tahmin edebilirsiniz, neden senkron console.log'un her zaman bir microtask'ı yeneceğini bilirsiniz — bu da her zaman bir setTimeout'u yener; Promise.all'a başvurursunuz rest beklemek yerine herhangi bir promise reddetme anında reddettiğini bilerek. Bu bandı üstten ayıran şey prototip ve nesne modeli çalışmasıdır: prototip zinciri bir kalıtsal yöntemi hasOwnProperty ile karşılaştırarak nasıl çözer; bir sınıfın özel #fields gerçekten ne saklıyor.",
          "recommendation": "Diğer kodun da ilgilendikleri durum koruyan kısımlara ilerlemeyin: JavaScript'in prototip zinciri örneğin kendisinde olmayan yöntem aramaları nasıl çözer; bir sınıfın özel #fields dış erişimden gerçekten ne saklar; JSON.stringify tanımlanmamış ve işlevleri düz bir nesnenin içinde farklı şekilde bir diziye karşı ele alır. MDN'nin olay döngüsü ve prototip zinciri materyalleri her ikisi için doğal bir sonraki adımdır."
        },
        "expert": {
          "name": "Uzman",
          "desc": "Her bölümde en yüksek puanı aldınız — temel söz dizimi, türler ve dönüştürme; işlevler, kapsam, kapanışlar ve bu; nesneler, diziler ve veri yapıları; ve eşzamansız, olay döngüsü, prototip ve idiomlar. Pratik olarak, bu yabancı bir işlevin alıp açıklayabileceğiniz anlamına gelir neden döndürdüğünü, söz dizimi ne söylemek gerekir göründüğü değil — bu daha zor ve daha değerli beceridir. Bu seviyede dil kendisi nadiren sınırlayıcı faktördür; sınır genellikle eşzamansız kontrol akışı veya altındaki verinin şeklidir.",
          "recommendation": "Getiri şimdi tasarımda ve tanıda yatıyor: Promise.all ve Promise.race arasındaki bir yarış koşulu hakkında sadece tanımlarını alıntı yapmak yerine akıl yürütme; bir kapanış özel durum için doğru araç ne zaman seçme sınıfın özel alanı karşı; üretim günlüklerinde bir microtask-vs-macrotask sıralama hatası okuma quiz'de değil. Bir rol için taranıyorsanız bulduğunuz bir zamanlama hatası açıklayın — eski bir kapanış değişkeni veya yanlış sıralanmış eşzamansız geri çağırma — sadece adı koymak yerine JavaScript özellikleri; bu akıl yürütmeyi gösterir, sadece söz dağarcığı değil."
        }
      },
      "questions": [
        {
          "question": "console.log(x);\nvar x = 5;\nBu ne yazdırır?",
          "options": [
            {
              "icon": "",
              "label": "5 — var bildirimleri diğer kodlardan önce hemen çalışır"
            },
            {
              "icon": "",
              "label": "ReferenceError: x is not defined"
            },
            {
              "icon": "",
              "label": "undefined — var bildirimleri kendi scope'unun en üstüne taşınırlar ve undefined olarak başlatılırlar, ancak atama yerinde gerçekleşir, bu nedenle çalışmadan önce değişken var fakat undefined içerir"
            },
            {
              "icon": "",
              "label": "null"
            }
          ]
        },
        {
          "question": "console.log(y);\nlet y = 5;\nNe olur?",
          "options": [
            {
              "icon": "",
              "label": "ReferenceError: Cannot access 'y' before initialization fırlatır — let kendi scope'unun en üstüne taşınır ancak temporal dead zone'da kalır, bildirim satırı gerçekten çalışıncaya kadar"
            },
            {
              "icon": "",
              "label": "undefined yazdırır, var gibi aynı şekilde"
            },
            {
              "icon": "",
              "label": "5 yazdırır"
            },
            {
              "icon": "",
              "label": "Parse zamanında SyntaxError fırlatır"
            }
          ]
        },
        {
          "question": "const arr = [1, 2, 3];\narr.push(4);\nconsole.log(arr.length);\nBu ne yazdırır?",
          "options": [
            {
              "icon": "",
              "label": "4 — const sadece arr bağlamasının yeniden atanmasını engeller, işaret ettiği dizi nesnesinin değiştirilmesini değil, bu nedenle push yine de çalışır"
            },
            {
              "icon": "",
              "label": "arr const olduğu için TypeError fırlatır"
            },
            {
              "icon": "",
              "label": "3 — const dizide push engellenir"
            },
            {
              "icon": "",
              "label": "undefined"
            }
          ]
        },
        {
          "question": "console.log('' == 0);\nconsole.log('' === 0);\nİki satır ne yazdırır?",
          "options": [
            {
              "icon": "",
              "label": "true sonra true"
            },
            {
              "icon": "",
              "label": "false sonra false"
            },
            {
              "icon": "",
              "label": "true sonra false — == karşılaştırmadan önce boş stringi 0'a zorlar, === ise tip zorlama olmadan tip ve değeri karşılaştırır, ve bir string asla bir sayıya kesin eşit değildir"
            },
            {
              "icon": "",
              "label": "false sonra true"
            }
          ]
        },
        {
          "question": "console.log(NaN === NaN);\nconsole.log(Number.isNaN(NaN));\nİki satır ne yazdırır?",
          "options": [
            {
              "icon": "",
              "label": "true sonra true"
            },
            {
              "icon": "",
              "label": "true sonra false"
            },
            {
              "icon": "",
              "label": "false sonra false"
            },
            {
              "icon": "",
              "label": "false sonra true — NaN, JavaScript'te === altında kendisine eşit olmayan tek değerdir, ancak Number.isNaN() bunu yine de doğru şekilde algılar"
            }
          ]
        },
        {
          "question": "console.log(typeof null);\nBu ne yazdırır?",
          "options": [
            {
              "icon": "",
              "label": "\"null\""
            },
            {
              "icon": "",
              "label": "\"object\" — dildeki uzun süreli bir hata: typeof null \"object\" döndürür, null bir ilkel (primitive) olmasına rağmen, geriye uyumluluk için o zamandan beri böyle tutulmuştur"
            },
            {
              "icon": "",
              "label": "\"undefined\""
            },
            {
              "icon": "",
              "label": "\"boolean\""
            }
          ]
        },
        {
          "question": "Aşağıdakilerden hangisi if koşulunda kullanıldığında truthy'dir?",
          "options": [
            {
              "icon": "",
              "label": "0"
            },
            {
              "icon": "",
              "label": "\"\" (boş bir string)"
            },
            {
              "icon": "",
              "label": "null"
            },
            {
              "icon": "",
              "label": "\"0\" — boş olmayan bir string JavaScript'te her zaman truthy'dir, içeriği \"0\" stringi olsa bile"
            }
          ]
        },
        {
          "question": "foo();\nfunction foo() { console.log('a'); }\nbar();\nvar bar = function() { console.log('b'); };\nNe olur?",
          "options": [
            {
              "icon": "",
              "label": "Her iki çağrı yazdırır, \"a\" sonra \"b\""
            },
            {
              "icon": "",
              "label": "foo() \"a\" yazdırır; bar() TypeError: bar is not a function fırlatır — function bildirimleri gövdeleriyle beraber tamamen taşınırlar, ancak var-atanmış fonksiyon ifadeleri sadece var'ın kendisini (undefined olarak) taşırlar, atamayı değil"
            },
            {
              "icon": "",
              "label": "Her iki çağrı ReferenceError fırlatır"
            },
            {
              "icon": "",
              "label": "foo() fırlatır; bar() \"b\" yazdırır"
            }
          ]
        },
        {
          "question": "function makeCounter() {\n  let count = 0;\n  return function() { count++; return count; };\n}\nconst counter = makeCounter();\nconsole.log(counter());\nconsole.log(counter());\nİki satır ne yazdırır?",
          "options": [
            {
              "icon": "",
              "label": "1 sonra 1"
            },
            {
              "icon": "",
              "label": "0 sonra 1"
            },
            {
              "icon": "",
              "label": "undefined sonra undefined"
            },
            {
              "icon": "",
              "label": "1 sonra 2 — döndürülen fonksiyon makeCounter'ın scope'unda aynı count değişkenini kapatır ve bu değişken çağrılar arasında sıfırlanmak yerine devam eder"
            }
          ]
        },
        {
          "question": "for (var i = 0; i < 3; i++) {\n  setTimeout(() => console.log(i), 0);\n}\nBu ne yazdırır?",
          "options": [
            {
              "icon": "",
              "label": "0, 1, 2"
            },
            {
              "icon": "",
              "label": "3, 3, 3 — var fonksiyon-scope'lu, blok-scope'lu değil, bu nedenle üç callback de aynı i'yi kapatırlar ve bu zaten döngüyü bitirmiştir, herhangi biri gerçekten çalışana kadar 3'e eşittir"
            },
            {
              "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}\nBu ne yazdırır?",
          "options": [
            {
              "icon": "",
              "label": "3, 3, 3"
            },
            {
              "icon": "",
              "label": "0, 0, 0"
            },
            {
              "icon": "",
              "label": "undefined, undefined, undefined"
            },
            {
              "icon": "",
              "label": "0, 1, 2 — let, her döngü yinelemesi için i'nin yeni bir bağlaması oluşturur, bu nedenle her geri çağırma tek bir paylaşılan değişken yerine kendi ayrı kopyası üzerine kapalıdır"
            }
          ]
        },
        {
          "question": "function greet() { return `Hi, ${this.name}`; }\nconst person = { name: 'Ana' };\nconsole.log(greet.call(person));\nBu ne yazdırır?",
          "options": [
            {
              "icon": "",
              "label": "\"Hi, Ana\" — Function.prototype.call işlevi ilk argümanına açıkça ayarlanmış this ile çağırır, bu nedenle this.name person'a göre çözülür"
            },
            {
              "icon": "",
              "label": "\"Hi, undefined\" — call() yalnızca zaten bir nesnenin yöntemi olan işlevlerde çalışır"
            },
            {
              "icon": "",
              "label": "TypeError fırlatır, çünkü greet, person'un bir yöntemi değildir"
            },
            {
              "icon": "",
              "label": "\"Hi, ${this.name}\" — call() şablon dizesi değerlendirmez"
            }
          ]
        },
        {
          "question": "const timer = {\n  seconds: 0,\n  start: function() {\n    setInterval(() => { this.seconds++; }, 1000);\n  },\n};\nİnsanlar setInterval içinde function() { this.seconds++ } yerine ok işlevini neden tercih ediyor?",
          "options": [
            {
              "icon": "",
              "label": "Ok işlevlerinin kendi this'i yoktur — bunlar enclosing start işlevinden this'i leksiksel olarak yakalarlar, bu da timer'dır (çünkü start, timer.start() olarak çağrıldı), bu nedenle this.seconds her tikde timer.seconds'u doğru şekilde ifade eder"
            },
            {
              "icon": "",
              "label": "Ok işlevleri çalışma zamanında normal işlevlerden daha hızlı yürütülür"
            },
            {
              "icon": "",
              "label": "Ok işlevleri otomatik olarak this'i küresel nesneye bağlar, bu da timer'a eşit olmaya devam eder"
            },
            {
              "icon": "",
              "label": "Ok işlevleri this'i otomatik olarak küresel bir değişkene dönüştürür"
            }
          ]
        },
        {
          "question": "function multiply(a, b) { return a * b; }\nconst double = multiply.bind(null, 2);\nconsole.log(double(5));\nBu ne yazdırır?",
          "options": [
            {
              "icon": "",
              "label": "Hata fırlatır, çünkü bind her iki argümanı da önceden gerektirur"
            },
            {
              "icon": "",
              "label": "10 — bind, this ve önceden ayarlanmış tüm başında gelen argümanları içeren yeni bir işlev döndürür; double(5) çağrıldığında kalan b=5 argümanı sağlar, bu nedenle multiply(2, 5) çalışır"
            },
            {
              "icon": "",
              "label": "NaN"
            },
            {
              "icon": "",
              "label": "7, çünkü bind argümanlarını çağrıya ekler, onları değiştirmez"
            }
          ]
        },
        {
          "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();\nİki console.log çağrısı ne yazdırır?",
          "options": [
            {
              "icon": "",
              "label": "20 sonra 20"
            },
            {
              "icon": "",
              "label": "20 sonra 10 — inner'ın kendi let x'i outer'ın x'ini yalnızca inner'ın kapsamı içinde gölgeler; outer'ın kendi x'i asla dokunulmaz"
            },
            {
              "icon": "",
              "label": "10 sonra 10"
            },
            {
              "icon": "",
              "label": "ReferenceError fırlatır, çünkü x iki kez bildirilir"
            }
          ]
        },
        {
          "question": "const a = [1, 2, 3];\nconst b = a;\nb.push(4);\nconsole.log(a.length);\nBu ne yazdırır?",
          "options": [
            {
              "icon": "",
              "label": "3 — b, a'nın ayrı bir kopyasıdır"
            },
            {
              "icon": "",
              "label": "undefined"
            },
            {
              "icon": "",
              "label": "TypeError fırlatır, çünkü a const'tur"
            },
            {
              "icon": "",
              "label": "4 — diziler nesnelerdir, bu nedenle const b = a referansı kopyalar, diziyi değil; b'yi push aracılığıyla mutate etmek a'nın işaret ettiği tam aynı diziyi de mutate eder"
            }
          ]
        },
        {
          "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);\nBu ne yazdırır?",
          "options": [
            {
              "icon": "",
              "label": "'Ana' 2 — spread, her iç içe geçmiş nesneyi ve diziyi derin olarak klonlar"
            },
            {
              "icon": "",
              "label": "'Ana' 3 — spread yalnızca sığ bir kopyadır: name gibi ilkel bir özellik değer tarafından kopyalanır, bu nedenle copy.name'i yeniden atamak hiçbir zaman orijinale dokunmaz, ancak tags gibi iç içe geçmiş bir dizi referans tarafından kopyalanır, bu nedenle copy.tags'a push orijinal.tags'ın işaret ettiği tam aynı diziyi mutate eder"
            },
            {
              "icon": "",
              "label": "'Bea' 3 — spread her şeyi referans olarak kopyalar, bu nedenle hem üst düzey hem de iç içe geçmiş değişiklikler orijinale geri döner"
            },
            {
              "icon": "",
              "label": "'Bea' 2"
            }
          ]
        },
        {
          "question": "const { a: x = 10, b: y = 20 } = { a: 5 };\nconsole.log(x, y);\nBu ne yazdırır?",
          "options": [
            {
              "icon": "",
              "label": "undefined undefined"
            },
            {
              "icon": "",
              "label": "5 undefined"
            },
            {
              "icon": "",
              "label": "10 20"
            },
            {
              "icon": "",
              "label": "5 20 — a, x olarak yeniden adlandırılır ve mevcuttur, bu nedenle değerini 5 tutar; b, y olarak yeniden adlandırılır ve yoktur, bu nedenle varsayılan 20'ye geri döner"
            }
          ]
        },
        {
          "question": "const [first, ...rest] = [1, 2, 3, 4];\nconsole.log(rest);\nBu ne yazdırır?",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 3, 4]"
            },
            {
              "icon": "",
              "label": "[2, 3, 4] — rest, first'ten sonra kalan her elemanı yeni bir diziye toplar"
            },
            {
              "icon": "",
              "label": "2"
            },
            {
              "icon": "",
              "label": "[1]"
            }
          ]
        },
        {
          "question": "const nums = [10, 1, 2];\nnums.sort();\nconsole.log(nums);\nBu ne yazdırır?",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 10] — sort her zaman sayıları varsayılan olarak sayısal olarak artan sırada sıralar"
            },
            {
              "icon": "",
              "label": "[10, 1, 2] — sort orijinal diziyi mutate etmez"
            },
            {
              "icon": "",
              "label": "[1, 10, 2] — Array.prototype.sort'un varsayılan karşılaştırıcı öğeleri dizelere dönüştürür ve sözlüksel olarak karşılaştırır, bu nedenle \"10\", \"2\"'den önce sıralanır; sort yeni bir tane döndürmek yerine diziyi yerinde mutate eder"
            },
            {
              "icon": "",
              "label": "[2, 1, 10]"
            }
          ]
        },
        {
          "question": "const user = { profile: { age: 0 } };\nconsole.log(user.profile?.age ?? 'unknown');\nconsole.log(user.address?.city ?? 'unknown');\nBu iki satır ne yazdırır?",
          "options": [
            {
              "icon": "",
              "label": "'unknown' sonra 'unknown' — ?? değeri 0 olarak eksik görür, || gibi davranır"
            },
            {
              "icon": "",
              "label": "0 sonra 'unknown' — ?? yalnızca null veya undefined döner, 0 gibi diğer falsy değerlerde değil, bu nedenle age (0) olduğu gibi kalır; user.address undefined olduğu için ?. tüm zinciri undefined'a kırpıyor ve ?? sonra 'unknown' sağlıyor"
            },
            {
              "icon": "",
              "label": "0 sonra undefined"
            },
            {
              "icon": "",
              "label": "'unknown' sonra 0"
            }
          ]
        },
        {
          "question": "const obj = { a: undefined, b: function(){}, c: NaN, d: [undefined, function(){}, 1] };\nconsole.log(JSON.stringify(obj));\nBu ne yazdırır?",
          "options": [
            {
              "icon": "",
              "label": "'{\"a\":null,\"b\":null,\"c\":null,\"d\":[null,null,1]}' — her desteklenmeyen değer her yerde null olur, nesnelerde ve dizilerde"
            },
            {
              "icon": "",
              "label": "'{\"a\":undefined,\"b\":undefined,\"c\":NaN,\"d\":[undefined,null,1]}'"
            },
            {
              "icon": "",
              "label": "'{\"c\":null,\"d\":[null,null,1]}' — değeri undefined veya bir işlev olan nesne özellikleri tamamen atlanır ve NaN null olarak serileşir, ancak bir dizi içinde bu desteklenmeyen değerler null olur çıkarılmak yerine, çünkü bir dizi öğesini kaldırmak sonraki tüm indeksleri kaydırır"
            },
            {
              "icon": "",
              "label": "TypeError fırlatır, çünkü NaN'i JSON'a serileştiremez"
            }
          ]
        },
        {
          "question": "console.log('1');\nsetTimeout(() => console.log('2'), 0);\nPromise.resolve().then(() => console.log('3'));\nconsole.log('4');\nBu satırlar hangi sırayla yazdırılır?",
          "options": [
            {
              "icon": "",
              "label": "1, 2, 3, 4"
            },
            {
              "icon": "",
              "label": "1, 4, 2, 3"
            },
            {
              "icon": "",
              "label": "1, 4, 3, 2 — senkron kod önce çalışır (bu nedenle 1 ve 4 hemen yazdırılır), sonra mikrotask kuyruğu (Promise geri çağrıları) tamamen boşaltılır, olay döngüsü sonraki makrotask'a geçmeden önce, bu nedenle 3, setTimeout geri çağrısının 2'sinden önce yazdırılır"
            },
            {
              "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');\nBu satırlar hangi sırayla yazdırılır?",
          "options": [
            {
              "icon": "",
              "label": "start, a, end, b — foo() ilk await'e kadar senkron olarak çalışır, bu nedenle foo() çağrıldığında 'a' hemen günlüğe kaydedilir; await daha sonra foo'yu askıya alır ve kontrolü arayana döndürür, bu nedenle 'end' devam eden 'b'den önce günlüğe kaydedilir, bu daha sonra bir mikrotask olarak çalışır"
            },
            {
              "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));\nBu ne yazdırır?",
          "options": [
            {
              "icon": "",
              "label": "'fail err' — Promise.all giriş vaatleri herhangi birinin reddettiği anda reddeder, diğerlerinin sonuçlarını göz ardı eder, bu nedenle catch işleyicisi bu reddetmenin nedeniyle çalışır"
            },
            {
              "icon": "",
              "label": "'ok' [1, 3]"
            },
            {
              "icon": "",
              "label": "'ok' [1, undefined, 3]"
            },
            {
              "icon": "",
              "label": "Senkron olarak bir hata fırlatır ve hiçbir işleyici çalışmaz"
            }
          ]
        },
        {
          "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));\nBu ne yazdırır?",
          "options": [
            {
              "icon": "",
              "label": "'slow'"
            },
            {
              "icon": "",
              "label": "['fast', 'slow']"
            },
            {
              "icon": "",
              "label": "'fast' — Promise.race giriş vaatlerinden ilki karara bağlandığında hemen çözer ve 10ms zamanlayıcı 100ms zamanlayıcıdan çok daha önce çözer"
            },
            {
              "icon": "",
              "label": "Hata fırlatır, çünkü race tam olarak iki vaadi gerektirir"
            }
          ]
        },
        {
          "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'));\nBu iki satır ne yazdırır?",
          "options": [
            {
              "icon": "",
              "label": "'Rex makes a sound' sonra true"
            },
            {
              "icon": "",
              "label": "undefined sonra false"
            },
            {
              "icon": "",
              "label": "TypeError fırlatır, çünkü dog'un kendine ait speak metodu yoktur"
            },
            {
              "icon": "",
              "label": "'Rex makes a sound' sonra false — speak, dog örneğinde değil, Animal.prototype'de tanımlanır; dog çağrıldığında bunu prototip zinciri aracılığıyla bulur, ancak hasOwnProperty yalnızca örneğin kendi özelliklerini kontrol eder, devralınan hiçbir şeyi değil"
            }
          ]
        },
        {
          "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);\nBu iki satır ne yazdırır?",
          "options": [
            {
              "icon": "",
              "label": "1 sonra undefined — #count özel bir sınıf alanıdır, yalnızca sınıfın kendi yöntemleri içinden okunabilir ve yazılabilir; c.count (# olmadan) hiçbir zaman ayarlanmamış tamamen farklı, sıradan bir özelliktir, bu nedenle undefined'dır"
            },
            {
              "icon": "",
              "label": "1 sonra 0"
            },
            {
              "icon": "",
              "label": "1 sonra 1"
            },
            {
              "icon": "",
              "label": "c.count'a erişirken SyntaxError fırlatır"
            }
          ]
        },
        {
          "question": "const items = ['a', 'b'];\nconst label = `Items: ${items.length > 0 ? items.join(', ') : 'none'}`;\nconsole.log(label);\nBu ne yazdırır?",
          "options": [
            {
              "icon": "",
              "label": "'Items: ${items.length > 0 ? items.join(\\', \\') : \\'none\\'}'"
            },
            {
              "icon": "",
              "label": "'Items: none'"
            },
            {
              "icon": "",
              "label": "'Items: a, b' — şablon değişmezleri ${...} içine yerleştirilen herhangi bir ifadeyi, tam ternary dahil olmak üzere değerlendirir ve sonucunu doğrudan dizeye enterpolasyonlaştırır"
            },
            {
              "icon": "",
              "label": "SyntaxError fırlatır, çünkü ternary'ler şablon değişmezleri içinde kullanılamaz"
            }
          ]
        },
        {
          "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);\nBu ne yazdırır?",
          "options": [
            {
              "icon": "",
              "label": "60 [1, 2, 3, 4, 5] — filter, map ve reduce her biri orijinal diziyi değiştirmeden yeni bir dizi veya değer döndürür, bu nedenle nums değişmez ve result son indirgenmiş toplamdır (2 ve 4, 20 ve 40'a ikiye katlanmış, 60'a toplanmış)"
            },
            {
              "icon": "",
              "label": "60 [2, 4, 20, 40]"
            },
            {
              "icon": "",
              "label": "150 [1, 2, 3, 4, 5]"
            },
            {
              "icon": "",
              "label": "60 [20, 40]"
            }
          ]
        }
      ],
      "optionOrderVersion": "50fc0eba818f2d72"
    }
  }
}