Composants angulaires : un guide complet pour les débutants

Créer des applications d'une seule page est un art et il existe de nombreux frameworks impressionnants parmi lesquels choisir. Angular est l'un des frameworks les plus intuitifs et les plus utilisés pour créer des applications Web et mobiles. Aujourd'hui, Angular 10 est sorti et il est doté de nombreuses fonctionnalités impressionnantes. Cependant, avant d’approfondir, vous devez maîtriser les composants.

Première chose : configurer les dépendances

Avant d'essayer Angular, vous devez vous assurer que vous avez installé avec succès les dépendances suivantes :

• Node.js
• CLI angulaire

Vous pouvez installer Angular CLI globalement à l'aide de NPM.

npm install -g @angular/cli

Vous pouvez désormais démarrer votre projet Angular de différentes manières :

• Créez-le manuellement
• Utilisation de la CLI angulaire
• Clonez et exécutez le projet depuis GitHub

Voici comment créer un nouveau projet à l'aide d'Angular CLI :

ng new my-project-name
cd my-project-name

C'est tout ! Maintenant, votre voyage angulaire a commencé. Dans cet article, nous allons construire une calculatrice simple pour additionner deux nombres à l'aide d'Angular.

Que sont les composants angulaires ?

Dans Angular, nous utilisons des directives. Il existe trois types de directives : les directives structurelles, les directives d'attribut et les directives de composants. Dans les prochaines sections, nous aborderons tout ce qui concerne les composants.

Les composants dans Angular sont les éléments que nous concevons et construisons pour le rendu des projets d'interface utilisateur. Ces éléments de l'interface utilisateur permettront aux utilisateurs d'interagir avec l'application et d'accéder à ses fonctionnalités.

À la fin de ce tutoriel, vous serez capable de créer des composants en Angular. De plus, vous comprendrez chaque étape du processus.

Les composants seront disponibles dans n'importe quel projet Angular dès le premier jour. D'une certaine manière, vous pouvez considérer n'importe quel projet Angular comme un arbre composé de nombreux composants connectés. Chaque composant a une fonctionnalité spécifique et un modèle qui la restitue. Un seul modèle peut être réutilisé dans plusieurs composants. Un ensemble de composants forme une application angulaire, qui est finalement visible dans le navigateur.

Un composant est comme une classe qui encapsule le comportement d'un élément et ses vues. Le comportement inclut les données chargées ou rendues et la manière dont l'utilisateur interagit avec elles, et ses vues sont des modèles qui définissent la manière dont les données sont présentées.

Construire un composant de calculatrice

Comprenons les composants en créant un composant angulaire pour ajouter deux nombres. Nous ne créerons pas les composants étape par étape dans ce didacticiel, mais vous pouvez trouver le code complet de cette application dans notre référentiel GitHub.

Définir les composants à l'aide de Componentdécorateurs

Component Les décorateurs sont utilisés pour définir des composants dans Angular. Les métadonnées qui définissent le composant sont les suivantes :

@Component({
  selector: 'calculator',
  templateUrl: './calculator.component.html',
  styleUrls: ['./calculator.component.css']
})
export class Calculator{
  
}

Dans la définition ci-dessus, selector 告诉应用程序该组件需要用于应用程序 HTML 的哪些元素。 templateUrl indique à l'application ce qu'elle peut restituer. Tout le reste dans le décorateur ci-dessus est facultatif.

Qu'est-ce qu'un sélecteur ?

selector est une propriété importante dans Angular. Cela aide l'application à déterminer où placer les composants. Le sélecteur est toujours une chaîne. Les sélecteurs peuvent être définis de trois manières différentes, chacune avec des cas d'utilisation uniques :

• selector: 'calculator' 当组件将被指定为 HTML 中的 <calculator></calculator> peut être utilisé lors de l'utilisation d'éléments.
• selector: '.calculator' 如果组件要用作 CSS 元素，则可以使用 en HTML.
• selector: '[calculator]' 当组件应该用作属性时可以使用，它看起来像 .

Les sélecteurs peuvent être simples ou complexes, mais la règle d'or est de garder vos sélecteurs aussi simples que possible.

Qu'est-ce qu'un modèle ?

templateUrl 用于标识组件将使用的模板。模板的路径应该是相对的。对于与组件源代码位于同一文件夹中的模板，您可以使用 templateUrl: './calculator.html'  或 templateUrl: 'calculator.html'.

