Live Coding

Bir JavaScript nesnesinin boş olup olmadığını nasıl kontrol edersiniz?

Açıklama: Bir nesne, kendi numaralandırılabilir özelliklerine sahip değilse boştur. Verilen bir nesnenin kendi numaralandırılabilir özellik adlarının bir dizisini döndüren Object.keys(obj)'yi kullanabiliriz. Bu dizinin uzunluğu 0 ise, nesne boştur.

function isEmpty(obj) {
  return Object.keys(obj).length === 0;
}

console.log(isEmpty({})); // true
console.log(isEmpty({ a: 1 })); // false

Verilen bir dizeyi tersine çeviren bir fonksiyon yazın.

Açıklama: En basit yol, dizeyi karakter dizisine dönüştürmek, diziler için yerleşik reverse() metodunu kullanmak ve ardından karakterleri tekrar bir dizeye birleştirmektir.

function reverseString(str) {
  return str.split('').reverse().join('');
}

console.log(reverseString('hello')); // 'olleh'

Verilen bir dizenin palindrom olup olmadığını kontrol eden bir fonksiyon yazın.

Açıklama: Palindrom, ileri ve geri aynı okunan bir kelime veya ifadedir. Bunu, dizeyi tersine çevirerek (daha sağlam bir kontrol için büyük/küçük harf ve alfanümerik olmayan karakterleri göz ardı ederek, ancak burada basit bir kontrol yapıyoruz) ve orijinaliyle karşılaştırarak kontrol edebiliriz.

function isPalindrome(str) {
  const reversed = str.split('').reverse().join('');
  return str === reversed;
}

console.log(isPalindrome('racecar')); // true
console.log(isPalindrome('hello')); // false

Sayı dizisindeki en büyük sayıyı bulan bir fonksiyon yazın.

Açıklama: Dizi üzerinde yineleme yaparak, şimdiye kadar bulunan en büyük sayıyı takip edebilirsiniz. Alternatif olarak, dizi öğelerini argüman olarak geçirmek için Math.max() fonksiyonunu yayılma sözdizimi (...) ile birlikte kullanabilirsiniz.

function findMaxNumber(arr) {
  if (arr.length === 0) return undefined; // Veya hata fırlat
  return Math.max(...arr);
}

console.log(findMaxNumber([1, 5, 2, 9, 3])); // 9

1'den n'ye kadar sayıları yazdıran bir program yazın. Ancak üç katı olanlar için sayının yerine 'Fizz' yazdırın ve beş katı olanlar için 'Buzz' yazdırın. Hem üç hem de beşin katı olan sayılar için 'FizzBuzz' yazdırın.

Açıklama: Bu klasik problem, temel döngü ve koşullu mantığı test eder. 1'den n'ye kadar yinelemeniz ve 3 ve 5'e bölünebilirliği kontrol etmek için modül operatörünü (%) kullanmanız gerekir.

function fizzBuzz(n) {
  for (let i = 1; i <= n; i++) {
    if (i % 3 === 0 && i % 5 === 0) {
      console.log('FizzBuzz');
    } else if (i % 3 === 0) {
      console.log('Fizz');
    } else if (i % 5 === 0) {
      console.log('Buzz');
    } else {
      console.log(i);
    }
  }
}

fizzBuzz(15);

Bir diziden tekrarlanan öğeleri kaldıran bir fonksiyon yazın.

Açıklama: Bunu başarmak için modern ve kısa bir yol, bir Set kullanmaktır. Set'ler yalnızca benzersiz değerler saklar. Diziyi bir Set'e ve ardından tekrar bir diziye dönüştürebilirsiniz.

function removeDuplicates(arr) {
  return [...new Set(arr)];
}

console.log(removeDuplicates([1, 2, 2, 3, 4, 4, 5])); // [1, 2, 3, 4, 5]

İki dizenin birbirinin anagramı olup olmadığını kontrol eden bir fonksiyon yazın.

Açıklama: Anagramlar, başka bir kelimenin harflerinin yeniden düzenlenmesiyle oluşan kelimelerdir. Kontrol etmek için dizeleri temizleyebilir, sıralayabilir ve karşılaştırabiliriz. Temizleme, alfanümerik olmayan karakterleri kaldırmayı ve tutarlı bir büyük/küçük harfe dönüştürmeyi içerir.

function isAnagram(str1, str2) {
  const clean = (str) => str.replace(/[^a-z0-9]/gi, '').toLowerCase();
  const sorted = (str) => clean(str).split('').sort().join('');
  
  return sorted(str1) === sorted(str2);
}

console.log(isAnagram('listen', 'silent')); // true
console.log(isAnagram('hello', 'world')); // false

Negatif olmayan bir tam sayının faktöriyelini hesaplayan bir fonksiyon yazın.

Açıklama: Bir sayının faktöriyeli (n!), n'den küçük veya n'ye eşit tüm pozitif tam sayıların çarpımıdır. Bunu, 1'den n'ye kadar sayıları çarparak yinelemeli olarak hesaplayabiliriz.

function factorial(n) {
  if (n < 0) return undefined; // Faktöriyel negatif sayılar için tanımlı değildir
  if (n === 0) return 1;
  let result = 1;
  for (let i = 1; i <= n; i++) {
    result *= i;
  }
  return result;
}

console.log(factorial(5)); // 120

Bir dizideki tüm sayıların toplamını döndüren bir fonksiyon yazın.

Açıklama: Bir diziden tek bir değer biriktirmek için ideal olan reduce metodunu kullanabilirsiniz. Bir geri çağırma fonksiyonu ve bir başlangıç değeri (toplama için 0) alır.

function sumArray(arr) {
  return arr.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
}

