Panduan Asas untuk Memahami Komponen dalam Sudut

Komponen sudut ialah asas aplikasi Sudut, menyediakan cara untuk membina bahagian modular, boleh guna semula antara muka pengguna. Dalam panduan ini, kami akan merangkumi asas komponen Sudut, daripada strukturnya kepada amalan terbaik. Sama ada anda baru menggunakan Angular atau mencari penyegar semula, artikel ini akan memberi anda pemahaman asas tentang komponen dalam Angular.

Apakah Komponen Sudut?

Dalam Angular, komponen ialah kelas yang mengawal sekeping antara muka pengguna (UI). Fikirkan tentang butang, tab, input, borang dan laci (sedikit pun UI sebenarnya). Setiap komponen adalah serba lengkap, terdiri daripada:

1. Templat HTML: Mentakrifkan reka letak dan struktur UI.
2. Gaya CSS: Menetapkan rupa dan gaya untuk komponen.
3. Kelas TypeScript: Mengandungi logik dan data untuk komponen.
4. Metadata: Menyediakan butiran konfigurasi untuk Sudut mengenali dan menggunakan komponen.

Komponen adalah penting untuk mencipta aplikasi modular, kerana setiap satu boleh mewakili bahagian tertentu halaman, seperti pengepala, bar sisi atau kad.

Struktur Asas Komponen Sudut

Komponen Sudut ditakrifkan menggunakan penghias @Component, yang mengkonfigurasinya dengan templat, gaya dan pemilih yang diperlukan. Berikut ialah contoh asas:

import { Component } from '@angular/core';

@Component({
  selector: 'app-example',
  templateUrl: './example.component.html',
  styleUrls: ['./example.component.css']
})
export class ExampleComponent {
  title: string = 'Hello, Angular!';

  getTitle() {
    return this.title;
  }
}

Dalam contoh ini:

• pemilih ialah teg HTML yang mewakili komponen.
• templateUrl menunjuk ke fail templat HTML.
• styleUrls merujuk kepada fail CSS komponen.
• Kelas ExampleComponent menyimpan data dan logik komponen.

Struktur Folder Komponen Biasa

Projek sudut biasanya menyusun komponen dengan fail berkaitannya dalam satu folder, dibuat secara automatik apabila menggunakan CLI Sudut. Struktur folder biasa untuk komponen termasuk:

• example.component.ts: Mentakrifkan kelas TypeScript.
• example.component.html: Mengandungi templat HTML.
• example.component.css: Memegang gaya komponen.
• example.component.spec.ts: Mengandungi ujian untuk komponen.

Kitaran Hayat Komponen

Komponen sudut mempunyai kitaran hayat dengan cangkuk yang membolehkan pembangun melakukan tindakan pada pelbagai peringkat. Cangkuk kitar hayat yang biasa digunakan termasuk:

• ngOnInit: Dipanggil selepas komponen dimulakan.
• ngOnChanges: Dicetuskan apabila sebarang sifat terikat data berubah.
• ngOnDestroy: Dipanggil sejurus sebelum Angular memusnahkan komponen.

Sebagai contoh, berikut ialah cara ngOnInit digunakan:

import { Component } from '@angular/core';

@Component({
  selector: 'app-example',
  templateUrl: './example.component.html',
  styleUrls: ['./example.component.css']
})
export class ExampleComponent {
  title: string = 'Hello, Angular!';

  getTitle() {
    return this.title;
  }
}

Cangkuk kitar hayat memberikan fleksibiliti, menjadikannya mudah untuk mengurus logik pada peringkat tertentu kitaran hayat komponen.

Komunikasi Antara Komponen

Dalam aplikasi dunia nyata, komponen selalunya perlu berinteraksi antara satu sama lain untuk berkongsi data atau mencetuskan tindakan. Angular menyediakan beberapa kaedah untuk komunikasi komponen:

1. @Input dan @Output

• @Input: Membenarkan komponen induk menghantar data kepada komponen anak.
• @Output: Membolehkan komponen anak menghantar acara kepada induknya.

Contoh:

import { Component, OnInit } from '@angular/core';

@Component({
  selector: 'app-lifecycle',
  template: '<p>Lifecycle example</p>',
})
export class LifecycleComponent implements OnInit {
  ngOnInit() {
    console.log('Component initialized!');
  }
}

// child.component.ts
import { Component, Input, Output, EventEmitter } from '@angular/core';

@Component({
  selector: 'app-child',
  template: `<button>Send Message</button>`,
})
export class ChildComponent {
  @Input() childMessage: string;
  @Output() messageEvent = new EventEmitter<string>();

  sendMessage() {
    this.messageEvent.emit('Message from child!');
  }
}
</string>

2. Komunikasi Berasaskan Perkhidmatan

Apabila komponen tidak berada dalam hubungan ibu bapa-anak, perkhidmatan Angular menawarkan cara yang mudah untuk berkongsi data dan logik. Perkhidmatan adalah tunggal secara lalai, bermakna hanya satu contoh wujud di seluruh apl.

<!-- parent.component.html -->
<app-child></app-child>

Menggunakan perkhidmatan dalam komponen yang berbeza:

import { Injectable } from '@angular/core';
import { BehaviorSubject } from 'rxjs';

@Injectable({
  providedIn: 'root'
})
export class SharedService {
  private messageSource = new BehaviorSubject<string>('Default Message');
  currentMessage = this.messageSource.asObservable();

  changeMessage(message: string) {
    this.messageSource.next(message);
  }
}
</string>

// component-one.ts
import { Component } from '@angular/core';
import { SharedService } from '../shared.service';

@Component({
  selector: 'app-component-one',
  template: `<button>Change Message</button>`,
})
export class ComponentOne {
  constructor(private sharedService: SharedService) {}

  changeMessage() {
    this.sharedService.changeMessage('Hello from Component One');
  }
}

Amalan Terbaik untuk Komponen Sudut

1. Tanggungjawab Tunggal: Pastikan setiap komponen mempunyai satu tanggungjawab untuk meningkatkan kebolehbacaan dan kebolehselenggaraan.
2. Modul Ciri: Susun komponen berkaitan dalam modul ciri, yang membantu dalam pemuatan malas.
3. Optimumkan Pengesanan Perubahan: Gunakan pengesanan perubahan OnPush untuk komponen yang tidak dikemas kini dengan kerap untuk meningkatkan prestasi.
4. Hadkan Penggunaan Perkhidmatan untuk Komunikasi: Walaupun perkhidmatan berharga untuk berkongsi data, terlalu bergantung padanya boleh membawa kepada kod yang diganding rapat. Gunakan @Input dan @Output untuk komunikasi ibu bapa-anak apabila boleh.
5. Ringkaskan Templat: Pastikan templat semudah mungkin, memindahkan logik kompleks ke dalam kelas komponen.

Kesimpulan

Komponen sudut adalah teras pembinaan aplikasi berskala dan modular. Dengan memahami struktur, kitaran hayat dan kaedah komunikasi mereka, anda boleh mencipta aplikasi yang cekap dan boleh diselenggara yang mudah difahami dan dibina.

Dalam artikel seterusnya, kami akan menyelami kitaran hayat komponen Angular dengan lebih terperinci, meneroka setiap cangkuk dan cara ia boleh digunakan untuk mengurus komponen dengan berkesan. Nantikan untuk melihat lebih mendalam ciri kitaran hayat berkuasa Angular!

Atas ialah kandungan terperinci Panduan Asas untuk Memahami Komponen dalam Sudut. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!