Live Coding

Bagaimana cara memeriksa apakah suatu objek JavaScript kosong?

Penjelasan: Sebuah objek kosong jika tidak memiliki properti enumerable sendiri. Kita bisa menggunakan Object.keys(obj) yang mengembalikan array dari nama-nama properti enumerable milik objek yang diberikan. Jika panjang array ini adalah 0, objek tersebut kosong.

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

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

Tulis fungsi untuk membalikkan string yang diberikan.

Penjelasan: Cara paling sederhana adalah mengubah string menjadi array karakter, menggunakan metode reverse() bawaan untuk array, lalu menggabungkan kembali karakter-karakter tersebut menjadi sebuah string.

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

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

Tulis fungsi yang memeriksa apakah string yang diberikan adalah palindrom.

Penjelasan: Palindrom adalah kata atau frasa yang terbaca sama dari depan maupun belakang. Kita bisa memeriksa ini dengan membalikkan string (mengabaikan huruf besar/kecil dan karakter non-alfanumerik untuk pemeriksaan yang lebih kuat, tetapi di sini kita melakukan pemeriksaan sederhana) dan membandingkannya dengan aslinya.

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

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

Tulis fungsi untuk menemukan angka terbesar dalam array angka.

Penjelasan: Anda dapat mengulang array, melacak angka terbesar yang ditemukan sejauh ini. Atau, Anda dapat menggunakan fungsi Math.max() bersama dengan sintaks spread (...) untuk meneruskan elemen array sebagai argumen.

function findMaxNumber(arr) {
  if (arr.length === 0) return undefined; // Atau lemparkan error
  return Math.max(...arr);
}

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

Tulis program yang mencetak angka dari 1 hingga n. Tetapi untuk kelipatan tiga, cetak 'Fizz' alih-alih angka, dan untuk kelipatan lima, cetak 'Buzz'. Untuk angka yang merupakan kelipatan tiga dan lima, cetak 'FizzBuzz'.

Penjelasan: Masalah klasik ini menguji logika dasar loop dan kondisi. Anda perlu mengulang dari 1 hingga n dan menggunakan operator modulo (%) untuk memeriksa keterbagian oleh 3 dan 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);

Tulis fungsi yang menghapus elemen duplikat dari array.

Penjelasan: Cara modern dan ringkas untuk mencapai ini adalah dengan menggunakan Set. Set hanya menyimpan nilai unik. Anda dapat mengubah array menjadi Set dan kemudian kembali menjadi array.

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

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

Tulis fungsi untuk memeriksa apakah dua string adalah anagram satu sama lain.

Penjelasan: Anagram adalah kata-kata yang dibentuk dengan menyusun ulang huruf-huruf dari kata lain. Untuk memeriksa, kita dapat membersihkan, mengurutkan, dan membandingkan string. Pembersihan melibatkan penghapusan karakter non-alfanumerik dan konversi ke kasus yang konsisten.

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

Tulis fungsi untuk menghitung faktorial dari bilangan bulat non-negatif.

Penjelasan: Faktorial (n!) dari sebuah bilangan adalah hasil kali semua bilangan bulat positif yang kurang dari atau sama dengan n. Kita dapat menghitung ini secara iteratif dengan mengalikan bilangan dari 1 hingga n.

function factorial(n) {
  if (n < 0) return undefined; // Faktorial tidak didefinisikan untuk bilangan negatif
  if (n === 0) return 1;
  let result = 1;
  for (let i = 1; i <= n; i++) {
    result *= i;
  }
  return result;
}

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

Tulis fungsi yang mengembalikan jumlah semua angka dalam array.

Penjelasan: Anda dapat menggunakan metode reduce, yang ideal untuk mengakumulasi nilai tunggal dari sebuah array. Metode ini mengambil fungsi callback dan nilai awal (0 untuk penjumlahan).

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

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

Tulis fungsi untuk meratakan array bertingkat. Untuk kesederhanaan, asumsikan hanya satu tingkat tingkatan.

Penjelasan: Untuk satu tingkat tingkatan, Anda dapat menggunakan Array.prototype.concat() dengan operator spread atau metode flat() (ES2019).