console.log(sumArray([1, 2, 3, 4])); // 10

İç içe bir diziyi düzleştiren bir fonksiyon yazın. Basitlik için, yalnızca bir seviye iç içe olduğunu varsayın.

Açıklama: Tek bir iç içe seviye için, yayılma operatörüyle Array.prototype.concat() veya flat() metodunu (ES2019) kullanabilirsiniz.

function flattenArray(arr) {
  // flat() kullanarak (ES2019+ uygunsa daha basit)
  // return arr.flat();

  // reduce ve concat kullanarak
  return arr.reduce((acc, val) => acc.concat(val), []);
}

console.log(flattenArray([1, [2, 3], 4, [5]])); // [1, 2, 3, 4, 5]

Verilen bir dizedeki sesli harflerin (a, e, i, o, u) sayısını bulan bir fonksiyon yazın.

Açıklama: Dize üzerinde (büyük/küçük harf duyarsız) yineleyin ve her karakterin bir sesli harf olup olmadığını kontrol edin. Bir sayacı tutun.

function countVowels(str) {
  const vowels = 'aeiou';
  let count = 0;
  for (let char of str.toLowerCase()) {
    if (vowels.includes(char)) {
      count++;
    }
  }
  return count;
}

console.log(countVowels('Hello World')); // 3

Bir cümleyi başlık büyük harfe (her kelimenin ilk harfi büyük) dönüştüren bir fonksiyon yazın.

Açıklama: Cümleyi kelimelere ayırın, ardından her kelime üzerinde yineleyin, ilk harfi büyük yapın ve geri kalanını küçük yapın. Son olarak, kelimeleri tekrar birleştirin.

function titleCase(str) {
  return str.toLowerCase().split(' ').map(word => {
    return word.charAt(0).toUpperCase() + word.slice(1);
  }).join(' ');
}

console.log(titleCase('i am a little tea pot')); // 'I Am A Little Tea Pot'

Bir tamsayılar dizisi nums ve bir tamsayı target verildiğinde, toplamları target olan iki sayının dizinlerini döndürün.

Açıklama: Yaygın bir yaklaşım, yineleme yaparken sayıları ve dizinlerini depolamak için bir hash haritası (veya bir JavaScript nesnesi) kullanmaktır. Her sayı için, target - mevcut_sayı'nın haritada olup olmadığını kontrol edin.

function twoSum(nums, target) {
  const map = {};
  for (let i = 0; i < nums.length; i++) {
    const complement = target - nums[i];
    if (map[complement] !== undefined) {
      return [map[complement], i];
    }
    map[nums[i]] = i;
  }
  return []; // Veya null, veya çözüm yoksa hata fırlat
}

console.log(twoSum([2, 7, 11, 15], 9)); // [0, 1]

Bir sayaç fonksiyonu döndüren bir fonksiyon oluşturun. Döndürülen fonksiyon her çağrıldığında, bir sayıyı artırmalı ve döndürmelidir.

Açıklama: Bu, kapanışları gösterir. İç fonksiyon, dış fonksiyonun yürütmesi bittikten sonra bile dış fonksiyonun kapsamındaki count değişkenine erişebilir.

function createCounter() {
  let count = 0;
  return function() {
    count++;
    return count;
  };
}

const counter1 = createCounter();
console.log(counter1()); // 1
console.log(counter1()); // 2
const counter2 = createCounter();
console.log(counter2()); // 1

Bir dizideki ilk tekrarlamayan karakteri bulan bir fonksiyon yazın.

Açıklama: Karakter frekanslarını saymak için bir hash haritası kullanabilirsiniz. İlk olarak, frekans haritasını oluşturmak için dize üzerinde yineleyin. Ardından, dize üzerinde tekrar yineleyin ve sayısı 1 olan ilk karakteri döndürün.

function firstNonRepeatingChar(str) {
  const charCount = {};
  for (const char of str) {
    charCount[char] = (charCount[char] || 0) + 1;
  }
  for (const char of str) {
    if (charCount[char] === 1) {
      return char;
    }
  }
  return null; // Veya hepsi tekrar ediyorsa bir gösterge
}

console.log(firstNonRepeatingChar('aabbcdeeff')); // 'c'
console.log(firstNonRepeatingChar('swiss')); // 'w'

Bir diziyi belirtilen boyutta gruplara ayıran bir fonksiyon yazın.

Açıklama: Diziyi yineleyin, belirtilen boyutta dilimler alın ve bunları yeni bir diziye itin. Son parçanın daha küçük olabileceği durumu ele alın.

function chunkArray(arr, size) {
  const chunked = [];
  let index = 0;
  while (index < arr.length) {
    chunked.push(arr.slice(index, index + size));
    index += size;
  }
  return chunked;
}

console.log(chunkArray([1, 2, 3, 4, 5, 6, 7], 3)); // [[1, 2, 3], [4, 5, 6], [7]]

Verilen bir sayının asal sayı olup olmadığını belirleyen bir fonksiyon yazın.

Açıklama: Asal sayı, 1'den büyük, kendisinden ve 1'den başka pozitif böleni olmayan doğal bir sayıdır. 2'den sayının kareköküne kadar yineleyin, bölünebilirliği kontrol edin. 1 ve 2 gibi uç durumları ele alın.

function isPrime(num) {
  if (num <= 1) return false;
  if (num <= 3) return true;

  if (num % 2 === 0 || num % 3 === 0) return false;

  for (let i = 5; i * i <= num; i = i + 6) {
    if (num % i === 0 || num % (i + 2) === 0) return false;
  }

  return true;
}

console.log(isPrime(7)); // true
console.log(isPrime(10)); // false

