Live Coding

كيف تتحقق مما إذا كان كائن JavaScript فارغًا؟

الشرح: يكون الكائن فارغًا إذا لم يكن لديه أي خصائص قابلة للتعداد خاصة به. يمكننا استخدام 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'

اكتب دالة تتحقق مما إذا كانت السلسلة النصية المعطاة هي كلمة متطابقة (palindrome).

الشرح: الكلمة المتطابقة هي كلمة أو عبارة تقرأ بنفس الطريقة إلى الأمام والخلف. يمكننا التحقق من ذلك عن طريق عكس السلسلة (تجاهل حالة الأحرف والأحرف غير الأبجدية الرقمية لإجراء فحص أكثر قوة، ولكن هنا نقوم بفحص بسيط) ومقارنتها بالأصل.

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

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

اكتب دالة للعثور على أكبر رقم في مصفوفة من الأرقام.

الشرح: يمكنك التكرار عبر المصفوفة، وتتبع أكبر رقم تم العثور عليه حتى الآن. بدلاً من ذلك، يمكنك استخدام الدالة Math.max() جنبًا إلى جنب مع بناء الجملة المنتشر (...) لتمرير عناصر المصفوفة كوسيطات.

function findMaxNumber(arr) {
  if (arr.length === 0) return undefined; // أو قم بإلقاء خطأ
  return Math.max(...arr);
}

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

اكتب برنامجًا يطبع الأرقام من 1 إلى n. ولكن بالنسبة لمضاعفات الرقم ثلاثة، اطبع 'Fizz' بدلاً من الرقم، وبالنسبة لمضاعفات الرقم خمسة، اطبع 'Buzz'. أما بالنسبة للأرقام التي هي مضاعفات لكل من ثلاثة وخمسة، اطبع 'FizzBuzz'.

الشرح: تختبر هذه المشكلة الكلاسيكية حلقة أساسية ومنطق شرطي. تحتاج إلى التكرار من 1 إلى n واستخدام عامل القسمة (%) للتحقق من قابلية القسمة على 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. تخزن المجموعات القيم الفريدة فقط. يمكنك تحويل المصفوفة إلى مجموعة ثم العودة إلى مصفوفة.

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، وهي مثالية لتجميع قيمة واحدة من مصفوفة. تأخذ دالة رد نداء وقيمة أولية (0 للجمع).

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

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

اكتب دالة لتسوية مصفوفة متداخلة. للتبسيط، افترض مستوى واحد فقط من التداخل.

الشرح: لمستوى واحد من التداخل، يمكنك استخدام Array.prototype.concat() مع عامل الانتشار أو طريقة flat() (ES2019).

function flattenArray(arr) {
  // استخدام flat() (أبسط إذا كان ES2019+ مقبولاً)
  // return arr.flat();

  // استخدام reduce و 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

اكتب دالة تحول جملة إلى حالة العنوان (الحرف الأول من كل كلمة كبير).

الشرح: قم بتقسيم الجملة إلى كلمات، ثم كرر عبر كل كلمة، وجعل الحرف الأول كبيرًا وبقية الحروف صغيرة. أخيرًا، قم بربط الكلمات مرة أخرى.

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.

الشرح: يتمثل أحد الأساليب الشائعة في استخدام خريطة التجزئة (أو كائن JavaScript) لتخزين الأرقام ومؤشراتها أثناء التكرار. لكل رقم، تحقق مما إذا كان 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، أو ألقِ خطأ إذا لم يكن هناك حل
}

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

أنشئ دالة تُرجع دالة عداد. في كل مرة يتم فيها استدعاء الدالة المرجعة، يجب أن تزيد العدد وتُرجع العد.

