Jassif Team Institution

JavaScript Iterables

ஒரு மீளக்கூடிய பொருள் என்பது for...of லூப்கள் மூலம் மீள்வு செய்யக்கூடிய ஒரு பொருள் ஆகும்.

மீளக்கூடியது for...of லூப்களுடன் மீள்வு செய்யப்படலாம்.

The for...of Loop

JavaScript for..of அறிக்கை ஒரு மீளக்கூடிய பொருளின் உறுப்புகள் வழியாக லூப் செய்கிறது.

Syntax

for (variable of iterable) {
  // செயல்படுத்த வேண்டிய குறியீட்டு தொகுதி
}

மீள்வு

மீள்வு என்பது உறுப்புகளின் ஒரு வரிசை மீது லூப் செய்வதாகும்.

இங்கே சில எடுத்துக்காட்டுகள்:

சரம் மீது மீள்வு

ஒரு சரத்தின் உறுப்புகள் மீது மீள்வதற்கு நீங்கள் for...of லூப்பைப் பயன்படுத்தலாம்:

Example

const name = "Jassif Team";

for (const x of name) {
  // செயல்படுத்த வேண்டிய குறியீட்டு தொகுதி
}

வரிசை மீது மீள்வு

ஒரு வரிசையின் உறுப்புகள் மீது மீள்வதற்கு நீங்கள் for...of லூப்பைப் பயன்படுத்தலாம்:

Example 1

const letters = ["a","b","c"];

for (const x of letters) {
  // செயல்படுத்த வேண்டிய குறியீட்டு தொகுதி
}

Example 2

const numbers = [2,4,6,8];

for (const x of numbers) {
  // செயல்படுத்த வேண்டிய குறியீட்டு தொகுதி
}

Set மீது மீள்வு

ஒரு Set இன் உறுப்புகள் மீது மீள்வதற்கு நீங்கள் for...of லூப்பைப் பயன்படுத்தலாம்:

Example

const letters = new Set(["a","b","c"]);

for (const x of letters) {
  // செயல்படுத்த வேண்டிய குறியீட்டு தொகுதி
}

Map மீது மீள்வு

ஒரு Map இன் உறுப்புகள் மீது மீள்வதற்கு நீங்கள் for...of லூப்பைப் பயன்படுத்தலாம்:

Example

const fruits = new Map([
  ["apples", 500],
  ["bananas", 300],
  ["oranges", 200]
]);

for (const x of fruits) {
  // செயல்படுத்த வேண்டிய குறியீட்டு தொகுதி
}

JavaScript Iterators

மீள்வு நெறிமுறை ஒரு பொருளிலிருந்து மதிப்புகளின் வரிசையை எவ்வாறு உருவாக்குவது என்பதை வரையறுக்கிறது.

ஒரு பொருள் next() முறையை செயல்படுத்தும்போது மீள்வியாக மாறுகிறது.

next() முறை இரண்டு பண்புகளைக் கொண்ட ஒரு பொருளைத் திரும்பப் பெற வேண்டும்:

JavaScript இல் மீளக்கூடியவை

JavaScript இல் பின்வருவன மீளக்கூடியவை:

காரணம்: அவற்றின் முன்னுதாரணப் பொருள்கள் Symbol.iterator முறையைக் கொண்டுள்ளன.

வீட்டில் உருவாக்கப்பட்ட மீளக்கூடிய

இந்த மீளக்கூடிய next() முறை அழைக்கப்படும் போது முடிவில்லா எண்களைத் தரும்: 10,20,30,40,....

Example

// வீட்டில் உருவாக்கப்பட்ட மீளக்கூடிய
function myNumbers() {
  let n = 0;
  return {
    next: function() {
      n += 10;
      return {value:n, done:false};
    }
  };
}

// மீளக்கூடியதை இயக்கவும்
const n = myNumbers();
n.next(); // 10 ஐத் தரும்
n.next(); // 20 ஐத் தரும்
n.next(); // 30 ஐத் தரும்

Symbol.iterator

ஒரு JavaScript மீளக்கூடிய என்பது Symbol.iterator ஐக் கொண்ட ஒரு பொருள் ஆகும்.

Symbol.iterator என்பது ஒரு next() செயல்பாட்டைத் தரும் ஒரு செயல்பாடு ஆகும்.

ஒரு மீளக்கூடிய பின்வரும் குறியீட்டுடன் மீள்வு செய்யப்படலாம்:

for (const x of iterable) {
  // இங்கே ஏதேனும் குறியீடு
}

Example

// ஒரு பொருளை உருவாக்கவும்
myNumbers = {};

// அதை மீளக்கூடியதாக மாற்றவும்
myNumbers[Symbol.iterator] = function() {
  let n = 0;
  done = false;
  return {
    next() {
      n += 10;
      if (n == 100) {done = true}
      return {value:n, done:done};
    }
  };
}

இப்போது நீங்கள் for..of ஐப் பயன்படுத்தலாம்:

for (const num of myNumbers) {
  // இங்கே ஏதேனும் குறியீடு
}

Example

let iterator = myNumbers[Symbol.iterator]();

while (true) {
  const result = iterator.next();
  if (result.done) break;
  // இங்கே ஏதேனும் குறியீடு
}

முக்கிய குறிப்பு

அடுத்த அத்தியாயத்தில் ECMAScript 2025 இல் அறிமுகப்படுத்தப்பட்ட புதிய மீள்வி உதவி செயல்பாடுகளைப் பற்றி கற்றுக்கொள்வீர்கள்.

JavaScript Iterables பயிற்சி

பின்வரும் குறியீட்டைக் கவனியுங்கள்:

let firstname = 'Jim', i = 0;
for (const x of firstname) {
  i++;
}

i இன் மதிப்பு என்னவாக இருக்கும்?