Bir cümledeki en uzun kelimeyi bulan bir fonksiyon yazın.

Açıklama: Dizeyi kelime dizisine ayırın. Ardından, dizide yineleyin, şimdiye kadar bulunan en uzun kelimeyi (veya uzunluğunu) takip edin.

function findLongestWord(str) {
  const words = str.split(' ');
  let longestWord = '';
  for (const word of words) {
    // Gerekirse kelimeleri temizle (örn. noktalama işaretlerini kaldır)
    if (word.length > longestWord.length) {
      longestWord = word;
    }
  }
  return longestWord;
}

console.log(findLongestWord('The quick brown fox jumped over the lazy dog')); // 'jumped'

Array.prototype.map fonksiyonunun kendi sürümünüzü uygulayın.

Açıklama: map fonksiyonu bir geri çağırma alır ve orijinal dizinin her öğesine geri çağırmayı uygulayarak yeni bir dizi oluşturur. Fonksiyonunuz dizide yinelemeli ve yeni diziyi oluşturmalıdır.

function myMap(arr, callback) {
  const mappedArray = [];
  for (let i = 0; i < arr.length; i++) {
    mappedArray.push(callback(arr[i], i, arr));
  }
  return mappedArray;
}

const numbers = [1, 4, 9];
const roots = myMap(numbers, Math.sqrt);
console.log(roots); // [1, 2, 3]

Array.prototype.filter fonksiyonunun kendi sürümünüzü uygulayın.

Açıklama: filter fonksiyonu bir geri çağırma alır ve sağlanan geri çağırma fonksiyonu tarafından uygulanan testi geçen tüm öğelerle yeni bir dizi oluşturur.

function myFilter(arr, callback) {
  const filteredArray = [];
  for (let i = 0; i < arr.length; i++) {
    if (callback(arr[i], i, arr)) {
        filteredArray.push(arr[i]);
    }
  }
  return filteredArray;
}

const words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];
const result = myFilter(words, word => word.length > 6);
console.log(result); // ['exuberant', 'destruction', 'present']

Array.prototype.reduce fonksiyonunun kendi sürümünüzü uygulayın.

Açıklama: reduce fonksiyonu, dizinin her öğesi üzerinde kullanıcı tarafından sağlanan bir 'reducer' geri çağırma fonksiyonunu yürütür ve önceki öğe üzerindeki hesaplamadan dönen değeri iletir. Reducer'ın dizinin tüm öğelerinde çalıştırılmasının nihai sonucu tek bir değerdir. Başlangıç değeri argümanını ele alın.

function myReduce(arr, callback, initialValue) {
  let accumulator = initialValue;
  let startIndex = 0;

  if (initialValue === undefined) {
      if (arr.length === 0) throw new TypeError('Boş dizide başlangıç değeri olmadan reduce');
      accumulator = arr[0];
      startIndex = 1;
  }

  for (let i = startIndex; i < arr.length; i++) {
    accumulator = callback(accumulator, arr[i], i, arr);
  }
  return accumulator;
}

const array1 = [1, 2, 3, 4];
const sum = myReduce(array1, (acc, curr) => acc + curr, 0);
console.log(sum); // 10

Performansı optimize etmek için memorizasyon kullanarak bir Fibonacci fonksiyonu uygulayın.

Açıklama: Fibonacci dizisi tekrarlanan hesaplamalar içerir. Memorizasyon, pahalı fonksiyon çağrılarının sonuçlarını saklar ve aynı girdiler tekrar oluştuğunda önbelleğe alınmış sonucu döndürür.

function memoizedFib() {
  const cache = {};

  function fib(n) {
    if (n in cache) {
      return cache[n];
    }
    if (n <= 1) {
      return n;
    }
    const result = fib(n - 1) + fib(n - 2);
    cache[n] = result;
    return result;
  }
  return fib;
}

const fibonacci = memoizedFib();
console.log(fibonacci(10)); // 55
console.log(fibonacci(40)); // 102334155 (memorizasyon yapılmayandan çok daha hızlı)

Parantez içeren bir dizenin {}[]() dengeli olup olmadığını kontrol eden bir fonksiyon yazın.

Açıklama: Bir yığın kullanın. Açılış paranteziyle karşılaştığınızda, onu yığına itin. Kapanış paranteziyle karşılaştığınızda, yığının boş olup olmadığını veya en üstteki öğenin eşleşen açılış parantezi olup olmadığını kontrol edin. Eşleşiyorsa, yığını çıkarın. Aksi takdirde veya yığın boşsa, dengesizdir. Sonunda, boş bir yığın dengeli olduğu anlamına gelir.

function isBalanced(str) {
  const stack = [];
  const map = { '(': ')', '{': '}', '[': ']' };

  for (let char of str) {
    if (map[char]) {
      stack.push(char);
    } else if (Object.values(map).includes(char)) {
      if (stack.length === 0) return false;
      const lastOpen = stack.pop();
      if (map[lastOpen] !== char) return false;
    }
  }
  return stack.length === 0;
}

console.log(isBalanced('({[]})')); // true
console.log(isBalanced('([)]')); // false

enqueue (arkaya ekle) ve dequeue (önden kaldır) metodlarıyla bir Kuyruk veri yapısı uygulayın.

Açıklama: Bir kuyruk, İlk Giren İlk Çıkar (FIFO) prensibini takip eder. enqueue için push ve dequeue için shift ile bir dizi kullanılabilir.

class Queue {
  constructor() {
    this.items = [];
  }

  enqueue(element) {
    this.items.push(element);
  }

  dequeue() {
    if (this.isEmpty()) return 'Yetersiz akış';
    return this.items.shift();
  }