N'utilisez pas d'URL absolues pour les fichiers HTML sur le serveur. Si vous faites cela, l'application ne sera pas compilée. Pourquoi? Angular 2+ précompile toujours le code et garantit que les modèles sont intégrés pendant le processus de construction.

Vous avez également la possibilité de remplacer par un modèle en ligne en utilisant l'option template 选项将 templateUrl. Ceci est utile dans les composants simples où le code TypeScript et le HTML ne doivent pas nécessairement se trouver dans des fichiers différents.

Cette démarche n'a aucun impact sur la candidature finale. Pourquoi? Quelle que soit la méthode, un seul bundle est généré.

Qu'est-ce que styleUrl ?

Les composants ne sont jamais simples ; ils sont toujours pleins de styles. styleUrl 属性的作用是帮助您包含特定于组件的 CSS。就像模板一样，您可以通过 styles Les propriétés sont utilisées pour vous aider à inclure du CSS spécifique au composant. Tout comme les modèles, vous pouvez utiliser des styles en ligne via l'attribut styles. Mais si le code comporte de nombreux styles, il doit être séparé en différents fichiers.

Notez que styleUrl prend toujours un tableau, vous pouvez donc ajouter plusieurs feuilles de style.

样式封装

Angular 组件始终鼓励样式隔离和完整封装。这意味着子组件或父组件中的样式不会影响 UI 层次结构中的其他组件。

为了控制样式封装，Angular 在 Component 装饰器中提供了一个名为 encapsulation 的属性。封装可以具有以下值之一：

• ViewEncapsulation.Emulated 是默认值。它创建填充样式来模拟影子根和 DOM。
• 如果您的浏览器本身支持影子 DOM，则 ViewEncapsulation.ShadowDom 是最快的。
• ViewEncapsulation.None，正如其名称所示，使用全局样式并避免任何形式的封装。

在我们的计算器组件中使用 encapsulation 属性的语法如下：

import { Component, ViewEncapsulation } from '@angular/core';
@Component({
  selector: 'calculator',
  templateUrl: './calculator.component.html',
  styleUrls: ['./calculator.component.css'],
  encapsulation: ViewEncapsulation.None
})
export class Calculator{}

在上面的示例中，我们选择了 ViewEncapsulation.None。这绝对是将通用样式应用于父组件和子组件的最佳方式。

Angular 组件和模块

在深入了解组件生命周期之前，让我们先看看组件和模块是如何相互链接的。我们的计算器应用程序的模块如下：

import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';

import { AppComponent } from './app.component';
import { CalcComponent } from './calc/calc.component'

@NgModule({
  declarations: [
    AppComponent,
    CalcComponent
  ],
  imports: [
    BrowserModule
  ],
  providers: [],
  bootstrap: [AppComponent]
})
export class AppModule { }

如果您创建组件，则必须将其包含为模块的一部分。

如果不将新创建的组件添加到模块中，则会出现错误。

要将组件添加到模块，必须首先导入它。首先，必须将导入的文件添加到 declarations 数组中。现在，该组件在整个应用程序中都是可见的，并且可以被其他组件使用。

让我们看看 @NgModule 指令中的每个数组代表什么：

• declarations 确保指令和组件在模块的范围内可用。 Angular CLI 具有一项功能，可以将指令和组件自动添加到模块中。
• imports 用于导入和访问其他模块。这允许开发人员在应用程序中包含第三方模块。
• 如果您的项目创建一个库或多个模块，则使用 exports 。如果组件未导出，则无法在其他地方使用。

组件生命周期

我们现在准备了解组件和指令的生命周期。请记住，每个组件都有一个生命周期，从创建到销毁。渲染组件的那一刻，该组件及其子组件的生命周期就开始了。

了解生命周期事件在 Angular 应用程序中非常有用，它可以帮助开发人员正确观察和响应事件。

以下是 Angular 组件的生命周期挂钩，按照调用每个挂钩的顺序排列。

1. 组件构造函数
2. ngOnChanges
3. ngOnInit
4. ngDoCheck
5. ngAfterContentInit
6. ngAfterContentChecked
7. ngAfterViewInit
8. ngAfterViewChecked
9. ngOnDestroy