الشرح: يوضح هذا الإغلاقات. الدالة الداخلية لديها إمكانية الوصول إلى متغير 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) {
    // نظف الكلمات إذا لزم الأمر (على سبيل المثال، إزالة علامات الترقيم)
    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 دالة رد نداء وتنشئ مصفوفة جديدة عن طريق تطبيق رد النداء على كل عنصر من عناصر المصفوفة الأصلية. يجب أن تقوم دالتك بالتكرار عبر المصفوفة وإنشاء المصفوفة الجديدة.

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 دالة رد نداء وتنشئ مصفوفة جديدة تحتوي على جميع العناصر التي تجتاز الاختبار الذي تم تنفيذه بواسطة دالة رد النداء المقدمة.

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 دالة رد نداء 'مخفضة' مقدمة من المستخدم على كل عنصر من عناصر المصفوفة، مع تمرير القيمة المرجعة من الحساب على العنصر السابق. النتيجة النهائية لتشغيل المخفض عبر جميع عناصر المصفوفة هي قيمة واحدة. تعامل مع وسيطة القيمة الأولية.

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

طبق دالة فيبوناتشي باستخدام الاستذكار لتحسين الأداء.

الشرح: تتضمن متتالية فيبوناتشي حسابات متكررة. يخزن الاستذكار نتائج استدعاءات الدالة المكلفة ويعيد النتيجة المخزنة مؤقتًا عندما تحدث نفس المدخلات مرة أخرى.

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 (أسرع بكثير من غير الاستذكار)

اكتب دالة للتحقق مما إذا كانت السلسلة النصية التي تحتوي على أقواس {}[]() متوازنة.

الشرح: استخدم مكدسًا. عندما تصادف قوسًا افتتاحيًا، ادفعه إلى المكدس. عندما تصادف قوسًا إغلاقيًا، تحقق مما إذا كان المكدس فارغًا أو إذا كان العنصر العلوي هو القوس الافتتاحي المطابق. إذا كان يطابق، فامسح المكدس. إذا لم يكن كذلك، أو إذا كان المكدس فارغًا، فهو غير متوازن. في النهاية، يعني المكدس الفارغ أنه متوازن.

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 (إزالة من الأمام).

الشرح: تتبع قائمة الانتظار مبدأ الأول يدخل، الأول يخرج (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 (إزالة من الأعلى).

الشرح: يتبع المكدس مبدأ الأخير يدخل، الأول يخرج (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

طبق دالة إزالة ارتداد. تضمن إزالة الارتداد عدم استدعاء دالة مرة أخرى حتى مرور فترة زمنية معينة دون استدعائها.

الشرح: استخدم setTimeout وclearTimeout. في كل مرة يتم فيها استدعاء الدالة المزالة الارتداد، امسح المهلة السابقة واضبط مهلة جديدة. يحدث استدعاء الدالة الفعلي فقط عند اكتمال المهلة.

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

// مثال على الاستخدام:
const sayHello = () => console.log('Hello!');
const debouncedHello = debounce(sayHello, 1000);
debouncedHello(); // يتم استدعاؤها بعد 1 ثانية (إذا لم يتم استدعاؤها مرة أخرى)
debouncedHello(); // تعيد ضبط المؤقت
debouncedHello(); // تعيد ضبط المؤقت، وستعمل فعليًا بعد 1 ثانية من هذا الاستدعاء.

طبق دالة التحديد. تضمن التحديد أن الدالة تُستدعى مرة واحدة على الأكثر في فترة زمنية محددة.

الشرح: استخدم علامة للإشارة إلى ما إذا كان الاستدعاء مسموحًا به. عند الاستدعاء، إذا كان مسموحًا به، قم بتنفيذ الدالة، واضبط العلامة على false، واستخدم setTimeout لإعادة ضبط العلامة بعد الفترة.

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

// مثال على الاستخدام:
const logScroll = () => console.log('Scrolling...');
const throttledScroll = throttle(logScroll, 1000);
// window.addEventListener('scroll', throttledScroll); // ستسجل مرة واحدة على الأكثر في الثانية.

اكتب دالة تأخذ دالة ذات وسيطتين وتُرجع نسخة مجزأة منها.

الشرح: تقوم التجزئة بتحويل دالة ذات وسيطات متعددة إلى سلسلة من الدوال، تأخذ كل منها وسيطة واحدة. تصبح 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

اكتب دالة لإجراء نسخ عميق لكائن JavaScript.

الشرح: النسخ السطحي ينسخ الخصائص العلوية فقط. النسخ العميق ينسخ جميع الخصائص بشكل متكرر، بما في ذلك الكائنات والمصفوفات المتداخلة. طريقة بسيطة (مع قيود، على سبيل المثال، لا تتعامل مع الدوال والتواريخ والتعبيرات النمطية بشكل جيد) هي استخدام JSON.parse(JSON.stringify(obj)). النهج المتكرر أكثر قوة.

function deepClone(obj) {
  // نسخة بسيطة (مع قيود)
  try {
      return JSON.parse(JSON.stringify(obj));
  } catch (e) {
      console.error("فشل الاستنساخ:", e);
      return null;
  }
  
  // نسخة متكررة أكثر قوة (مثال أساسي):
  /*
  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 (يثبت أنه استنساخ عميق)
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

كيف تدمج مصفوفتين في واحدة؟

الشرح: استخدم بناء الجملة المنتشر (...) أو 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 لأن 'this' موروثة
  }, 100);
}
new MyClass();

ما هي الاختلافات الرئيسية بين let وconst وvar؟

الشرح: var محدد النطاق بالدالة ويتم رفعه (hoisted). let وconst محددين النطاق بالكتلة ويتم رفعهما ولكن في 'منطقة زمنية ميتة' حتى الإعلان. يجب تهيئة 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) في JavaScript.

الشرح: الوعد هو كائن يمثل الاكتمال النهائي (أو الفشل) لعملية غير متزامنة وقيمتها الناتجة. يمكن أن يكون في إحدى الحالات الثلاث: معلق (pending)، مكتمل (fulfilled)، أو مرفوض (rejected).

const myPromise = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve('نجاح!');
    // reject('خطأ!');
  }, 1000);
});

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

كيف تبسط async وawait العمل مع الوعود؟

الشرح: يوفر async/await سكرًا نحويًا (syntactic sugar) فوق الوعود، مما يجعل الكود غير المتزامن يبدو ويتصرف أكثر شبهاً بالكود المتزامن. ترجع دالة async دائمًا وعدًا، وawait توقف التنفيذ حتى يستقر الوعد.

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

async function run() {
  console.log('جارٍ البدء...');
  await delay(1000);
  console.log('انتظرنا ثانية واحدة.');
  await delay(500);
  console.log('انتظرنا 0.5 ثانية أخرى.');
  return 'انتهى!';
}

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؟

الشرح: يحول كائن أو قيمة JavaScript إلى سلسلة JSON.

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

ماذا يفعل JSON.parse؟

الشرح: يقوم بتحليل سلسلة JSON، وإنشاء قيمة أو كائن JavaScript الموصوف بواسطة السلسلة.

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

كيف يُستخدم عامل الانتشار مع المصفوفات؟

الشرح: يسمح بفتح كائن قابل للتكرار (مثل مصفوفة) في أماكن يُتوقع فيها صفر أو أكثر من الوسيطات أو العناصر. مفيد للنسخ والدمج وإضافة العناصر.

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

كيف يُستخدم عامل الانتشار مع الكائنات؟

الشرح: يسمح بنسخ ودمج خصائص الكائن.

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 }

اشرح تفكيك المصفوفات مع مثال.

الشرح: هو بناء جملة يجعل من الممكن فك قيم المصفوفات إلى متغيرات مميزة.

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

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

اشرح تفكيك الكائنات مع مثال.

الشرح: يجعل من الممكن فك خصائص الكائنات إلى متغيرات مميزة.

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

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

كيف يمكنك تطبيق نسخة أساسية من 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: 'تشارلي' }, 'مرحباً', '!'); // مرحباً، تشارلي!

كيف يمكنك تطبيق نسخة أساسية من 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: 'ديفيد' }, ['أهلاً', '.']); // أهلاً، ديفيد.

شرح موجز لدورة الأحداث في JavaScript.

الشرح: JavaScript أحادية الخيط (single-threaded)، ولكنها تحقق التزامن باستخدام حلقة الأحداث (event loop). يتعامل مكدس الاستدعاءات (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]

تنفيذ خوارزمية الفرز السريع.

الشرح: الفرز السريع هي أيضًا خوارزمية 'فرق تسد'. تختار عنصرًا كنقطة ارتكاز وتقسم المصفوفة المعطاة حول نقطة الارتكاز المختارة. العناصر الأصغر من نقطة الارتكاز تذهب إلى اليسار، والعناصر الأكبر تذهب إلى اليمين. ثم تقوم بفرز المصفوفات الفرعية بشكل متكرر.

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]

بمعلومية سلسلة نصية، أوجد طول أطول سلسلة فرعية بدون أحرف متكررة.

الشرح: استخدم تقنية 'النافذة المنزلقة'. احتفظ بنافذة (سلسلة فرعية) ومجموعة من الأحرف في تلك النافذة. قم بتوسيع النافذة عن طريق تحريك المؤشر الأيمن. إذا تم العثور على حرف متكرر، قم بتقليص النافذة من اليسار حتى يتم إزالة الحرف المتكرر.

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.

الشرح: القائمة المتصلة هي بنية بيانات خطية لا يتم تخزين العناصر فيها في مواقع ذاكرة متجاورة. يشير كل عنصر (عقدة) إلى العنصر التالي. تحتاج إلى فئة 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) في المتوسط. ثم، قم بالتكرار عبر المصفوفة الثانية وتحقق مما إذا كان كل عنصر موجودًا في المجموعة. اجمع التطابقات.

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]

بمعلومية مصفوفة من السلاسل النصية، قم بتجميع المتجانسات معًا.

الشرح: المفتاح هو إيجاد توقيع فريد لكل مجموعة من المتجانسات. طريقة شائعة هي فرز كل كلمة أبجديًا. الكلمات التي تنتج نفس السلسلة النصية المرتبة هي متجانسات. استخدم خريطة تجزئة حيث المفاتيح هي الكلمات المرتبة والقيم هي مصفوفات من الكلمات الأصلية.

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، اكتب دالة لنقل جميع الأصفار إلى نهايتها مع الحفاظ على الترتيب النسبي للعناصر غير الصفرية.

الشرح: استخدم نهج 'المؤشرين' أو 'كرة الثلج'. يحافظ مؤشر واحد على تتبع الموضع الذي يجب أن يذهب إليه العنصر غير الصفري التالي. قم بالتكرار عبر المصفوفة؛ إذا كان العنصر غير صفري، ضعه في موضع المؤشر وزد المؤشر. أخيرًا، املأ الباقي بالأصفار.

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