  front() {
    if (this.isEmpty()) return 'Kuyrukta eleman yok';
    return this.items[0];
  }

  isEmpty() {
    return this.items.length === 0;
  }
}

const q = new Queue();
q.enqueue(10);
q.enqueue(20);
console.log(q.dequeue()); // 10
console.log(q.front()); // 20

push (üste ekle) ve pop (üstten kaldır) metodlarıyla bir Yığın veri yapısı uygulayın.

Açıklama: Bir yığın, Son Giren İlk Çıkar (LIFO) prensibini takip eder. push ve pop metodlarıyla bir dizi kullanılabilir.

class Stack {
  constructor() {
    this.items = [];
  }

  push(element) {
    this.items.push(element);
  }

  pop() {
    if (this.isEmpty()) return 'Yetersiz akış';
    return this.items.pop();
  }

  peek() {
    return this.items[this.items.length - 1];
  }

  isEmpty() {
    return this.items.length === 0;
  }
}

const s = new Stack();
s.push(10);
s.push(20);
console.log(s.pop()); // 20
console.log(s.peek()); // 10

0, 1, 2, ..., n sayılarından alınan n farklı sayıyı içeren bir dizi verildiğinde, dizide eksik olanı bulun.

Açıklama: 0'dan n'ye kadar olan sayıların toplamı n*(n+1)/2 formülü kullanılarak hesaplanabilir. Dizideki öğelerin gerçek toplamı hesaplanabilir. Bu iki toplam arasındaki fark, eksik sayı olacaktır.

function findMissingNumber(nums) {
  const n = nums.length;
  const expectedSum = n * (n + 1) / 2;
  const actualSum = nums.reduce((sum, num) => sum + num, 0);
  return expectedSum - actualSum;
}

console.log(findMissingNumber([3, 0, 1])); // 2
console.log(findMissingNumber([9, 6, 4, 2, 3, 5, 7, 0, 1])); // 8

Bir debounce fonksiyonu uygulayın. Debouncing, bir fonksiyonun belirli bir süre çağrılmadıkça tekrar çağrılmamasını sağlar.

Açıklama: setTimeout ve clearTimeout kullanın. Debounce edilen fonksiyon her çağrıldığında, önceki zaman aşımını temizleyin ve yeni bir tane ayarlayın. Asıl fonksiyon çağrısı yalnızca zaman aşımı tamamlandığında gerçekleşir.

function debounce(func, delay) {
  let timeoutId;
  return function(...args) {
    clearTimeout(timeoutId);
    timeoutId = setTimeout(() => {
      func.apply(this, args);
    }, delay);
  };
}

// Örnek kullanım:
const sayHello = () => console.log('Merhaba!');
const debouncedHello = debounce(sayHello, 1000);
debouncedHello(); // 1 saniye sonra çağrılır (tekrar çağrılmazsa)
debouncedHello(); // Zamanlayıcıyı sıfırlar
debouncedHello(); // Zamanlayıcıyı sıfırlar, bu çağrıdan 1 saniye sonra çalışır.

Bir throttle fonksiyonu uygulayın. Throttling, bir fonksiyonun belirtilen bir zaman aralığında en fazla bir kez çağrılmasını sağlar.

Açıklama: Bir çağrının izinli olup olmadığını belirtmek için bir bayrak kullanın. Çağrıldığında, izinliyse fonksiyonu yürütün, bayrağı false olarak ayarlayın ve aralıktan sonra bayrağı sıfırlamak için setTimeout kullanın.

function throttle(func, limit) {
  let inThrottle = false;
  return function(...args) {
    if (!inThrottle) {
      func.apply(this, args);
      inThrottle = true;
      setTimeout(() => inThrottle = false, limit);
    }
  };
}

// Örnek kullanım:
const logScroll = () => console.log('Kaydırılıyor...');
const throttledScroll = throttle(logScroll, 1000);
// window.addEventListener('scroll', throttledScroll); // Saniyede en fazla bir kez loglayacaktır.

İki argüman alan bir fonksiyonu alan ve onun curried bir versiyonunu döndüren bir fonksiyon yazın.

Açıklama: Currying, birden çok argüman alan bir fonksiyonu, her biri tek bir argüman alan bir fonksiyonlar dizisine dönüştürür. f(a, b) f(a)(b) olur.

function curry(fn) {
  return function(a) {
    return function(b) {
      return fn(a, b);
    };
  };
}

function add(a, b) {
  return a + b;
}

const curriedAdd = curry(add);
const add5 = curriedAdd(5);
console.log(add5(3)); // 8
console.log(curriedAdd(10)(20)); // 30

Bir JavaScript nesnesinin derin kopyasını gerçekleştiren bir fonksiyon yazın.

Açıklama: Sığ kopya yalnızca üst düzey özellikleri kopyalar. Derin kopya, iç içe nesneler ve diziler de dahil olmak üzere tüm özellikleri özyinelemeli olarak kopyalar. Basit bir yol (sınırlamalarla, örneğin fonksiyonları, tarihleri, düzenli ifadeleri iyi işlemez) JSON.parse(JSON.stringify(obj)) kullanmaktır. Özyinelemeli bir yaklaşım daha sağlamdır.

function deepClone(obj) {
  // Basit sürüm (sınırlamalarla)
  try {
      return JSON.parse(JSON.stringify(obj));
  } catch (e) {
      console.error("Kopyalama başarısız:", e);
      return null;
  }
  
  // Daha sağlam özyinelemeli (temel örnek):
  /*
  if (obj === null || typeof obj !== 'object') {
      return obj;
  }
  let clone = Array.isArray(obj) ? [] : {};
  for (let key in obj) {
      if (Object.prototype.hasOwnProperty.call(obj, key)) {
          clone[key] = deepClone(obj[key]);
      }
  }
  return clone;
  */
}