创建组件时，会调用 构造函数 。接下来，按照上述顺序调用各种钩子。某些挂钩（例如 OnInit 和 AfterContentInit）将仅被调用一次。同时，只要组件中的内容发生更改，就会调用其他挂钩。最后，onDestroy 被调用一次。

上面的生命周期钩子有一个接口。要使用钩子，您应该实现该接口。通常，该接口带有函数，以 ng 开头。例如，如果要使用 ngOnInit 函数，则组件必须实现 OnInit 接口。以下是 Angular 组件中生命周期挂钩中常用接口和方法的快速摘要。该表再次根据实现时首先调用的方法进行排序。

界面	方法	目的
OnChanges	ngOnChanges	在构造函数之后以及输入值发生更改时调用。
OnInit	ngOnInit	仅调用一次。非常特定于组件或指令。它是从服务器加载数据的最佳位置。
DoCheck	ngDoCheck	当 Angular 无法自动检查更改或绑定时，使用此方法。它通知组件任何变化。
AfterContentInit	ngAfterContentInit	仅调用一次。它由组件初始化触发。
AfterContentChecked	ngAfterContentChecked	在组件内容的每次更改时调用。
AfterViewInit	ngAfterViewInit	一旦每个子组件都被初始化，就会调用这个生命周期钩子。视图可能没有完全渲染，但内部视图已经由 Angular 准备好了。
AfterViewChanged	ngAfterViewChecked	一旦每个子组件都经过验证和更新，就会调用此挂钩。
OnDestroy	ngOnDestroy	如果组件准备好从 UI 中删除或销毁，则会调用此挂钩。这是保留取消订阅和取消注册可观察对象或计时器的侦听器的好地方。

现在，如果您想将生命周期挂钩添加到我们的计算器组件中，它将显示如下：

import { Component, OnInit } from '@angular/core';
@Component({
  selector: 'calculator',
  templateUrl: './calculator.component.html',
  styleUrls: ['./calculator.component.css'],
  encapsulation: ViewEncapsulation.None
})
export class Calculator implements OnInit {
                                     
  constructor() {}

  ngOnInit(): void {
    console.log('Component - On Init');
  }

}

创建计算器组件

我们正在构建的计算器应用程序的 UI 如下所示。

这是我们将添加到组件模板中的 HTML：

<div class="row">
    <div class="col-12">
    	<input [(ngModel)]="number1" type="number" name="" placeholder="number">
	</div>
</div>
<div class="row">
	<div class="col-12">
		<input [(ngModel)]="number2" type="number" name="" placeholder="number">
	</div>
</div>
<button (click)="add()" class="button">
    Add 
</button>
<div class="result">
    <span>
		Result : {{result}}
	</span>
</div>

交互

UI呈现后，用户将对应用程序执行操作。现在，应用程序必须做出相应的响应。例如，当用户输入两个数字并单击添加时，我们的计算器必须进行添加。使用此功能连接输入框的最简单方法是通过 ngModel。在 HTML 模板文件中，每个输入都可以链接到 ngModel 变量。您可以在上面的 HTML 中看到，我们有许多 ngModel 属性将 HTML 元素链接到我们的 TypeScript 代码。这些变量将在计算器组件源代码中声明和使用。

让我们看看如何在计算器的 TypeScript 代码中使用 ngModel 变量。

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

@Component({
  selector: 'calc',
  templateUrl: 'calc.component.html',
  styleUrls: ['calc.component.css']
})
export class CalcComponent {
  public number1 : number;
  public number2 : number;
  public result : number;

  public add(){
      this.result = this.number1 + this.number2
  }
}

每次用户在输入框中输入值时，this.number1 和 this.number2 都会相应更新。为什么？ ngModel 用于捕获输入。

当用户点击添加按钮时，将调用 add 函数。如何？我们利用 (click) 控件将按钮连接到 add 方法。

当调用 add 时，this.result 根据 this.number1 和 this.number2 进行更新。一旦 this.result 更新，UI 也会更新。如何？ {{result}} 链接到 this.result。

这就结束了！

我希望本教程有用。现在，您应该了解 Angular 组件的基础知识。您刚刚了解了如何定义组件、利用各种生命周期挂钩，以及最终进行用户交互。这仅仅是个开始。 Angular 组件还有很多东西。

本教程中功能齐全的源代码可在 GitHub 上获取。看一看，并尝试创建您自己的 Angular 项目 - 这是最好的学习方式！

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!