Angular Templates: TrackBy with *ngFor

பட்டியல்களை விரைவாகவும் நிலையாகவும் வைத்திருங்கள் - ஒரு தனிப்பட்ட விசையுடன் உருப்படிகளை அடையாளம் காண trackBy பயன்படுத்தவும்

TrackBy with *ngFor என்றால் என்ன?

ஆங்குலர் பட்டியல் உருப்படிகளை எவ்வாறு அடையாளம் காண்கிறது என்பதை வரையறுக்கிறது.

உருப்படிகள் நகர்த்தப்படும்போது, செருகப்படும்போது அல்லது அகற்றப்படும்போது DOM முனைகளை மீண்டும் பயன்படுத்துவதை இயலுமைப்படுத்துகிறது.

பொதுவாக ஒவ்வொரு உருப்படிக்கும் ஒரு தனிப்பட்ட ID ஐ திருப்பி அனுப்புகிறது.

Without trackBy:
Slow Performance
With trackBy:
Fast Performance

TrackBy எப்போது பயன்படுத்த வேண்டும்

Item 1
Item 2
Item 3
Item 4
Item 5

Performance Tip

trackBy இல்லாமல், ஆங்குலர் ஒவ்வொரு மாற்றத்திலும் முழு DOM மரத்தையும் மறுவழங்க வேண்டியிருக்கும். trackBy உடன், DOM முனைகள் தேவைப்படும்போது மீண்டும் பயன்படுத்தப்படும்.

TrackBy எவ்வாறு செயல்படுகிறது

Without trackBy

<li *ngFor="let item of items">
  {{ item.name }}
</li>

சிக்கல்: ஒவ்வொரு மாற்றத்திலும் முழு பட்டியலையும் ஆங்குலர் மறுவழங்குகிறது

செயல்திறன்: மோசமானது

With trackBy

<li *ngFor="let item of items; 
         trackBy: trackById">
  {{ item.name }}
</li>

நன்மை: ஆங்குலர் DOM முனைகளை மீண்டும் பயன்படுத்துகிறது

செயல்திறன்: சிறந்தது

Important Warning

தொடர்புடைய பைண்டிங்குகள் மற்றும் சங்கிலி விளைவுகளுடன் பெரிய பட்டியல்களுக்கு trackBy இல்லாமல், கடுமையான செயல்திறன் சிக்கல்கள் ஏற்படலாம்.

Example

Complete Angular Example

import { bootstrapApplication } from '@angular/platform-browser';
import { Component } from '@angular/core';
import { CommonModule } from '@angular/common';

// Define Item type
type Item = { 
  id: number; 
  name: string 
};

@Component({
  selector: 'app-root',
  standalone: true,
  imports: [CommonModule],
  template: `
    <button (click)="shuffle()">Shuffle Items</button>
    <ul>
      <li *ngFor="let it of items; trackBy: trackById">
        {{ it.id }} - {{ it.name }}
      </li>
    </ul>
  `
})
export class App {
  // Initial items array
  items: Item[] = [
    { id: 1, name: 'Alpha' },
    { id: 2, name: 'Beta' },
    { id: 3, name: 'Gamma' }
  ];
  
  // Shuffle method to reorder items
  shuffle() {
    // Reverse the array to demonstrate trackBy benefits
    this.items = [...this.items].reverse();
  }
  
  // TrackBy function - identifies each item uniquely
  trackById(_i: number, it: Item) { 
    return it.id; 
  }
}

bootstrapApplication(App);

Example Explained

*ngFor ... trackBy: trackById: பட்டியல் வரிசை மாறும்போது ஆங்குலர் DOM முனைகளை மீண்டும் பயன்படுத்தக்கூடிய வகையில் ஒவ்வொரு உருப்படிக்கும் நிலையான அடையாளத்தைக் கொடுக்க trackById ஐப் பயன்படுத்துகிறது.

trackById(index, item): ஒரு உருப்படிக்கான தனிப்பட்ட விசையைத் திருப்பி அனுப்புகிறது. இங்கே, குறியீட்டைப் பொருட்படுத்தாமல் item.id ஐத் திருப்பி அனுப்புகிறது.

