Live Coding

Jak sprawdzić, czy obiekt JavaScript jest pusty?

Wyjaśnienie: Obiekt jest pusty, jeśli nie ma żadnych własnych, wyliczalnych właściwości. Możemy użyć Object.keys(obj), która zwraca tablicę nazw własnych, wyliczalnych właściwości danego obiektu. Jeśli długość tej tablicy wynosi 0, obiekt jest pusty.

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

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

Napisz funkcję, która odwraca dany ciąg znaków.

Wyjaśnienie: Najprostszym sposobem jest przekształcenie ciągu znaków w tablicę znaków, użycie wbudowanej metody reverse() dla tablic, a następnie połączenie znaków z powrotem w ciąg znaków.

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

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

Napisz funkcję, która sprawdza, czy dany ciąg znaków jest palindromem.

Wyjaśnienie: Palindrom to słowo lub fraza, która czyta się tak samo do przodu i do tyłu. Możemy to sprawdzić, odwracając ciąg znaków (ignorując wielkość liter i znaki niealfanumeryczne dla bardziej solidnego sprawdzenia, ale tutaj wykonujemy proste sprawdzenie) i porównując go z oryginałem.

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

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

Napisz funkcję, która znajduje największą liczbę w tablicy liczb.

Wyjaśnienie: Możesz iterować po tablicy, śledząc największą znalezioną do tej pory liczbę. Alternatywnie, możesz użyć funkcji Math.max() wraz ze składnią spread (...), aby przekazać elementy tablicy jako argumenty.

function findMaxNumber(arr) {
  if (arr.length === 0) return undefined; // Lub rzuć błąd
  return Math.max(...arr);
}

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

Napisz program, który wypisuje liczby od 1 do n. Ale dla wielokrotności trzech wypisz 'Fizz' zamiast liczby, a dla wielokrotności pięciu wypisz 'Buzz'. Dla liczb będących wielokrotnością zarówno trzech, jak i pięciu, wypisz 'FizzBuzz'.

Wyjaśnienie: Ten klasyczny problem testuje podstawową logikę pętli i warunków. Musisz iterować od 1 do n i użyć operatora modulo (%) do sprawdzenia podzielności przez 3 i 5.

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);

Napisz funkcję, która usuwa z tablicy zduplikowane elementy.

Wyjaśnienie: Nowoczesny i zwięzły sposób na osiągnięcie tego to użycie Set. Zestawy przechowują tylko unikalne wartości. Możesz przekonwertować tablicę na Set, a następnie z powrotem na tablicę.

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

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

Napisz funkcję, która sprawdza, czy dwa ciągi znaków są anagramami.

Wyjaśnienie: Anagramy to słowa utworzone przez przestawienie liter innego słowa. Aby to sprawdzić, możemy wyczyścić, posortować i porównać ciągi znaków. Czyszczenie obejmuje usunięcie znaków niealfanumerycznych i konwersję na jednolitą wielkość liter.

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

Napisz funkcję do obliczania silni nieujemnej liczby całkowitej.

Wyjaśnienie: Silnia (n!) liczby to iloczyn wszystkich dodatnich liczb całkowitych mniejszych lub równych n. Możemy to obliczyć iteracyjnie, mnożąc liczby od 1 do n.

function factorial(n) {
  if (n < 0) return undefined; // Silnia nie jest zdefiniowana dla liczb ujemnych
  if (n === 0) return 1;
  let result = 1;
  for (let i = 1; i <= n; i++) {
    result *= i;
  }
  return result;
}

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

Napisz funkcję, która zwraca sumę wszystkich liczb w tablicy.

Wyjaśnienie: Możesz użyć metody reduce, która jest idealna do kumulowania pojedynczej wartości z tablicy. Przyjmuje ona funkcję zwrotną i wartość początkową (0 dla sumowania).

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

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