const original = { a: 1, b: { c: 2 } };
const cloned = deepClone(original);
cloned.b.c = 3;
console.log(original.b.c); // 2 (derin kopya olduğunu kanıtlar)
console.log(cloned.b.c); // 3

Bir nesneden anahtarların bir dizisini nasıl alırsınız?

Açıklama: Object.keys(obj) kullanın.

function getKeys(obj) {
  return Object.keys(obj);
}
console.log(getKeys({a: 1, b: 2})); // ['a', 'b']

Bir nesneden değerlerin bir dizisini nasıl alırsınız?

Açıklama: Object.values(obj) kullanın.

function getValues(obj) {
  return Object.values(obj);
}
console.log(getValues({a: 1, b: 2})); // [1, 2]

Bir dizinin belirli bir değeri içerip içermediğini nasıl kontrol edersiniz?

Açıklama: Array.prototype.includes(value) kullanın.

function checkIncludes(arr, val) {
  return arr.includes(val);
}
console.log(checkIncludes([1, 2, 3], 2)); // true

İki diziyi tek bir dizide nasıl birleştirirsiniz?

Açıklama: Yayılma sözdizimi (...) veya Array.prototype.concat() kullanın.

function mergeArrays(arr1, arr2) {
  return [...arr1, ...arr2];
}
console.log(mergeArrays([1, 2], [3, 4])); // [1, 2, 3, 4]

Bir tarayıcıda global kapsamda this neyi ifade eder?

Açıklama: Global yürütme bağlamında (herhangi bir fonksiyonun dışında), this global nesneyi ifade eder, bu da web tarayıcılarında window'dur.

console.log(this === window); // true (tarayıcı ortamında)

Bir nesne metodunun içinde kullanıldığında this neyi ifade eder?

Açıklama: Bir fonksiyon bir nesnenin metodu olarak çağrıldığında, this metodun çağrıldığı nesneyi ifade eder.

const myObject = {
  prop: 'Merhaba',
  greet() {
    return this.prop;
  }
};
console.log(myObject.greet()); // 'Merhaba'

Ok fonksiyonları this'i nasıl ele alır?

Açıklama: Ok fonksiyonlarının kendi this bağlamı yoktur. Bunun yerine, tanımlandıkları çevreleyen (sözcüksel) kapsamdan this'i miras alırlar.

function MyClass() {
  this.value = 42;
  setTimeout(() => {
    console.log(this.value); // 42'yi loglar çünkü 'this' miras alınır
  }, 100);
}
new MyClass();

let, const ve var arasındaki temel farklar nelerdir?

Açıklama: var fonksiyon kapsamlıdır ve hoisted'dır. let ve const blok kapsamlıdır ve hoisted'dır ancak bildirilene kadar 'geçici ölü bölgede'dirler. const başlatılmalı ve yeniden atanamaz.

function scopeTest() {
  var a = 1;
  let b = 2;
  const c = 3;
  if (true) {
    var a = 10; // Dıştaki 'a'yı yeniden bildirir ve etkiler
    let b = 20; // Blok içinde yeni 'b'
    // const c = 30; // Yeni bir 'c' olurdu
    console.log(a, b, c); // 10, 20, 3
  }
  console.log(a, b, c); // 10, 2, 3
}
scopeTest();

JavaScript'te Promise'in ne olduğunu açıklayın.

Açıklama: Promise, asenkron bir işlemin nihai tamamlanmasını (veya başarısızlığını) ve ortaya çıkan değerini temsil eden bir nesnedir. Üç durumdan birinde olabilir: beklemede, yerine getirilmiş veya reddedilmiş.

const myPromise = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve('Başarılı!');
    // reject('Hata!');
  }, 1000);
});

myPromise
  .then(result => console.log(result))
  .catch(error => console.error(error));

async ve await Promise'lerle çalışmayı nasıl basitleştirir?

Açıklama: async/await, Promise'ler üzerinde sentaktik şeker sağlar, asenkron kodu senkron koda biraz daha benzetir ve öyle davranmasını sağlar. Bir async fonksiyon her zaman bir Promise döndürür ve await bir Promise çözülene kadar yürütmeyi duraklatır.

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function run() {
  console.log('Başlıyor...');
  await delay(1000);
  console.log('1 saniye bekledi.');
  await delay(500);
  console.log('Bir 0.5 saniye daha bekledi.');
  return 'Bitti!';
}

run().then(console.log);

Bir dizeyi sayıya nasıl dönüştürürsünüz?

Açıklama: parseInt(), parseFloat() veya birli artı operatörünü (+) kullanın.

const str = '123.45';
console.log(parseInt(str)); // 123
console.log(parseFloat(str)); // 123.45
console.log(+str); // 123.45

Bir sayıyı dizeye nasıl dönüştürürsünüz?

Açıklama: String(), number.toString() veya dize birleştirmeyi kullanın.

const num = 123;
console.log(String(num)); // '123'
console.log(num.toString()); // '123'
console.log('' + num); // '123'

JSON.stringify ne yapar?

Açıklama: Bir JavaScript nesnesini veya değerini bir JSON dizesine dönüştürür.

const obj = { name: 'Alice', age: 30 };
const jsonString = JSON.stringify(obj);
console.log(jsonString); // '{"name":"Alice","age":30}'

JSON.parse ne yapar?

Açıklama: Bir JSON dizesini ayrıştırır, dize tarafından açıklanan JavaScript değerini veya nesnesini oluşturur.

const jsonString = '{"name":"Alice","age":30}';
const obj = JSON.parse(jsonString);
console.log(obj.name); // 'Alice'