function flattenArray(arr) {
  // Menggunakan flat() (lebih sederhana jika ES2019+ bisa)
  // return arr.flat();

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

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

Tulis fungsi yang menghitung jumlah vokal (a, e, i, o, u) dalam string yang diberikan.

Penjelasan: Iterasi string (tidak peka huruf besar/kecil) dan periksa apakah setiap karakter adalah vokal. Pertahankan penghitung.

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

Tulis fungsi yang mengubah kalimat menjadi title case (huruf pertama setiap kata dikapitalisasi).

Penjelasan: Pisahkan kalimat menjadi kata-kata, lalu ulangi setiap kata, mengkapitalisasi huruf pertama dan membuat sisanya huruf kecil. Terakhir, gabungkan kembali kata-kata tersebut.

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'

Diberikan sebuah array bilangan bulat nums dan sebuah bilangan bulat target, kembalikan indeks dari dua bilangan sehingga jika dijumlahkan menghasilkan target.

Penjelasan: Pendekatan umum adalah menggunakan hash map (atau objek JavaScript) untuk menyimpan angka dan indeksnya saat Anda mengulang. Untuk setiap angka, periksa apakah target - current_number ada di peta.

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 []; // Atau null, atau lemparkan error jika tidak ada solusi
}

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

Buat fungsi yang mengembalikan fungsi penghitung. Setiap kali fungsi yang dikembalikan dipanggil, ia harus bertambah dan mengembalikan hitungan.

Penjelasan: Ini menunjukkan closure. Fungsi dalam memiliki akses ke variabel count dari lingkup fungsi luar, bahkan setelah fungsi luar selesai dieksekusi.

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

Tulis fungsi yang menemukan karakter non-pengulangan pertama dalam sebuah string.

Penjelasan: Anda dapat menggunakan hash map untuk menghitung frekuensi karakter. Pertama, ulangi string untuk membangun peta frekuensi. Kemudian, ulangi string lagi dan kembalikan karakter pertama dengan hitungan 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; // Atau beberapa indikator jika semuanya berulang
}

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

Tulis fungsi yang membagi array menjadi kelompok-kelompok dengan ukuran tertentu.

Penjelasan: Iterasi melalui array, mengambil irisan dengan ukuran yang ditentukan dan mendorongnya ke array baru. Tangani kasus di mana potongan terakhir mungkin lebih kecil.

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

Tulis fungsi untuk menentukan apakah angka yang diberikan adalah bilangan prima.

Penjelasan: Bilangan prima adalah bilangan asli lebih besar dari 1 yang tidak memiliki pembagi positif selain 1 dan dirinya sendiri. Iterasi dari 2 hingga akar kuadrat dari bilangan, periksa keterbagian. Tangani kasus ekstrem seperti 1 dan 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

Tulis fungsi yang menemukan kata terpanjang dalam sebuah kalimat.

Penjelasan: Pisahkan string menjadi array kata-kata. Kemudian, ulangi array, melacak kata terpanjang yang ditemukan sejauh ini (atau panjangnya).

function findLongestWord(str) {
  const words = str.split(' ');
  let longestWord = '';
  for (const word of words) {
    // Bersihkan kata jika diperlukan (misalnya, hapus tanda baca)
    if (word.length > longestWord.length) {
      longestWord = word;
    }
  }
  return longestWord;
}

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

Implementasikan versi Anda sendiri dari fungsi Array.prototype.map.

Penjelasan: Fungsi map mengambil callback dan membuat array baru dengan menerapkan callback ke setiap elemen dari array asli. Fungsi Anda harus mengulang array dan membangun array baru.

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]

Implementasikan versi Anda sendiri dari fungsi Array.prototype.filter.

Penjelasan: Fungsi filter mengambil callback dan membuat array baru dengan semua elemen yang melewati pengujian yang diimplementasikan oleh fungsi callback yang disediakan.

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

Implementasikan versi Anda sendiri dari fungsi Array.prototype.reduce.