shuffle(): trackBy உடன், ஆங்குலர் இருக்கும் DOM முனைகளை அழிப்பதற்கும் மீண்டும் உருவாக்குவதற்கும் பதிலாக நகர்த்துகிறது என்பதை நிரூபிக்க வரிசையை மாற்றுகிறது.

Visual Demonstration

Without trackBy

DOM முனைகள் அழிக்கப்பட்டு மீண்டும் உருவாக்கப்படுகின்றன

Alpha
Beta
Gamma

↓ Shuffle ↓

Gamma
Beta
Alpha

6 DOM செயல்பாடுகள்

With trackBy

DOM முனைகள் மீண்டும் பயன்படுத்தப்படுகின்றன

Alpha
Beta
Gamma

↓ Shuffle ↓

Gamma
Beta
Alpha

3 DOM செயல்பாடுகள்

Common TrackBy Patterns

Using ID Field

trackById(index, item) {
  return item.id;
}

மிகவும் பொதுவான முறை

Using Unique Key

trackByKey(index, item) {
  return item.uniqueKey;
}

மாற்று தனிப்பட்ட புலத்திற்கு

Using Index (Caution)

trackByIndex(index, item) {
  return index;
}

இறுதி முயற்சியாக மட்டுமே - தரவு மாறினால் சிக்கல்கள்

Index as TrackBy Warning

குறியீட்டை trackBy செயல்பாடாகப் பயன்படுத்த வேண்டாம், ஏனெனில்:

  • உருப்படிகள் சேர்க்கப்படும்போது அல்லது அகற்றப்படும்போது குறியீடுகள் மாறுகின்றன
  • தவறான DOM மறுபயன்பாட்டிற்கு வழிவகுக்கும்
  • தரவு பைண்டிங் சிக்கல்களை ஏற்படுத்தும்

Exercise

பட்டியல் வழங்கலுடன் trackBy பயன்படுத்துவதன் நன்மை என்ன?

பட்டியல் வழங்கலுடன் trackBy பயன்படுத்துவதன் நன்மை என்ன?

உருப்படி அடையாளத்தை கண்காணிப்பதன் மூலம் வழங்கும் செயல்திறனை மேம்படுத்துகிறது
✓ சரி! trackBy ஆங்குலருக்கு DOM முனைகளை மீண்டும் பயன்படுத்த அனுமதிக்கிறது, மறுவழங்கும் செயல்திறனை கணிசமாக மேம்படுத்துகிறது
பட்டியலை தானாகவே வரிசைப்படுத்துகிறது
✗ தவறு! trackBy பட்டியலை வரிசைப்படுத்தாது - அது தரவு மேலாளரின் பொறுப்பு
மாற்றங்களைக் கண்டறிதலைத் தடுக்கிறது
✗ தவறு! trackBy மாற்றங்களைக் கண்டறிதலைத் தடுக்காது, ஆனால் DOM செயல்திறனை மேம்படுத்துகிறது

Best Practices for TrackBy

Always Use trackBy for Large Lists

50+ உருப்படிகள் கொண்ட எந்தப் பட்டியலுக்கும் trackBy ஐ எப்போதும் பயன்படுத்தவும்

Use Stable Unique Identifiers

உருப்படி வாழ்நாள் முழுவதும் மாறாத தனிப்பட்ட அடையாளங்காட்டிகளைப் பயன்படுத்தவும்

Never Use Random Values

Math.random() அல்லது Date.now() போன்ற சீரற்ற மதிப்புகளை trackBy செயல்பாடாகப் பயன்படுத்த வேண்டாம்

Performance Checklist

  • ✅ பெரிய பட்டியல்களுக்கு எப்போதும் trackBy ஐப் பயன்படுத்தவும்
  • ✅ உருப்படி வாழ்நாள் முழுவதும் நிலையான ID புலங்களைப் பயன்படுத்தவும்
  • ✅ trackBy செயல்பாடு எளிமையாகவும் வேகமாகவும் இருக்க வேண்டும்
  • ✅ பட்டியல் தரவு மாறும்போது குறியீட்டைப் பயன்படுத்துவதைத் தவிர்க்கவும்
அடுத்தது