Napisz funkcję spłaszczającą zagnieżdżoną tablicę. Dla uproszczenia załóż tylko jeden poziom zagnieżdżenia.

Wyjaśnienie: Dla pojedynczego poziomu zagnieżdżenia możesz użyć Array.prototype.concat() z operatorem spread lub metody flat() (ES2019).

function flattenArray(arr) {
  // Użycie flat() (prostsze, jeśli ES2019+ jest w porządku)
  // return arr.flat();

  // Użycie reduce i concat
  return arr.reduce((acc, val) => acc.concat(val), []);
}

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

Napisz funkcję, która zlicza liczbę samogłosek (a, e, i, o, u) w danym ciągu znaków.

Wyjaśnienie: Iteruj po ciągu znaków (bez uwzględniania wielkości liter) i sprawdzaj, czy każdy znak jest samogłoską. Utrzymuj licznik.

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

Napisz funkcję, która konwertuje zdanie na tytułowe (pierwsza litera każdego słowa jest pisana wielką literą).

Wyjaśnienie: Podziel zdanie na słowa, a następnie iteruj po każdym słowie, pisząc pierwszą literę wielką literą, a resztę małymi literami. Na koniec połącz słowa z powrotem.

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'

Mając tablicę liczb całkowitych nums i liczbę całkowitą target, zwróć indeksy dwóch liczb, które sumują się do target.

Wyjaśnienie: Powszechnym podejściem jest użycie mapy haszującej (lub obiektu JavaScript) do przechowywania liczb i ich indeksów podczas iteracji. Dla każdej liczby sprawdź, czy target - bieżąca_liczba istnieje w mapie.

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 []; // Lub null, lub rzuć błąd, jeśli brak rozwiązania
}

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

Utwórz funkcję, która zwraca funkcję licznika. Za każdym razem, gdy wywołana zostanie zwrócona funkcja, powinna ona zwiększać i zwracać wartość licznika.

Wyjaśnienie: Demonstracja domknięć. Funkcja wewnętrzna ma dostęp do zmiennej count w zakresie funkcji zewnętrznej, nawet po zakończeniu wykonywania funkcji zewnętrznej.

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

Napisz funkcję, która znajduje pierwszy niepowtarzający się znak w ciągu znaków.

Wyjaśnienie: Możesz użyć mapy haszującej do zliczania częstotliwości znaków. Najpierw iteruj po ciągu znaków, aby zbudować mapę częstotliwości. Następnie ponownie iteruj po ciągu znaków i zwróć pierwszy znak z licznikiem 1.

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; // Lub jakiś wskaźnik, jeśli wszystkie się powtarzają
}

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

Napisz funkcję, która dzieli tablicę na grupy o określonym rozmiarze.

Wyjaśnienie: Iteruj po tablicy, pobierając wycinki o określonym rozmiarze i dodając je do nowej tablicy. Obsłuż przypadek, gdy ostatni fragment może być mniejszy.

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]]

Napisz funkcję, która określa, czy dana liczba jest liczbą pierwszą.

Wyjaśnienie: Liczba pierwsza to liczba naturalna większa od 1, która ma dokładnie dwa dzielniki naturalne: jedynkę i samą siebie. Iteruj od 2 do pierwiastka kwadratowego z liczby, sprawdzając podzielność. Obsłuż przypadki brzegowe, takie jak 1 i 2.

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

Napisz funkcję, która znajduje najdłuższe słowo w zdaniu.

Wyjaśnienie: Podziel ciąg znaków na tablicę słów. Następnie iteruj po tablicy, śledząc najdłuższe znalezione do tej pory słowo (lub jego długość).

function findLongestWord(str) {
  const words = str.split(' ');
  let longestWord = '';
  for (const word of words) {
    // Wyczyść słowa, jeśli to konieczne (np. usuń znaki interpunkcyjne)
    if (word.length > longestWord.length) {
      longestWord = word;
    }
  }
  return longestWord;
}

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