Yayılma operatörü dizilerle nasıl kullanılır?

Açıklama: Bir yinelenebilirin (dizi gibi) sıfır veya daha fazla argümanın veya öğenin beklendiği yerlerde genişletilmesini sağlar. Kopyalama, birleştirme ve öğe ekleme için kullanışlıdır.

const arr1 = [1, 2];
const arr2 = [3, 4];
const combined = [...arr1, ...arr2]; // [1, 2, 3, 4]
const copy = [...arr1]; // [1, 2]

Yayılma operatörü nesnelerle nasıl kullanılır?

Açıklama: Nesne özelliklerinin kopyalanmasını ve birleştirilmesini sağlar.

const obj1 = { a: 1, b: 2 };
const obj2 = { b: 3, c: 4 };
const merged = { ...obj1, ...obj2 }; // { a: 1, b: 3, c: 4 }
const copy = { ...obj1 }; // { a: 1, b: 2 }

Bir örnekle dizi yapı bozmayı açıklayın.

Açıklama: Dizilerden değerleri ayrı değişkenlere açmayı mümkün kılan bir sözdizimidir.

const [a, b] = [10, 20];
console.log(a); // 10
console.log(b); // 20

const [x, , z] = [1, 2, 3];
console.log(z); // 3

Bir örnekle nesne yapı bozmayı açıklayın.

Açıklama: Nesnelerden özellikleri ayrı değişkenlere açmayı mümkün kılar.

const person = { name: 'Bob', age: 25 };
const { name, age } = person;
console.log(name); // 'Bob'
console.log(age); // 25

const { name: personName } = person;
console.log(personName); // 'Bob'

Function.prototype.call'ın temel bir sürümünü nasıl uygulayabilirsiniz?

Açıklama: call, belirtilen bir this değeri ve ayrı ayrı sağlanan argümanlarla bir fonksiyonu çağırır. Fonksiyonu this bağlamına ekleyebilir, çağırabilir ve sonra kaldırabilirsiniz.

Function.prototype.myCall = function(context, ...args) {
  context = context || window;
  const uniqueId = Symbol(); // Benzersiz bir anahtar kullanın
  context[uniqueId] = this;
  const result = context[uniqueId](...args);
  delete context[uniqueId];
  return result;
}

function greet(greeting, punctuation) {
  console.log(`${greeting}, ${this.name}${punctuation}`);
}

greet.myCall({ name: 'Charlie' }, 'Selam', '!'); // Selam, Charlie!

Function.prototype.apply'ın temel bir sürümünü nasıl uygulayabilirsiniz?

Açıklama: apply, call'a benzer, ancak argümanları bir dizi olarak kabul eder.

Function.prototype.myApply = function(context, argsArray) {
  context = context || window;
  const uniqueId = Symbol();
  context[uniqueId] = this;
  const result = context[uniqueId](...(argsArray || []));
  delete context[uniqueId];
  return result;
}

function greet(greeting, punctuation) {
  console.log(`${greeting}, ${this.name}${punctuation}`);
}

greet.myApply({ name: 'David' }, ['Merhaba', '.']); // Merhaba, David.

JavaScript Olay Döngüsünü kısaca açıklayın.

Açıklama: JavaScript tek iş parçacıklı bir dildir ancak olay döngüsü kullanarak eşzamanlılık sağlar. Çağrı yığını senkron kodu işler. Web API'leri (setTimeout, fetch gibi) asenkron işlemleri yönetir. Asenkron bir işlem bittiğinde, geri çağırımı geri çağırım kuyruğuna (veya Promise'ler için mikro görev kuyruğuna) gider. Olay döngüsü, çağrı yığınının boş olup olmadığını sürekli kontrol eder; eğer boşsa, bir sonraki geri çağırımı yürütmek üzere kuyruktan yığına taşır.

console.log('Start');

setTimeout(() => {
  console.log('Timeout Callback'); // Geri Çağırım Kuyruğuna gider
}, 0);

Promise.resolve().then(() => {
  console.log('Promise Resolved'); // Mikro Görev Kuyruğuna gider
});

console.log('End');

// Çıktı Sırası: Start, End, Promise Resolved, Timeout Callback
// (Mikro görevler Makro görevlerden/Geri Çağırımlardan önce çalışır)

Sıralı bir dizi için ikili arama fonksiyonunu uygulayın.

Açıklama: İkili arama, arama aralığını sürekli ikiye bölerek sıralı bir dizideki bir öğeyi verimli bir şekilde bulur. Eğer arama anahtarının değeri aralığın ortasındaki öğeden küçükse, aralığı alt yarıya daraltın. Aksi takdirde, üst yarıya daraltın. Bu işlemi değer bulunana veya aralık boşalana kadar yaparsınız.

function binarySearch(sortedArray, key) {
  let start = 0;
  let end = sortedArray.length - 1;

  while (start <= end) {
    let middle = Math.floor((start + end) / 2);

    if (sortedArray[middle] === key) {
      return middle; // Bulundu
    } else if (sortedArray[middle] < key) {
      start = middle + 1; // Sağ yarıyı ara
    } else {
      end = middle - 1; // Sol yarıyı ara
    }
  }
  return -1; // Bulunamadı
}

console.log(binarySearch([1, 3, 5, 7, 9, 11], 7)); // 3
console.log(binarySearch([1, 3, 5, 7, 9, 11], 2)); // -1

Birleştirme Sıralaması algoritmasını uygulayın.

Açıklama: Birleştirme Sıralaması, böl ve yönet algoritmasıdır. Giriş dizisini iki yarıya böler, iki yarı için kendini çağırır ve ardından iki sıralanmış yarıyı birleştirir. Birleştirme fonksiyonu çok önemlidir; iki sıralanmış alt diziyi tek bir sıralanmış diziye birleştirir.

