Live Coding

چگونه بررسی کنیم که یک شیء جاوااسکریپت خالی است؟

توضیح: یک شیء زمانی خالی است که هیچ ویژگی قابل شمارش (enumerable) خودش را نداشته باشد. می‌توانیم از Object.keys(obj) استفاده کنیم که آرایه‌ای از نام ویژگی‌های قابل شمارش خود شیء داده شده را برمی‌گرداند. اگر طول این آرایه 0 باشد، شیء خالی است.

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

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

تابعی بنویسید که یک رشته داده شده را معکوس کند.

توضیح: ساده‌ترین راه این است که رشته را به آرایه‌ای از کاراکترها تبدیل کنیم، از متد داخلی reverse() برای آرایه‌ها استفاده کنیم و سپس کاراکترها را دوباره به یک رشته متصل کنیم.

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

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

تابعی بنویسید که بررسی کند آیا یک رشته داده شده پالیندروم است یا خیر.

توضیح: پالیندروم کلمه یا عبارتی است که از جلو و عقب یکسان خوانده می‌شود. می‌توانیم این را با معکوس کردن رشته (با نادیده گرفتن حروف بزرگ و کوچک و کاراکترهای غیرحروفی-عددی برای بررسی قوی‌تر، اما در اینجا یک بررسی ساده انجام می‌دهیم) و مقایسه آن با رشته اصلی بررسی کنیم.

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

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

تابعی بنویسید که بزرگترین عدد را در آرایه‌ای از اعداد پیدا کند.

توضیح: می‌توانید در آرایه پیمایش کنید و بزرگترین عدد یافت شده تا کنون را پیگیری کنید. روش دیگر این است که از تابع Math.max() به همراه عملگر spread (...) برای ارسال عناصر آرایه به عنوان آرگومان استفاده کنید.

function findMaxNumber(arr) {
  if (arr.length === 0) return undefined; // یا یک خطا throw کنید
  return Math.max(...arr);
}

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

برنامه‌ای بنویسید که اعداد از 1 تا n را چاپ کند. اما برای مضرب‌های سه، به جای عدد 'Fizz' و برای مضرب‌های پنج، 'Buzz' را چاپ کند. برای اعدادی که هم مضرب سه و هم پنج هستند، 'FizzBuzz' را چاپ کند.

توضیح: این مسئله کلاسیک منطق پایه حلقه و شرطی را آزمایش می‌کند. شما باید از 1 تا n پیمایش کنید و از عملگر modulo (%) برای بررسی قابلیت تقسیم بر 3 و 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);

تابعی بنویسید که عناصر تکراری را از یک آرایه حذف کند.

توضیح: یک راه مدرن و مختصر برای دستیابی به این هدف، استفاده از یک Set است. Setها فقط مقادیر منحصر به فرد را ذخیره می‌کنند. می‌توانید آرایه را به یک Set تبدیل کرده و سپس دوباره به یک آرایه برگردانید.

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

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

تابعی بنویسید که بررسی کند آیا دو رشته آناگرام یکدیگر هستند یا خیر.

توضیح: آناگرام‌ها کلماتی هستند که با جابجایی حروف کلمه‌ای دیگر تشکیل می‌شوند. برای بررسی، می‌توانیم رشته‌ها را تمیز، مرتب و مقایسه کنیم. تمیز کردن شامل حذف کاراکترهای غیرحروفی-عددی و تبدیل به یک حالت ثابت (حروف کوچک یا بزرگ) است.

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

تابعی بنویسید که فاکتوریل یک عدد صحیح غیر منفی را محاسبه کند.

توضیح: فاکتوریل (n!) یک عدد حاصل ضرب تمام اعداد صحیح مثبت کوچکتر یا مساوی n است. می‌توانیم این را به صورت تکراری با ضرب اعداد از 1 تا n محاسبه کنیم.

function factorial(n) {
  if (n < 0) return undefined; // فاکتوریل برای اعداد منفی تعریف نشده است
  if (n === 0) return 1;
  let result = 1;
  for (let i = 1; i <= n; i++) {
    result *= i;
  }
  return result;
}

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