Penjelasan: Fungsi reduce mengeksekusi fungsi callback 'reducer' yang disediakan pengguna pada setiap elemen array, meneruskan nilai pengembalian dari perhitungan pada elemen sebelumnya. Hasil akhir dari menjalankan reducer di semua elemen array adalah nilai tunggal. Tangani argumen nilai awal.

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

  if (initialValue === undefined) {
      if (arr.length === 0) throw new TypeError('Reduce of empty array with no initial value');
      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

Implementasikan fungsi Fibonacci menggunakan memoization untuk mengoptimalkan kinerja.

Penjelasan: Urutan Fibonacci melibatkan perhitungan berulang. Memoization menyimpan hasil panggilan fungsi yang mahal dan mengembalikan hasil yang di-cache saat input yang sama terjadi lagi.

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 (jauh lebih cepat daripada yang tidak di-memoized)

Tulis fungsi untuk memeriksa apakah string yang berisi kurung {}[]() seimbang.

Penjelasan: Gunakan tumpukan (stack). Saat Anda menemukan kurung buka, dorong ke tumpukan. Saat Anda menemukan kurung tutup, periksa apakah tumpukan kosong atau apakah elemen teratas adalah kurung buka yang cocok. Jika cocok, pop tumpukan. Jika tidak, atau jika tumpukan kosong, itu tidak seimbang. Pada akhirnya, tumpukan kosong berarti seimbang.

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

Implementasikan struktur data Antrean (Queue) dengan metode enqueue (tambah ke belakang) dan dequeue (hapus dari depan).

Penjelasan: Antrean mengikuti prinsip First-In, First-Out (FIFO). Array dapat digunakan, dengan push untuk enqueue dan shift untuk dequeue.

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

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

  dequeue() {
    if (this.isEmpty()) return 'Underflow';
    return this.items.shift();
  }

  front() {
    if (this.isEmpty()) return 'No elements in Queue';
    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

Implementasikan struktur data Tumpukan (Stack) dengan metode push (tambah ke atas) dan pop (hapus dari atas).

Penjelasan: Tumpukan mengikuti prinsip Last-In, First-Out (LIFO). Array dapat digunakan, dengan metode push dan pop.

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

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

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

Diberikan sebuah array yang berisi n bilangan berbeda yang diambil dari 0, 1, 2, ..., n, temukan bilangan yang hilang dari array tersebut.

Penjelasan: Jumlah bilangan dari 0 hingga n dapat dihitung menggunakan rumus n*(n+1)/2. Jumlah sebenarnya dari elemen array dapat dihitung. Selisih antara kedua jumlah ini akan menjadi bilangan yang hilang.

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

Implementasikan fungsi debounce. Debouncing memastikan bahwa suatu fungsi tidak dipanggil lagi sampai jangka waktu tertentu telah berlalu tanpa dipanggil.

Penjelasan: Gunakan setTimeout dan clearTimeout. Setiap kali fungsi yang di-debounce dipanggil, hapus timeout sebelumnya dan atur timeout baru. Panggilan fungsi yang sebenarnya hanya terjadi ketika timeout selesai.

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

// Contoh penggunaan:
const sayHello = () => console.log('Hello!');
const debouncedHello = debounce(sayHello, 1000);
debouncedHello(); // Dipanggil setelah 1 detik (jika tidak dipanggil lagi)
debouncedHello(); // Mereset timer
debouncedHello(); // Mereset timer, akan benar-benar berjalan 1 detik setelah panggilan ini.

Implementasikan fungsi throttle. Throttling memastikan bahwa suatu fungsi dipanggil paling banyak sekali dalam interval waktu tertentu.

Penjelasan: Gunakan flag untuk menunjukkan apakah panggilan diizinkan. Saat dipanggil, jika diizinkan, jalankan fungsi, atur flag ke false, dan gunakan setTimeout untuk mereset flag setelah interval.

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

// Contoh penggunaan:
const logScroll = () => console.log('Scrolling...');
const throttledScroll = throttle(logScroll, 1000);
// window.addEventListener('scroll', throttledScroll); // Akan mencatat paling banyak sekali per detik.

Tulis fungsi yang mengambil fungsi dengan dua argumen dan mengembalikan versi curried-nya.

Penjelasan: Currying mengubah fungsi dengan banyak argumen menjadi urutan fungsi, masing-masing mengambil satu argumen. f(a, b) menjadi 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

Tulis fungsi untuk melakukan deep clone dari objek JavaScript.

Penjelasan: Shallow clone hanya menyalin properti tingkat atas. Deep clone secara rekursif menyalin semua properti, termasuk objek dan array bertingkat. Cara sederhana (dengan batasan, mis. tidak menangani fungsi, tanggal, regex dengan baik) adalah menggunakan JSON.parse(JSON.stringify(obj)). Pendekatan rekursif lebih kuat.

function deepClone(obj) {
  // Versi sederhana (dengan batasan)
  try {
      return JSON.parse(JSON.stringify(obj));
  } catch (e) {
      console.error("Kloning gagal:", e);
      return null;
  }
  
  // Rekursif yang lebih kuat (contoh dasar):
  /*
  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 (membuktikan itu deep clone)
console.log(cloned.b.c); // 3

Bagaimana cara mendapatkan array kunci dari sebuah objek?

Penjelasan: Gunakan Object.keys(obj).

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

Bagaimana cara mendapatkan array nilai dari sebuah objek?

Penjelasan: Gunakan Object.values(obj).

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

Bagaimana cara memeriksa apakah sebuah array berisi nilai tertentu?

Penjelasan: Gunakan Array.prototype.includes(value).

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

Bagaimana cara menggabungkan dua array menjadi satu?

Penjelasan: Gunakan sintaks spread (...) atau Array.prototype.concat().

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

Apa yang dimaksud this dalam lingkup global di browser?

Penjelasan: Dalam konteks eksekusi global (di luar fungsi apa pun), this mengacu pada objek global, yaitu window di browser web.

console.log(this === window); // true (di lingkungan browser)

Apa yang dimaksud this saat digunakan di dalam metode objek?

Penjelasan: Ketika sebuah fungsi dipanggil sebagai metode dari sebuah objek, this mengacu pada objek tempat metode tersebut dipanggil.

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

Bagaimana fungsi panah menangani this?

Penjelasan: Fungsi panah tidak memiliki konteks this sendiri. Sebaliknya, mereka mewarisi this dari cakupan (leksikal) di sekitarnya tempat mereka didefinisikan.

function MyClass() {
  this.value = 42;
  setTimeout(() => {
    console.log(this.value); // Mencatat 42 karena 'this' diwarisi
  }, 100);
}
new MyClass();

Apa perbedaan utama antara let, const, dan var?

Penjelasan: var memiliki cakupan fungsi dan di-hoist. let dan const memiliki cakupan blok dan di-hoist tetapi berada dalam 'zona mati temporal' sampai deklarasi. const harus diinisialisasi dan tidak dapat ditetapkan ulang.

function scopeTest() {
  var a = 1;
  let b = 2;
  const c = 3;
  if (true) {
    var a = 10; // Mendeklarasikan ulang dan memengaruhi 'a' luar
    let b = 20; // 'b' baru di dalam blok
    // const c = 30; // Akan menjadi 'c' baru
    console.log(a, b, c); // 10, 20, 3
  }
  console.log(a, b, c); // 10, 2, 3
}
scopeTest();

Jelaskan apa itu Promise dalam JavaScript.

Penjelasan: Promise adalah objek yang mewakili penyelesaian (atau kegagalan) operasi asinkron dan nilai hasilnya. Ini dapat berada dalam salah satu dari tiga keadaan: pending, fulfilled, atau rejected.

const myPromise = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve('Sukses!');
    // reject('Error!');
  }, 1000);
});

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

Bagaimana async dan await menyederhanakan bekerja dengan Promise?

Penjelasan: async/await menyediakan sintaks gula di atas Promise, membuat kode asinkron terlihat dan berperilaku sedikit lebih seperti kode sinkron. Fungsi async selalu mengembalikan Promise, dan await menjeda eksekusi sampai Promise terselesaikan.

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

async function run() {
  console.log('Memulai...');
  await delay(1000);
  console.log('Menunggu 1 detik.');
  await delay(500);
  console.log('Menunggu 0,5 detik lagi.');
  return 'Selesai!';
}

run().then(console.log);

Bagaimana cara mengubah string menjadi angka?

Penjelasan: Gunakan parseInt(), parseFloat(), atau operator plus unary (+).

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

Bagaimana cara mengubah angka menjadi string?

Penjelasan: Gunakan String(), number.toString(), atau konkatenasi string.

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

Apa yang dilakukan JSON.stringify?

Penjelasan: Ini mengubah objek atau nilai JavaScript menjadi string JSON.

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

Apa yang dilakukan JSON.parse?

Penjelasan: Ini menguraikan string JSON, membangun nilai atau objek JavaScript yang dijelaskan oleh string.

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

Bagaimana operator spread digunakan dengan array?

Penjelasan: Ini memungkinkan iterable (seperti array) untuk diperluas di tempat-tempat di mana nol atau lebih argumen atau elemen diharapkan. Berguna untuk menyalin, menggabungkan, dan menambahkan elemen.

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

Bagaimana operator spread digunakan dengan objek?

Penjelasan: Ini memungkinkan penyalinan dan penggabungan properti objek.

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 }

Jelaskan destrukturisasi array dengan sebuah contoh.

Penjelasan: Ini adalah sintaks yang memungkinkan untuk membongkar nilai dari array ke dalam variabel yang berbeda.

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

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

Jelaskan destrukturisasi objek dengan sebuah contoh.

Penjelasan: Ini memungkinkan untuk membongkar properti dari objek ke dalam variabel yang berbeda.

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'

Bagaimana Anda bisa mengimplementasikan versi dasar dari Function.prototype.call?

Penjelasan: call memanggil fungsi dengan nilai this yang ditentukan dan argumen yang disediakan secara individual. Anda dapat melampirkan fungsi ke konteks this, memanggilnya, dan kemudian menghapusnya.

Function.prototype.myCall = function(context, ...args) {
  context = context || window;
  const uniqueId = Symbol(); // Gunakan kunci unik
  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' }, 'Hi', '!'); // Hi, Charlie!

Bagaimana Anda bisa mengimplementasikan versi dasar dari Function.prototype.apply?

Penjelasan: apply mirip dengan call, tetapi menerima argumen sebagai array.

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

Jelaskan secara singkat JavaScript Event Loop.

Penjelasan: JavaScript adalah single-threaded, tetapi mencapai konkurensi menggunakan event loop. Call stack menangani kode sinkron. Web API menangani operasi asinkron (seperti setTimeout, fetch). Ketika operasi asinkron selesai, callback-nya masuk ke antrean callback (atau antrean microtask untuk Promise). Event loop terus-menerus memeriksa apakah call stack kosong; jika ya, ia memindahkan callback berikutnya dari antrean ke stack untuk dieksekusi.

console.log('Mulai');

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

Promise.resolve().then(() => {
  console.log('Promise Diselesaikan'); // Masuk ke Microtask Queue
});

console.log('Selesai');

// Urutan Output: Mulai, Selesai, Promise Diselesaikan, Callback Timeout
// (Microtasks berjalan sebelum Macrotasks/Callbacks)

Implementasikan fungsi pencarian biner untuk array yang diurutkan.

Penjelasan: Pencarian biner secara efisien menemukan item dalam array yang diurutkan dengan berulang kali membagi interval pencarian menjadi dua. Jika nilai kunci pencarian lebih kecil dari item di tengah interval, persempit interval ke setengah bagian bawah. Jika tidak, persempit ke setengah bagian atas. Anda melakukan ini sampai nilai ditemukan atau interval kosong.

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; // Ditemukan
    } else if (sortedArray[middle] < key) {
      start = middle + 1; // Cari setengah kanan
    } else {
      end = middle - 1; // Cari setengah kiri
    }
  }
  return -1; // Tidak ditemukan
}

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

Implementasikan algoritma Merge Sort.

Penjelasan: Merge Sort adalah algoritma divide-and-conquer. Ini membagi array masukan menjadi dua bagian, memanggil dirinya sendiri untuk kedua bagian, dan kemudian menggabungkan dua bagian yang diurutkan. Fungsi penggabungan sangat penting; ini menggabungkan dua sub-array yang diurutkan menjadi satu array yang diurutkan.

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]

Implementasikan algoritma Quick Sort.

Penjelasan: Quick Sort juga merupakan algoritma divide-and-conquer. Ia memilih elemen sebagai pivot dan mempartisi array yang diberikan di sekitar pivot yang dipilih. Elemen yang lebih kecil dari pivot pergi ke kiri, dan elemen yang lebih besar pergi ke kanan. Kemudian secara rekursif mengurutkan sub-array.

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]

Implementasikan algoritma Bubble Sort.

Penjelasan: Bubble Sort adalah algoritma pengurutan sederhana yang berulang kali melangkah melalui daftar, membandingkan elemen-elemen yang berdekatan, dan menukarnya jika urutannya salah. Lintasan melalui daftar diulang sampai daftar diurutkan.

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]]; // Tukar
        swapped = true;
      }
    }
    n--; // Optimasi: elemen terakhir sudah pada tempatnya
  } while (swapped);
  return arr;
}

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

Diberikan sebuah string, temukan panjang substring terpanjang tanpa karakter berulang.

Penjelasan: Gunakan teknik 'sliding window'. Pertahankan jendela (substring) dan set karakter dalam jendela itu. Perluas jendela dengan menggerakkan penunjuk kanan. Jika karakter berulang ditemukan, kecilkan jendela dari kiri hingga karakter berulang dihapus.

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

Implementasikan Singly Linked List dengan metode add dan print.

Penjelasan: Linked list adalah struktur data linier di mana elemen tidak disimpan di lokasi memori yang berdekatan. Setiap elemen (node) menunjuk ke elemen berikutnya. Anda membutuhkan kelas Node dan kelas LinkedList untuk mengelola head dan menambahkan node baru.

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

Implementasikan Pohon Pencarian Biner dengan metode insert dan find.

Penjelasan: BST adalah struktur data pohon biner berbasis node yang memiliki properti berikut: Subpohon kiri sebuah node hanya berisi node dengan kunci yang lebih kecil dari kunci node. Subpohon kanan sebuah node hanya berisi node dengan kunci yang lebih besar dari kunci node. Kedua subpohon juga harus berupa pohon pencarian biner.

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

Tulis fungsi untuk memutar array ke kanan sebanyak k langkah.

Penjelasan: Memutar array berarti memindahkan elemen-elemennya. Untuk rotasi kanan, elemen terakhir menjadi yang pertama. Mengulang ini sebanyak k kali berfungsi tetapi tidak efisien. Cara yang lebih baik adalah menggunakan manipulasi array atau menghitung posisi baru.

function rotateArray(nums, k) {
  k = k % nums.length; // Tangani kasus di mana k > panjang
  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]

Diberikan dua array, tulis fungsi untuk menghitung irisannya (elemen yang umum untuk keduanya).

Penjelasan: Pendekatan yang baik adalah mengubah salah satu array menjadi Set untuk pencarian waktu rata-rata O(1). Kemudian, ulangi array kedua dan periksa apakah setiap elemen ada di set. Kumpulkan yang cocok.

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]

Diberikan sebuah array string, kelompokkan anagram menjadi satu.

Penjelasan: Kuncinya adalah menemukan tanda tangan unik untuk setiap kelompok anagram. Cara umum adalah mengurutkan setiap kata secara alfabetis. Kata-kata yang menghasilkan string terurut yang sama adalah anagram. Gunakan hash map di mana kunci adalah kata-kata yang diurutkan dan nilai adalah array kata-kata asli.

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

Diberikan sebuah array nums, tulis fungsi untuk memindahkan semua angka 0 ke akhir sambil mempertahankan urutan relatif elemen non-nol.

Penjelasan: Gunakan pendekatan 'dua-penunjuk' atau 'bola salju'. Satu penunjuk melacak posisi di mana elemen non-nol berikutnya harus ditempatkan. Ulangi array; jika sebuah elemen non-nol, tempatkan pada posisi penunjuk dan tingkatkan penunjuk. Terakhir, isi sisanya dengan nol.

function moveZeroes(nums) {
  let nonZeroIndex = 0;

  // Pindahkan semua elemen non-nol ke depan
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] !== 0) {
      nums[nonZeroIndex] = nums[i];
      nonZeroIndex++;
    }
  }

  // Isi sisanya dengan nol
  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]

Diberikan sebuah array bilangan bulat nums, temukan sub-array yang berdekatan (mengandung setidaknya satu angka) yang memiliki jumlah terbesar dan kembalikan jumlahnya.

Penjelasan: Algoritma Kadane adalah cara yang efisien untuk menyelesaikan ini. Ulangi array, lacak jumlah currentMax yang berakhir pada posisi saat ini dan jumlah globalMax yang ditemukan sejauh ini. Jika currentMax menjadi negatif, reset ke 0 (atau lebih tepatnya, elemen saat ini).

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