Zaimplementuj własną wersję funkcji Array.prototype.map.

Wyjaśnienie: Funkcja map przyjmuje callback i tworzy nową tablicę, stosując callback do każdego elementu oryginalnej tablicy. Twoja funkcja powinna iterować po tablicy i budować nową tablicę.

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]

Zaimplementuj własną wersję funkcji Array.prototype.filter.

Wyjaśnienie: Funkcja filter przyjmuje callback i tworzy nową tablicę ze wszystkimi elementami, które przejdą test zaimplementowany przez dostarczoną funkcję callback.

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']

Zaimplementuj własną wersję funkcji Array.prototype.reduce.

Wyjaśnienie: Funkcja reduce wykonuje dostarczoną przez użytkownika funkcję zwrotną 'reducer' na każdym elemencie tablicy, przekazując wartość zwracaną z obliczeń na poprzednim elemencie. Końcowym wynikiem uruchomienia reducera na wszystkich elementach tablicy jest pojedyncza wartość. Obsłuż argument wartości początkowej.

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

  if (initialValue === undefined) {
      if (arr.length === 0) throw new TypeError('Zmniejszenie pustej tablicy bez wartości początkowej');
      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

Zaimplementuj funkcję Fibonacciego używając memoizacji w celu optymalizacji wydajności.

Wyjaśnienie: Ciąg Fibonacciego wiąże się z powtarzającymi się obliczeniami. Memoizacja przechowuje wyniki kosztownych wywołań funkcji i zwraca buforowany wynik, gdy ponownie wystąpią te same dane wejściowe.

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 (znacznie szybciej niż bez memoizacji)

Napisz funkcję, która sprawdza, czy ciąg znaków zawierający nawiasy {}[]() jest zbalansowany.

Wyjaśnienie: Użyj stosu. Kiedy napotkasz otwierający nawias, wciśnij go na stos. Kiedy napotkasz zamykający nawias, sprawdź, czy stos jest pusty lub czy górny element jest pasującym nawiasem otwierającym. Jeśli pasuje, zdejmij ze stosu. Jeśli nie, lub jeśli stos jest pusty, jest niezbalansowany. Na końcu, pusty stos oznacza zbalansowany.

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

Zaimplementuj strukturę danych Kolejka z metodami enqueue (dodaj na koniec) i dequeue (usuń z początku).

Wyjaśnienie: Kolejka działa na zasadzie First-In, First-Out (FIFO). Można użyć tablicy, z push dla enqueue i shift dla dequeue.

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

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

  dequeue() {
    if (this.isEmpty()) return 'Niedopełnienie';
    return this.items.shift();
  }

  front() {
    if (this.isEmpty()) return 'Brak elementów w Kolejce';
    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

Zaimplementuj strukturę danych stosu z metodami push (dodaj na górę) i pop (usuń z góry).

Wyjaśnienie: Stos działa na zasadzie Last-In, First-Out (LIFO). Można użyć tablicy z metodami push i pop.

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

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

  pop() {
    if (this.isEmpty()) return 'Niedopełnienie';
    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

Mając tablicę zawierającą n różnych liczb pobranych z 0, 1, 2, ..., n, znajdź tę, której brakuje w tablicy.

Wyjaśnienie: Sumę liczb od 0 do n można obliczyć za pomocą wzoru n*(n+1)/2. Można obliczyć rzeczywistą sumę elementów tablicy. Różnica między tymi dwoma sumami będzie brakującą liczbą.

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

Zaimplementuj funkcję debounce. Debouncing zapewnia, że funkcja nie zostanie wywołana ponownie, dopóki nie upłynie określony czas, w którym nie była wywoływana.

Wyjaśnienie: Użyj setTimeout i clearTimeout. Za każdym razem, gdy wywoływana jest debounced funkcja, wyczyść poprzednie opóźnienie i ustaw nowe. Faktyczne wywołanie funkcji następuje dopiero po zakończeniu opóźnienia.

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

// Przykład użycia:
const sayHello = () => console.log('Witaj!');
const debouncedHello = debounce(sayHello, 1000);
debouncedHello(); // Wywołane po 1 sek (jeśli nie wywołane ponownie)
debouncedHello(); // Resetuje timer
debouncedHello(); // Resetuje timer, faktycznie uruchomi się 1 sek po tym wywołaniu.

Zaimplementuj funkcję throttle. Throttling zapewnia, że funkcja jest wywoływana co najwyżej raz w określonym przedziale czasowym.

Wyjaśnienie: Użyj flagi, aby wskazać, czy wywołanie jest dozwolone. Po wywołaniu, jeśli dozwolone, wykonaj funkcję, ustaw flagę na false i użyj setTimeout, aby zresetować flagę po upływie interwału.

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

// Przykład użycia:
const logScroll = () => console.log('Przewijanie...');
const throttledScroll = throttle(logScroll, 1000);
// window.addEventListener('scroll', throttledScroll); // Będzie logować co najwyżej raz na sekundę.

Napisz funkcję, która przyjmuje funkcję z dwoma argumentami i zwraca jej scurryfikowaną wersję.

Wyjaśnienie: Currying przekształca funkcję z wieloma argumentami w sekwencję funkcji, z których każda przyjmuje pojedynczy argument. f(a, b) staje się f(a)(b).

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

Napisz funkcję do wykonania głębokiego klonowania obiektu JavaScript.

Wyjaśnienie: Płytkie klonowanie kopiuje tylko właściwości najwyższego poziomu. Głębokie klonowanie rekurencyjnie kopiuje wszystkie właściwości, w tym zagnieżdżone obiekty i tablice. Prostym sposobem (z ograniczeniami, np. nie obsługuje dobrze funkcji, dat, wyrażeń regularnych) jest użycie JSON.parse(JSON.stringify(obj)). Rekurencyjne podejście jest bardziej niezawodne.

function deepClone(obj) {
  // Prosta wersja (z ograniczeniami)
  try {
      return JSON.parse(JSON.stringify(obj));
  } catch (e) {
      console.error("Klonowanie nie powiodło się:", e);
      return null;
  }
  
  // Bardziej niezawodne rekurencyjne (podstawowy przykład):
  /*
  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 (dowodzi, że jest to głębokie klonowanie)
console.log(cloned.b.c); // 3

Jak pobrać tablicę kluczy z obiektu?

Wyjaśnienie: Użyj Object.keys(obj).

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

Jak pobrać tablicę wartości z obiektu?

Wyjaśnienie: Użyj Object.values(obj).

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

Jak sprawdzić, czy tablica zawiera określoną wartość?

Wyjaśnienie: Użyj Array.prototype.includes(value).

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

Jak scalić dwie tablice w jedną?

Wyjaśnienie: Użyj składni spread (...) lub Array.prototype.concat().

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

Do czego odnosi się this w zasięgu globalnym w przeglądarce?

Wyjaśnienie: W globalnym kontekście wykonania (poza jakąkolwiek funkcją), this odnosi się do obiektu globalnego, którym w przeglądarkach internetowych jest window.

console.log(this === window); // true (w środowisku przeglądarki)

Do czego odnosi się this, gdy jest używane w metodzie obiektu?

Wyjaśnienie: Kiedy funkcja jest wywoływana jako metoda obiektu, this odnosi się do obiektu, na którym metoda jest wywoływana.

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

Jak funkcje strzałkowe obsługują this?

Wyjaśnienie: Funkcje strzałkowe nie mają własnego kontekstu this. Zamiast tego dziedziczą this z otaczającego (leksykalnego) zasięgu, w którym są zdefiniowane.

function MyClass() {
  this.value = 42;
  setTimeout(() => {
    console.log(this.value); // Loguje 42, ponieważ 'this' jest dziedziczone
  }, 100);
}
new MyClass();

Jakie są główne różnice między let, const i var?

Wyjaśnienie: var ma zakres funkcji i jest podnoszony (hoisting). let i const mają zakres bloku i są podnoszone, ale znajdują się w 'tymczasowej strefie martwej' do momentu deklaracji. const musi być zainicjowane i nie może być ponownie przypisane.

function scopeTest() {
  var a = 1;
  let b = 2;
  const c = 3;
  if (true) {
    var a = 10; // Ponownie deklaruje i wpływa na zewnętrzne 'a'
    let b = 20; // Nowe 'b' wewnątrz bloku
    // const c = 30; // Byłoby to nowe 'c'
    console.log(a, b, c); // 10, 20, 3
  }
  console.log(a, b, c); // 10, 2, 3
}
scopeTest();

Wyjaśnij, czym jest Obietnica w JavaScript.

Wyjaśnienie: Obietnica to obiekt reprezentujący ostateczne zakończenie (lub niepowodzenie) operacji asynchronicznej i jej wynikową wartość. Może znajdować się w jednym z trzech stanów: oczekująca, spełniona lub odrzucona.

const myPromise = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve('Sukces!');
    // reject('Błąd!');
  }, 1000);
});

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

Jak async i await upraszczają pracę z Obietnicami?

Wyjaśnienie: async/await dostarcza cukier składniowy nad Obietnicami, dzięki czemu kod asynchroniczny wygląda i zachowuje się nieco bardziej jak kod synchroniczny. Funkcja async zawsze zwraca Obietnicę, a await wstrzymuje wykonanie, dopóki Obietnica nie zostanie rozstrzygnięta.

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

async function run() {
  console.log('Startuję...');
  await delay(1000);
  console.log('Czekałem 1 sekundę.');
  await delay(500);
  console.log('Czekałem kolejne 0.5 sekundy.');
  return 'Zakończono!';
}

run().then(console.log);

Jak przekonwertować ciąg znaków na liczbę?

Wyjaśnienie: Użyj parseInt(), parseFloat() lub operatora unarnego plus (+).

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

Jak przekonwertować liczbę na ciąg znaków?

Wyjaśnienie: Użyj String(), number.toString() lub konkatenacji ciągów znaków.

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

Co robi JSON.stringify?

Wyjaśnienie: Konwertuje obiekt lub wartość JavaScript na ciąg znaków JSON.

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

Co robi JSON.parse?

Wyjaśnienie: Parsuje ciąg znaków JSON, konstruując wartość lub obiekt JavaScript opisany przez ciąg znaków.

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

Jak używany jest operator spread w tablicach?

Wyjaśnienie: Pozwala na rozszerzanie iterowalnego (takiego jak tablica) w miejscach, gdzie oczekuje się zera lub więcej argumentów lub elementów. Przydatne do kopiowania, scalania i dodawania elementów.

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

Jak używany jest operator spread z obiektami?

Wyjaśnienie: Pozwala na kopiowanie i scalanie właściwości obiektów.

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 }

Wyjaśnij destrukturyzację tablic na przykładzie.

Wyjaśnienie: Jest to składnia, która umożliwia rozpakowywanie wartości z tablic do odrębnych zmiennych.

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

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

Wyjaśnij destrukturyzację obiektów na przykładzie.

Wyjaśnienie: Umożliwia rozpakowywanie właściwości z obiektów do odrębnych zmiennych.

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'

Jak można by zaimplementować podstawową wersję Function.prototype.call?

Wyjaśnienie: call wywołuje funkcję z określoną wartością this i argumentami dostarczonymi indywidualnie. Możesz dołączyć funkcję do kontekstu this, wywołać ją, a następnie usunąć.

Function.prototype.myCall = function(context, ...args) {
  context = context || window;
  const uniqueId = Symbol(); // Użyj unikalnego klucza
  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' }, 'Cześć', '!'); // Cześć, Charlie!

Jak można by zaimplementować podstawową wersję Function.prototype.apply?

Wyjaśnienie: apply jest podobne do call, ale akceptuje argumenty jako tablicę.

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' }, ['Witaj', '.']); // Witaj, David.

Krótko wyjaśnij pętlę zdarzeń JavaScript. Wyjaśnienie: JavaScript jest jednowątkowy, ale osiąga współbieżność za pomocą pętli zdarzeń. Stos wywołań (call stack) obsługuje kod synchroniczny. Web API obsługują operacje asynchroniczne (takie jak setTimeout, fetch). Gdy operacja asynchroniczna się zakończy, jej funkcja zwrotna trafia do kolejki funkcji zwrotnych (callback queue) (lub kolejki mikro-zadań dla Promise). Pętla zdarzeń stale sprawdza, czy stos wywołań jest pusty; jeśli tak, przenosi następną funkcję zwrotną z kolejki na stos w celu wykonania.

console.log('Start');

setTimeout(() => {
  console.log('Timeout Callback'); // Goes to Callback Queue
}, 0);

Promise.resolve().then(() => {
  console.log('Promise Resolved'); // Goes to Microtask Queue
});

console.log('End');

// Output Order: Start, End, Promise Resolved, Timeout Callback
// (Microtasks run before Macrotasks/Callbacks)

Zaimplementuj funkcję wyszukiwania binarnego dla posortowanej tablicy. Wyjaśnienie: Wyszukiwanie binarne efektywnie znajduje element w posortowanej tablicy, wielokrotnie dzieląc przedział wyszukiwania na pół. Jeśli wartość klucza wyszukiwania jest mniejsza niż element w środku przedziału, zawęź przedział do dolnej połowy. W przeciwnym razie zawęź go do górnej połowy. Robisz to, dopóki wartość nie zostanie znaleziona lub przedział nie będzie pusty.

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; // Found
    } else if (sortedArray[middle] < key) {
      start = middle + 1; // Search right half
    } else {
      end = middle - 1; // Search left half
    }
  }
  return -1; // Not found
}

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

Zaimplementuj algorytm sortowania przez scalanie (Merge Sort). Wyjaśnienie: Sortowanie przez scalanie to algorytm typu dziel i zwyciężaj. Dzieli on tablicę wejściową na dwie połówki, wywołuje się dla tych dwóch połówek, a następnie scala dwie posortowane połówki. Funkcja scalająca jest kluczowa; łączy ona dwie posortowane podtablice w jedną posortowaną tablicę.

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]

Zaimplementuj algorytm sortowania szybkiego (Quick Sort). Wyjaśnienie: Sortowanie szybkie to również algorytm typu dziel i zwyciężaj. Wybiera element jako punkt obrotu i dzieli daną tablicę wokół wybranego punktu obrotu. Elementy mniejsze od punktu obrotu trafiają na lewą stronę, a elementy większe na prawą. Następnie rekurencyjnie sortuje podtablice.

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]

Zaimplementuj algorytm sortowania bąbelkowego (Bubble Sort). Wyjaśnienie: Sortowanie bąbelkowe to prosty algorytm sortowania, który wielokrotnie przechodzi przez listę, porównuje sąsiadujące elementy i zamienia je miejscami, jeśli są w złej kolejności. Przejście przez listę jest powtarzane, aż lista zostanie posortowana.

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]]; // Swap
        swapped = true;
      }
    }
    n--; // Optimization: last element is already in place
  } while (swapped);
  return arr;
}

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

Dla danego ciągu znaków znajdź długość najdłuższego podciągu bez powtarzających się znaków. Wyjaśnienie: Użyj techniki 'ruchomego okna'. Utrzymuj okno (podciąg) i zestaw znaków w tym oknie. Rozszerzaj okno, przesuwając prawy wskaźnik. Jeśli zostanie znaleziony powtarzający się znak, zmniejsz okno od lewej, aż powtarzający się znak zostanie usunięty.

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')

Zaimplementuj listę jednokierunkową z metodami add i print. Wyjaśnienie: Lista połączona to liniowa struktura danych, w której elementy nie są przechowywane w ciągłych lokalizacjach pamięci. Każdy element (węzeł) wskazuje na następny. Potrzebujesz klasy Node i klasy LinkedList do zarządzania głową i dodawania nowych węzłów.

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

Zaimplementuj binarne drzewo poszukiwań (BST) z metodami insert i find. Wyjaśnienie: BST to struktura danych drzewa binarnego oparta na węzłach, która ma następujące właściwości: Lewe poddrzewo węzła zawiera tylko węzły z kluczami mniejszymi niż klucz węzła. Prawe poddrzewo węzła zawiera tylko węzły z kluczami większymi niż klucz węzła. Oba poddrzewa muszą być również binarnymi drzewami poszukiwań.

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

Napisz funkcję, która obraca tablicę w prawo o k kroków. Wyjaśnienie: Obracanie tablicy oznacza przesuwanie jej elementów. Dla obrotu w prawo, ostatni element staje się pierwszym. Powtarzanie tego k razy działa, ale jest nieefektywne. Lepszym sposobem jest użycie manipulacji tablicą lub obliczenie nowych pozycji.

function rotateArray(nums, k) {
  k = k % nums.length; // Handle cases where k > length
  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]

Dla dwóch danych tablic, napisz funkcję, która obliczy ich przecięcie (elementy wspólne dla obu). Wyjaśnienie: Dobrym podejściem jest przekształcenie jednej tablicy w Set dla wyszukiwania w czasie O(1). Następnie, iteruj przez drugą tablicę i sprawdź, czy każdy element istnieje w zestawie. Zbierz pasujące elementy.

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]

Dla danej tablicy ciągów znaków, pogrupuj anagramy. Wyjaśnienie: Kluczem jest znalezienie unikalnej sygnatury dla każdej grupy anagramów. Typowym sposobem jest posortowanie każdego słowa alfabetycznie. Słowa, które po posortowaniu dają ten sam ciąg znaków, są anagramami. Użyj mapy hash, gdzie kluczami są posortowane słowa, a wartościami są tablice oryginalnych słów.

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'])); 
// Output: [['eat', 'tea', 'ate'], ['tan', 'nat'], ['bat']]

Dla danej tablicy nums, napisz funkcję, która przeniesie wszystkie zera na jej koniec, zachowując względną kolejność elementów niezerowych. Wyjaśnienie: Użyj podejścia 'dwóch wskaźników' lub 'kuli śnieżnej'. Jeden wskaźnik śledzi pozycję, na której powinien znaleźć się następny element niezerowy. Iteruj przez tablicę; jeśli element jest niezerowy, umieść go na pozycji wskaźnika i zwiększ wskaźnik. Na koniec, wypełnij resztę zerami.

function moveZeroes(nums) {
  let nonZeroIndex = 0;

  // Move all non-zero elements to the front
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] !== 0) {
      nums[nonZeroIndex] = nums[i];
      nonZeroIndex++;
    }
  }

  // Fill the rest with zeros
  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]

Dla danej tablicy liczb całkowitych nums, znajdź ciągłą podtablicę (zawierającą co najmniej jedną liczbę), która ma największą sumę i zwróć tę sumę. Wyjaśnienie: Algorytm Kadane'a to efektywny sposób rozwiązania tego problemu. Iteruj przez tablicę, śledząc sumę currentMax kończącą się na bieżącej pozycji i sumę globalMax znalezioną do tej pory. Jeśli currentMax stanie się ujemna, zresetuj ją do 0 (lub raczej do bieżącego elementu).

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 (from [4, -1, 2, 1])