تابعی بنویسید که مجموع تمام اعداد در یک آرایه را برگرداند.

توضیح: می‌توانید از متد reduce استفاده کنید که برای جمع‌آوری یک مقدار واحد از یک آرایه ایده‌آل است. این متد یک تابع callback و یک مقدار اولیه (0 برای جمع) را می‌گیرد.

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

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

تابعی بنویسید که یک آرایه تو در تو را تخت کند. برای سادگی، فرض کنید فقط یک سطح تو در تو بودن وجود دارد.

توضیح: برای یک سطح تو در تو بودن، می‌توانید از Array.prototype.concat() با عملگر spread یا متد flat() (ES2019) استفاده کنید.

function flattenArray(arr) {
  // Using flat() (simpler if ES2019+ is okay)
  // return arr.flat();

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

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

تابعی بنویسید که تعداد حروف صدادار (a, e, i, o, u) را در یک رشته داده شده بشمارد.

توضیح: در رشته (بدون توجه به حروف بزرگ و کوچک) پیمایش کنید و بررسی کنید که آیا هر کاراکتر یک حرف صدادار است یا خیر. یک شمارنده را نگه دارید.

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

تابعی بنویسید که یک جمله را به Title Case تبدیل کند (حرف اول هر کلمه با حروف بزرگ).

توضیح: جمله را به کلمات تقسیم کنید، سپس در هر کلمه پیمایش کنید، حرف اول را بزرگ کرده و بقیه را کوچک کنید. در نهایت، کلمات را دوباره به هم متصل کنید.

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'

آرایه‌ای از اعداد صحیح nums و یک عدد صحیح target داده شده است، ایندکس‌های دو عددی را برگردانید که مجموع آنها برابر با target باشد.

توضیح: یک رویکرد متداول استفاده از یک نقشه هش (یا یک شیء جاوااسکریپت) برای ذخیره اعداد و ایندکس‌های آنها در حین پیمایش است. برای هر عدد، بررسی کنید که آیا target - current_number در نقشه وجود دارد یا خیر.

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 []; // یا null، یا در صورت عدم وجود راه حل خطا throw کنید
}

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

تابعی ایجاد کنید که یک تابع شمارنده را برگرداند. هر بار که تابع برگشتی فراخوانی می‌شود، باید شمارنده را افزایش داده و مقدار آن را برگرداند.

توضیح: این مثال Closures را نشان می‌دهد. تابع داخلی به متغیر count در حوزه تابع بیرونی دسترسی دارد، حتی پس از اتمام اجرای تابع بیرونی.

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

تابعی بنویسید که اولین کاراکتر غیر تکراری را در یک رشته پیدا کند.

توضیح: می‌توانید از یک نقشه هش برای شمارش فرکانس کاراکترها استفاده کنید. ابتدا، در رشته پیمایش کنید تا نقشه فرکانس را بسازید. سپس، دوباره در رشته پیمایش کنید و اولین کاراکتر با شمارش 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; // یا یک نشانگر در صورت تکرار همه
}

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

تابعی بنویسید که یک آرایه را به گروه‌هایی با اندازه مشخص تقسیم کند.

توضیح: در آرایه پیمایش کنید، تکه‌هایی با اندازه مشخص را بردارید و آنها را به یک آرایه جدید اضافه کنید. حالت‌هایی را که آخرین تکه ممکن است کوچکتر باشد، مدیریت کنید.

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

تابعی بنویسید که تعیین کند آیا یک عدد داده شده عدد اول است یا خیر.

توضیح: یک عدد اول یک عدد طبیعی بزرگتر از 1 است که هیچ مقسوم‌علیه مثبتی به جز 1 و خودش ندارد. از 2 تا ریشه مربع عدد پیمایش کنید و قابلیت تقسیم را بررسی کنید. موارد خاص مانند 1 و 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

تابعی بنویسید که طولانی‌ترین کلمه را در یک جمله پیدا کند.