function mergeSort(arr) {
  if (arr.length <= 1) return arr;

  const mid = Math.floor(arr.length / 2);
  const left = mergeSort(arr.slice(0, mid));
  const right = mergeSort(arr.slice(mid));

  return merge(left, right);
}

function merge(left, right) {
  let result = [];
  let leftIndex = 0;
  let rightIndex = 0;

  while (leftIndex < left.length && rightIndex < right.length) {
    if (left[leftIndex] < right[rightIndex]) {
      result.push(left[leftIndex]);
      leftIndex++;
    } else {
      result.push(right[rightIndex]);
      rightIndex++;
    }
  }

  return result.concat(left.slice(leftIndex)).concat(right.slice(rightIndex));
}

console.log(mergeSort([38, 27, 43, 3, 9, 82, 10])); // [3, 9, 10, 27, 38, 43, 82]

Hızlı Sıralama algoritmasını uygulayın.

Açıklama: Hızlı Sıralama da bir böl ve yönet algoritmasıdır. Bir öğeyi pivot olarak seçer ve verilen diziyi seçilen pivot etrafında böler. Pivottan küçük öğeler sola, daha büyük öğeler sağa gider. Daha sonra alt dizileri özyinelemeli olarak sıralar.

function quickSort(arr) {
  if (arr.length <= 1) return arr;

  const pivot = arr[arr.length - 1];
  const left = [];
  const right = [];

  for (let i = 0; i < arr.length - 1; i++) {
    if (arr[i] < pivot) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }

  return [...quickSort(left), pivot, ...quickSort(right)];
}

console.log(quickSort([10, 8, 2, 1, 6, 3, 9, 4, 7, 5])); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Kabarcık Sıralaması algoritmasını uygulayın.

Açıklama: Kabarcık Sıralaması, liste boyunca art arda adım atan, bitişik öğeleri karşılaştıran ve yanlış sıradaysa yerlerini değiştiren basit bir sıralama algoritmasıdır. Liste sıralanana kadar liste boyunca geçiş tekrarlanır.

function bubbleSort(arr) {
  let n = arr.length;
  let swapped;
  do {
    swapped = false;
    for (let i = 0; i < n - 1; i++) {
      if (arr[i] > arr[i + 1]) {
        [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]]; // Yer değiştirme
        swapped = true;
      }
    }
    n--; // Optimizasyon: son öğe zaten yerindedir
  } while (swapped);
  return arr;
}

console.log(bubbleSort([64, 34, 25, 12, 22, 11, 90])); // [11, 12, 22, 25, 34, 64, 90]

Verilen bir dizgedeki tekrarlayan karakterler olmadan en uzun alt dizinin uzunluğunu bulun.

Açıklama: Kayar pencere tekniğini kullanın. Bir pencere (alt dizi) ve o penceredeki karakterlerden oluşan bir küme tutun. Sağ işaretçiyi hareket ettirerek pencereyi genişletin. Tekrarlayan bir karakter bulunursa, tekrarlayan karakter kaldırılana kadar pencereyi soldan küçültün.

function lengthOfLongestSubstring(s) {
  let maxLength = 0;
  let start = 0;
  const charMap = {};

  for (let end = 0; end < s.length; end++) {
    const char = s[end];
    if (charMap[char] >= start) {
        start = charMap[char] + 1;
    }
    charMap[char] = end;
    maxLength = Math.max(maxLength, end - start + 1);
  }
  return maxLength;
}

console.log(lengthOfLongestSubstring('abcabcbb')); // 3 ('abc')
console.log(lengthOfLongestSubstring('bbbbb')); // 1 ('b')
console.log(lengthOfLongestSubstring('pwwkew')); // 3 ('wke')

Add ve print metotlarına sahip tek yönlü bir bağlı liste uygulayın.

Açıklama: Bağlı liste, öğelerin bitişik bellek konumlarında depolanmadığı doğrusal bir veri yapısıdır. Her öğe (düğüm) bir sonrakini işaret eder. Baş düğümü ve yeni düğümleri yönetmek için bir Node sınıfına ve bir LinkedList sınıfına ihtiyacınız var.

class Node {
  constructor(data, next = null) {
    this.data = data;
    this.next = next;
  }
}

class LinkedList {
  constructor() {
    this.head = null;
  }

  add(data) {
    const newNode = new Node(data);
    if (!this.head) {
      this.head = newNode;
    } else {
      let current = this.head;
      while (current.next) {
        current = current.next;
      }
      current.next = newNode;
    }
  }

  print() {
    let current = this.head;
    let list = '';
    while (current) {
      list += current.data + ' -> ';
      current = current.next;
    }
    console.log(list + 'null');
  }
}

const list = new LinkedList();
list.add(10);
list.add(20);
list.add(30);
list.print(); // 10 -> 20 -> 30 -> null

Ekle ve bul metotlarına sahip bir İkili Arama Ağacı uygulayın.

Açıklama: BST, aşağıdaki özelliklere sahip düğüm tabanlı bir ikili ağaç veri yapısıdır: Bir düğümün sol alt ağacı yalnızca düğümün anahtarından küçük anahtarlara sahip düğümleri içerir. Bir düğümün sağ alt ağacı yalnızca düğümün anahtarından büyük anahtarlara sahip düğümleri içerir. Her iki alt ağaç da ikili arama ağacı olmalıdır.

class Node {
  constructor(data) {
    this.data = data;
    this.left = null;
    this.right = null;
  }
}

class BST {
  constructor() {
    this.root = null;
  }