توضیح: رشته را به آرایه‌ای از کلمات تقسیم کنید. سپس، در آرایه پیمایش کنید و طولانی‌ترین کلمه یافت شده تا کنون (یا طول آن) را پیگیری کنید.

function findLongestWord(str) {
  const words = str.split(' ');
  let longestWord = '';
  for (const word of words) {
    // Clean words if needed (e.g., remove punctuation)
    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 را پیاده‌سازی کنید.

توضیح: تابع map یک callback را می‌گیرد و با اعمال callback به هر عنصر از آرایه اصلی، یک آرایه جدید ایجاد می‌کند. تابع شما باید در آرایه پیمایش کرده و آرایه جدید را بسازد.

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 را پیاده‌سازی کنید.

توضیح: تابع filter یک callback را می‌گیرد و یک آرایه جدید با تمام عناصری که تست پیاده‌سازی شده توسط تابع 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']

نسخه خودتان از تابع Array.prototype.reduce را پیاده‌سازی کنید.

توضیح: تابع reduce یک تابع callback 'reducer' که توسط کاربر ارائه شده است را بر روی هر عنصر آرایه اجرا می‌کند و مقدار بازگشتی از محاسبه بر روی عنصر قبلی را به آن منتقل می‌کند. نتیجه نهایی اجرای reducer در تمام عناصر آرایه یک مقدار واحد است. آرگومان مقدار اولیه را مدیریت کنید.

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

یک تابع فیبوناچی را با استفاده از memoization برای بهینه‌سازی عملکرد پیاده‌سازی کنید.

توضیح: دنباله فیبوناچی شامل محاسبات تکراری است. Memoization نتایج فراخوانی توابع گران‌قیمت را ذخیره می‌کند و در صورت تکرار ورودی‌های مشابه، نتیجه کش شده را برمی‌گرداند.

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 (much faster than non-memoized)

تابعی بنویسید که بررسی کند آیا یک رشته حاوی پرانتزهای {}[()] متوازن است یا خیر.

توضیح: از یک پشته استفاده کنید. هنگامی که به یک پرانتز باز برمی‌خورید، آن را به پشته فشار دهید. هنگامی که به یک پرانتز بسته برمی‌خورید، بررسی کنید که آیا پشته خالی است یا اینکه عنصر بالایی پرانتز باز مطابق است. اگر مطابق باشد، پشته را pop کنید. اگر نه، یا اگر پشته خالی است، نامتوازن است. در پایان، یک پشته خالی به معنای متوازن بودن است.

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

ساختار داده Queue را با متدهای enqueue (افزودن به انتها) و dequeue (حذف از جلو) پیاده‌سازی کنید.

توضیح: یک صف از اصل First-In, First-Out (FIFO) پیروی می‌کند. می‌توان از یک آرایه استفاده کرد، با push برای enqueue و shift برای 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

ساختار داده Stack را با متدهای push (افزودن به بالا) و pop (حذف از بالا) پیاده‌سازی کنید.

توضیح: یک پشته از اصل Last-In, First-Out (LIFO) پیروی می‌کند. می‌توان از یک آرایه استفاده کرد، با متدهای push و 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

آرایه‌ای حاوی n عدد متمایز از 0, 1, 2, ..., n داده شده است، عددی را پیدا کنید که از آرایه گم شده است.

توضیح: مجموع اعداد از 0 تا n را می‌توان با استفاده از فرمول n*(n+1)/2 محاسبه کرد. مجموع واقعی عناصر آرایه را می‌توان محاسبه کرد. تفاوت بین این دو مجموع، عدد گمشده خواهد بود.

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

یک تابع debounce را پیاده‌سازی کنید. Debouncing تضمین می‌کند که یک تابع تا زمانی که مقدار مشخصی از زمان بدون فراخوانی آن سپری نشده باشد، دوباره فراخوانی نشود.

توضیح: از setTimeout و clearTimeout استفاده کنید. هر بار که تابع debounced فراخوانی می‌شود، timeout قبلی را پاک کرده و یک timeout جدید را تنظیم کنید. فراخوانی واقعی تابع تنها زمانی اتفاق می‌افتد که timeout کامل شود.

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

// Example usage:
const sayHello = () => console.log('Hello!');
const debouncedHello = debounce(sayHello, 1000);
debouncedHello(); // Called after 1 sec (if not called again)
debouncedHello(); // Resets timer
debouncedHello(); // Resets timer, will actually run 1 sec after this call.

یک تابع throttle را پیاده‌سازی کنید. Throttling تضمین می‌کند که یک تابع حداکثر یک بار در یک بازه زمانی مشخص فراخوانی شود.

توضیح: از یک پرچم برای نشان دادن اینکه آیا فراخوانی مجاز است یا خیر، استفاده کنید. هنگامی که فراخوانی شد، اگر مجاز بود، تابع را اجرا کنید، پرچم را به false تنظیم کنید و از setTimeout برای بازنشانی پرچم پس از بازه زمانی استفاده کنید.

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

// Example usage:
const logScroll = () => console.log('Scrolling...');
const throttledScroll = throttle(logScroll, 1000);
// window.addEventListener('scroll', throttledScroll); // Will log at most once per second.

تابعی بنویسید که یک تابع با دو آرگومان را می‌گیرد و یک نسخه curried از آن را برمی‌گرداند.

توضیح: Currying یک تابع با آرگومان‌های متعدد را به دنباله‌ای از توابع تبدیل می‌کند که هر کدام یک آرگومان را می‌گیرند. f(a, b) به 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

تابعی بنویسید که یک کپی عمیق از یک شیء جاوااسکریپت را انجام دهد.

توضیح: یک کپی سطحی (shallow clone) فقط ویژگی‌های سطح بالا را کپی می‌کند. یک کپی عمیق به صورت بازگشتی تمام ویژگی‌ها، از جمله اشیاء و آرایه‌های تو در تو را کپی می‌کند. یک راه ساده (با محدودیت‌هایی، مثلاً توابع، تاریخ‌ها، regex را به خوبی مدیریت نمی‌کند) استفاده از JSON.parse(JSON.stringify(obj)) است. یک رویکرد بازگشتی قوی‌تر است.

function deepClone(obj) {
  // Simple version (with limitations)
  try {
      return JSON.parse(JSON.stringify(obj));
  } catch (e) {
      console.error("Cloning failed:", e);
      return null;
  }
  
  // More robust recursive (basic example):
  /*
  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 (proves it's a deep clone)
console.log(cloned.b.c); // 3

چگونه آرایه‌ای از کلیدها را از یک شیء دریافت کنیم؟

توضیح: از Object.keys(obj) استفاده کنید.

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

چگونه آرایه‌ای از مقادیر را از یک شیء دریافت کنیم؟

توضیح: از Object.values(obj) استفاده کنید.

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

چگونه بررسی کنیم که یک آرایه حاوی مقدار خاصی است؟

توضیح: از Array.prototype.includes(value) استفاده کنید.

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

چگونه دو آرایه را در یک آرایه ادغام کنیم؟

توضیح: از عملگر spread (...) یا Array.prototype.concat() استفاده کنید.

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

this در حوزه سراسری در یک مرورگر به چه چیزی اشاره دارد؟

توضیح: در زمینه اجرای سراسری (خارج از هر تابع)، this به شیء سراسری اشاره دارد که در مرورگرهای وب window است.

console.log(this === window); // true (در یک محیط مرورگر)

this هنگامی که در داخل یک متد شیء استفاده می‌شود، به چه چیزی اشاره دارد؟

توضیح: هنگامی که یک تابع به عنوان متدی از یک شیء فراخوانی می‌شود، this به شیئی اشاره دارد که متد بر روی آن فراخوانی شده است.

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

توابع فلش this را چگونه مدیریت می‌کنند؟

توضیح: توابع فلش زمینه this خود را ندارند. در عوض، آنها this را از حوزه احاطه‌کننده (لغوی) که در آن تعریف شده‌اند، به ارث می‌برند.

function MyClass() {
  this.value = 42;
  setTimeout(() => {
    console.log(this.value); // 42 را log می‌کند زیرا 'this' به ارث برده شده است
  }, 100);
}
new MyClass();

تفاوت‌های اصلی بین let, const, و var چیست؟

توضیح: var در حوزه تابع است و hoisted می‌شود. let و const در حوزه بلوک هستند و hoisted می‌شوند اما تا زمان اعلان در یک 'منطقه مرده زمانی' (temporal dead zone) قرار دارند. const باید مقداردهی اولیه شود و نمی‌تواند دوباره مقداردهی شود.

function scopeTest() {
  var a = 1;
  let b = 2;
  const c = 3;
  if (true) {
    var a = 10; // دوباره اعلان می‌کند و بر 'a' بیرونی تأثیر می‌گذارد
    let b = 20; // 'b' جدید در داخل بلوک
    // const c = 30; // یک 'c' جدید خواهد بود
    console.log(a, b, c); // 10, 20, 3
  }
  console.log(a, b, c); // 10, 2, 3
}
scopeTest();

توضیح دهید که Promise در جاوااسکریپت چیست.

توضیح: یک Promise شیئی است که نشان‌دهنده اتمام (یا شکست) نهایی یک عملیات ناهمزمان و مقدار حاصل از آن است. می‌تواند در یکی از سه حالت باشد: در حال انتظار (pending)، انجام شده (fulfilled)، یا رد شده (rejected).

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

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

چگونه async و await کار با Promiseها را ساده می‌کنند؟

توضیح: async/await یک sugar نحوی بر روی Promiseها ارائه می‌دهد که کد ناهمزمان را تا حدی شبیه به کد همزمان می‌کند. یک تابع async همیشه یک Promise را برمی‌گرداند، و await اجرا را تا زمانی که یک Promisesettle شود، متوقف می‌کند.

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

async function run() {
  console.log('Starting...');
  await delay(1000);
  console.log('Waited 1 second.');
  await delay(500);
  console.log('Waited another 0.5 seconds.');
  return 'Finished!';
}

run().then(console.log);

چگونه یک رشته را به عدد تبدیل کنیم؟

توضیح: از parseInt(), parseFloat(), یا عملگر تک‌عملیاتی مثبت (+) استفاده کنید.

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

چگونه یک عدد را به رشته تبدیل کنیم؟

توضیح: از String(), number.toString(), یا الحاق رشته استفاده کنید.

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

JSON.stringify چه کاری انجام می‌دهد؟

توضیح: یک شیء یا مقدار جاوااسکریپت را به یک رشته JSON تبدیل می‌کند.

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

JSON.parse چه کاری انجام می‌دهد؟

توضیح: یک رشته JSON را تجزیه می‌کند و مقدار یا شیء جاوااسکریپت توصیف شده توسط رشته را می‌سازد.

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

عملگر spread چگونه با آرایه‌ها استفاده می‌شود؟

توضیح: به یک iterable (مانند یک آرایه) اجازه می‌دهد در جاهایی که صفر یا بیشتر آرگومان یا عنصر مورد انتظار است، گسترش یابد. برای کپی کردن، ادغام و افزودن عناصر مفید است.

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

عملگر spread چگونه با اشیاء استفاده می‌شود؟

توضیح: امکان کپی و ادغام ویژگی‌های شیء را فراهم می‌کند.

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 }

تجزیه آرایه (array destructuring) را با یک مثال توضیح دهید.

توضیح: یک نحو است که امکان باز کردن مقادیر از آرایه‌ها را به متغیرهای مجزا فراهم می‌کند.

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

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

تجزیه شیء (object destructuring) را با یک مثال توضیح دهید.

توضیح: امکان باز کردن ویژگی‌ها از اشیاء را به متغیرهای مجزا فراهم می‌کند.

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 را پیاده‌سازی کنید؟

توضیح: call یک تابع را با یک مقدار this مشخص و آرگومان‌های ارائه شده به صورت جداگانه فراخوانی می‌کند. می‌توانید تابع را به زمینه this متصل کنید، آن را فراخوانی کنید، و سپس آن را حذف کنید.

Function.prototype.myCall = function(context, ...args) {
  context = context || window;
  const uniqueId = Symbol(); // از یک کلید منحصر به فرد استفاده کنید
  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!

چگونه می‌توانید یک نسخه پایه از Function.prototype.apply را پیاده‌سازی کنید؟

توضیح: apply شبیه به call است، اما آرگومان‌ها را به عنوان یک آرایه می‌پذیرد.

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.

حلقه رویداد جاوااسکریپت را به اختصار توضیح دهید.

توضیح: جاوااسکریپت تک‌رشته‌ای (single-threaded) است، اما با استفاده از حلقه رویداد به هم‌زمانی (concurrency) دست می‌یابد. پشته فراخوانی (call stack) کد هم‌زمان را مدیریت می‌کند. رابط‌های برنامه‌نویسی وب (Web APIs) عملیات ناهم‌زمان (مانند setTimeout، fetch) را مدیریت می‌کنند. وقتی یک عملیات ناهم‌زمان به پایان می‌رسد، تابع بازگشتی آن (callback) به صف بازگشتی (callback queue) یا صف میکرووظایف (microtask queue برای Promises) می‌رود. حلقه رویداد دائماً بررسی می‌کند که آیا پشته فراخوانی خالی است؛ اگر خالی باشد، تابع بازگشتی بعدی را از صف به پشته منتقل می‌کند تا اجرا شود.

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)

تابعی برای جستجوی دودویی در یک آرایه مرتب شده پیاده‌سازی کنید.

توضیح: جستجوی دودویی به طور کارآمد یک آیتم را در یک آرایه مرتب شده با تقسیم مکرر فاصله جستجو به نصف، پیدا می‌کند. اگر مقدار کلید جستجو کمتر از آیتم میانی فاصله باشد، فاصله را به نیمه پایینی محدود کنید. در غیر این صورت، آن را به نیمه بالایی محدود کنید. این کار را تا زمانی که مقدار یافت شود یا فاصله خالی شود، انجام می‌دهید.

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

الگوریتم مرتب‌سازی ادغامی را پیاده‌سازی کنید.

توضیح: مرتب‌سازی ادغامی یک الگوریتم تقسیم و غلبه است. این الگوریتم آرایه ورودی را به دو نیمه تقسیم می‌کند، خودش را برای دو نیمه فراخوانی می‌کند و سپس دو نیمه مرتب شده را ادغام می‌کند. تابع ادغام حیاتی است؛ آن دو زیرآرایه مرتب شده را در یک آرایه مرتب شده ترکیب می‌کند.

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]

الگوریتم مرتب‌سازی سریع را پیاده‌سازی کنید.

توضیح: مرتب‌سازی سریع نیز یک الگوریتم تقسیم و غلبه است. این الگوریتم یک عنصر را به عنوان محور (pivot) انتخاب می‌کند و آرایه داده شده را حول محور انتخاب شده تقسیم می‌کند. عناصر کوچکتر از محور به سمت چپ و عناصر بزرگتر به سمت راست می‌روند. سپس به صورت بازگشتی زیرآرایه‌ها را مرتب می‌کند.

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]

الگوریتم مرتب‌سازی حبابی را پیاده‌سازی کنید.

توضیح: مرتب‌سازی حبابی یک الگوریتم مرتب‌سازی ساده است که به طور مکرر از لیست عبور می‌کند، عناصر مجاور را مقایسه می‌کند و اگر در ترتیب اشتباه باشند، آنها را جابجا می‌کند. عبور از لیست تا زمانی که لیست مرتب شود تکرار می‌شود.

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]

با داشتن یک رشته، طول طولانی‌ترین زیررشته بدون تکرار کاراکترها را پیدا کنید.

توضیح: از تکنیک پنجره کشویی (sliding window) استفاده کنید. یک پنجره (زیررشته) و مجموعه‌ای از کاراکترها در آن پنجره را حفظ کنید. پنجره را با حرکت دادن اشاره‌گر راست گسترش دهید. اگر یک کاراکتر تکراری یافت شد، پنجره را از سمت چپ کوچک کنید تا کاراکتر تکراری حذف شود.

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

یک لیست پیوندی یک‌طرفه (Singly Linked List) با متدهای add و print پیاده‌سازی کنید.

توضیح: لیست پیوندی یک ساختار داده خطی است که در آن عناصر در مکان‌های حافظه پیوسته ذخیره نمی‌شوند. هر عنصر (گره) به عنصر بعدی اشاره می‌کند. برای مدیریت سر (head) و اضافه کردن گره‌های جدید به یک کلاس Node و یک کلاس LinkedList نیاز دارید.

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

یک درخت جستجوی دودویی (Binary Search Tree) با متدهای insert و find پیاده‌سازی کنید.

توضیح: BST یک ساختار داده درختی دودویی مبتنی بر گره است که دارای ویژگی‌های زیر است: زیردرخت چپ یک گره فقط شامل گره‌هایی با کلیدهای کوچکتر از کلید گره است. زیردرخت راست یک گره فقط شامل گره‌هایی با کلیدهای بزرگتر از کلید گره است. هر دو زیردرخت نیز باید درختان جستجوی دودویی باشند.

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

تابعی بنویسید که یک آرایه را به راست به اندازه k گام بچرخاند.

توضیح: چرخاندن یک آرایه به معنای جابجایی عناصر آن است. برای چرخش به راست، عنصر آخر به اولین عنصر تبدیل می‌شود. تکرار این کار k بار کار می‌کند اما ناکارآمد است. راه بهتر استفاده از دستکاری آرایه یا محاسبه موقعیت‌های جدید است.

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]

با داشتن دو آرایه، تابعی برای محاسبه تقاطع آنها (عناصر مشترک در هر دو) بنویسید.

توضیح: یک روش خوب این است که یک آرایه را به یک Set تبدیل کنید تا جستجوها در زمان متوسط O(1) انجام شود. سپس، آرایه دوم را پیمایش کنید و بررسی کنید که آیا هر عنصر در Set وجود دارد یا خیر. موارد تطابق را جمع‌آوری کنید.

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]

با داشتن آرایه‌ای از رشته‌ها، آناگرام‌ها را با هم گروه‌بندی کنید.

توضیح: نکته اصلی این است که برای هر گروه از آناگرام‌ها یک امضای منحصر به فرد پیدا کنید. یک روش متداول، مرتب‌سازی هر کلمه به صورت الفبایی است. کلماتی که به یک رشته مرتب شده یکسان منجر می‌شوند، آناگرام هستند. از یک جدول هش (hash map) استفاده کنید که در آن کلیدها کلمات مرتب شده و مقادیر آرایه‌هایی از کلمات اصلی هستند.

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

با داشتن یک آرایه nums، تابعی بنویسید تا همه 0ها را به انتهای آن منتقل کند در حالی که ترتیب نسبی عناصر غیرصفر حفظ شود.

توضیح: از رویکرد دو اشاره‌گر (two-pointer) یا گلوله برفی (snowball) استفاده کنید. یک اشاره‌گر موقعیتی را که عنصر غیرصفر بعدی باید قرار گیرد، پیگیری می‌کند. آرایه را پیمایش کنید؛ اگر عنصری غیرصفر است، آن را در موقعیت اشاره‌گر قرار دهید و اشاره‌گر را افزایش دهید. در نهایت، بقیه را با صفر پر کنید.

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]

با داشتن یک آرایه از اعداد صحیح nums، زیرآرایه متوالی (شامل حداقل یک عدد) را که بیشترین مجموع را دارد پیدا کنید و مجموع آن را برگردانید.

توضیح: الگوریتم کادان یک روش کارآمد برای حل این مسئله است. آرایه را پیمایش کنید و هم مجموع currentMax (مجموع تا موقعیت فعلی) و هم مجموع globalMax (بیشترین مجموع یافت شده تا کنون) را پیگیری کنید. اگر currentMax منفی شد، آن را به 0 (یا بهتر است بگوییم، به عنصر فعلی) بازنشانی کنید.

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