  insert(data) {
    const newNode = new Node(data);
    if (!this.root) {
      this.root = newNode;
      return;
    }
    this._insertNode(this.root, newNode);
  }

  _insertNode(node, newNode) {
    if (newNode.data < node.data) {
      if (!node.left) node.left = newNode;
      else this._insertNode(node.left, newNode);
    } else {
      if (!node.right) node.right = newNode;
      else this._insertNode(node.right, newNode);
    }
  }

  find(data) {
    return this._findNode(this.root, data);
  }

  _findNode(node, data) {
    if (!node) return null;
    if (data < node.data) return this._findNode(node.left, data);
    else if (data > node.data) return this._findNode(node.right, data);
    else return node;
  }
}

const bst = new BST();
bst.insert(10);
bst.insert(5);
bst.insert(15);
bst.insert(7);
console.log(bst.find(7)); // Node { data: 7, left: null, right: null }
console.log(bst.find(12)); // null

Bir diziyi k adım sağa döndüren bir fonksiyon yazın.

Açıklama: Bir diziyi döndürmek, öğelerini hareket ettirmek anlamına gelir. Sağ döndürme için son öğe ilk öğe olur. Bunu k kez tekrarlamak işe yarar ancak verimsizdir. Daha iyi bir yol, dizi manipülasyonu kullanmak veya yeni konumları hesaplamaktır.

function rotateArray(nums, k) {
  k = k % nums.length; // k > uzunluk olduğu durumları ele alın
  if (k === 0) return nums;

  const partToMove = nums.splice(nums.length - k);
  nums.unshift(...partToMove);
  return nums;
}

console.log(rotateArray([1, 2, 3, 4, 5, 6, 7], 3)); // [5, 6, 7, 1, 2, 3, 4]

İki dizi verildiğinde, kesişimlerini (her ikisinde de ortak olan öğeler) hesaplamak için bir fonksiyon yazın.

Açıklama: İyi bir yaklaşım, O(1) ortalama zamanlı aramalar için bir diziyi bir Set'e dönüştürmektir. Ardından, ikinci dizi boyunca yineleyin ve her öğenin kümede olup olmadığını kontrol edin. Eşleşmeleri toplayın.

function intersection(nums1, nums2) {
  const set1 = new Set(nums1);
  const resultSet = new Set();

  for (const num of nums2) {
    if (set1.has(num)) {
      resultSet.add(num);
    }
  }

  return [...resultSet];
}

console.log(intersection([1, 2, 2, 1], [2, 2])); // [2]
console.log(intersection([4, 9, 5], [9, 4, 9, 8, 4])); // [9, 4]

Bir dizge dizisi verildiğinde, anagramları bir araya getirin.

Açıklama: Anahtar, her anagram grubu için benzersiz bir imza bulmaktır. Yaygın bir yol, her kelimeyi alfabetik olarak sıralamaktır. Aynı sıralanmış dizgeyle sonuçlanan kelimeler anagramlardır. Anahtarların sıralanmış kelimeler ve değerlerin orijinal kelime dizileri olduğu bir hash haritası kullanın.

function groupAnagrams(strs) {
  const map = {};
  for (const str of strs) {
    const sortedStr = str.split('').sort().join('');
    if (!map[sortedStr]) {
      map[sortedStr] = [];
    }
    map[sortedStr].push(str);
  }
  return Object.values(map);
}

console.log(groupAnagrams(['eat', 'tea', 'tan', 'ate', 'nat', 'bat'])); 
// Çıktı: [['eat', 'tea', 'ate'], ['tan', 'nat'], ['bat']]

Bir nums dizisi verildiğinde, sıfır olmayan öğelerin göreceli sırasını korurken tüm 0'ları sona taşıyan bir fonksiyon yazın.

Açıklama: Bir iki işaretçi veya kartopu yaklaşımı kullanın. Bir işaretçi, bir sonraki sıfır olmayan öğenin gitmesi gereken konumu takip eder. Dizi boyunca yineleyin; bir öğe sıfır değilse, onu işaretçinin konumuna yerleştirin ve işaretçiyi artırın. Son olarak, geri kalanını sıfırlarla doldurun.

function moveZeroes(nums) {
  let nonZeroIndex = 0;

  // Tüm sıfır olmayan öğeleri öne taşıyın
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] !== 0) {
      nums[nonZeroIndex] = nums[i];
      nonZeroIndex++;
    }
  }

  // Geri kalanını sıfırlarla doldurun
  for (let i = nonZeroIndex; i < nums.length; i++) {
    nums[i] = 0;
  }

  return nums;
}

console.log(moveZeroes([0, 1, 0, 3, 12])); // [1, 3, 12, 0, 0]

Bir tamsayı dizisi nums verildiğinde, en büyük toplama sahip bitişik alt diziyi (en az bir sayı içeren) bulun ve toplamını döndürün.

Açıklama: Kadane algoritması, bunu çözmek için verimli bir yoldur. Dizi boyunca yineleyin, mevcut konumda sona eren currentMax toplamını ve şimdiye kadar bulunan globalMax toplamını takip edin. Eğer currentMax negatif olursa, onu 0'a (veya daha doğrusu, mevcut öğeye) sıfırlayın.

function maxSubArray(nums) {
  let globalMax = -Infinity;
  let currentMax = 0;

  for (let i = 0; i < nums.length; i++) {
    currentMax = Math.max(nums[i], currentMax + nums[i]);
    if (currentMax > globalMax) {
      globalMax = currentMax;
    }
  }
  return globalMax;
}

console.log(maxSubArray([-2, 1, -3, 4, -1, 2, 1, -5, 4])); // 6 ([4, -1, 2, 1]'den)