Angular PDF
Angular PDF
Angular PDF
Contenido
¿Por qué aprender Angular 7? ............................................................................................. 4
Aplicaciones de Angular 7..................................................................................................... 5
Audiencia ................................................................................................................................. 5
Prerrequisitos .......................................................................................................................... 5
Angular7 - Descripción general ............................................................................................ 6
Actualización angular a V7.................................................................................................... 6
CLI angular .............................................................................................................................. 6
Rendimiento de la aplicación ................................................................................................ 7
Material angular y CDK ......................................................................................................... 7
Desplazamiento virtual ................................................................................................... 7
Arrastrar y soltar .............................................................................................................. 8
Angular7 - Configuración del entorno ................................................................................ 8
Nodejs ...................................................................................................................................... 8
Angular7 - Configuración del proyecto ............................................................................ 11
Aplicación............................................................................................................................... 24
app.module.ts .................................................................................................................. 24
app.component.html...................................................................................................... 25
app.component.spec.ts ................................................................................................ 27
app.component.ts .......................................................................................................... 27
app-routing.module.ts................................................................................................... 27
Bienes ................................................................................................................................ 27
Ambiente........................................................................................................................... 27
favicon.ico ........................................................................................................................ 28
index.html ......................................................................................................................... 28
main.ts ............................................................................................................................... 28
polyfill.ts ........................................................................................................................... 29
styles.css .......................................................................................................................... 29
test.ts ................................................................................................................................. 29
tsconfig.app.json ............................................................................................................ 29
tsconfig.spec.json .......................................................................................................... 29
typings.d.ts ...................................................................................................................... 30
Angular7 - Componentes ..................................................................................................... 31
Angular7 - Módulos ............................................................................................................... 39
Declaration............................................................................................................................. 40
Import ................................................................................................................................ 40
Providers .......................................................................................................................... 40
Bootstrap .......................................................................................................................... 40
Angular7 - Data Binding ....................................................................................................... 40
(Enlace de datos) .................................................................................................................... 40
Ejemplo ............................................................................................................................. 42
Salida ................................................................................................................................. 43
Ejemplo ............................................................................................................................. 43
Angular7 - Enlace de eventos ............................................................................................. 46
Angular7 - Plantillas .............................................................................................................. 51
Angular7 - Directivas ............................................................................................................. 56
Directivas de componentes ......................................................................................... 56
Directivas estructurales................................................................................................ 56
Directivas de atributos .................................................................................................. 56
¿Cómo crear directivas personalizadas? ......................................................................... 56
Angular7 – Pipes(tuberías) .................................................................................................. 58
¿Cómo crear una tubería personalizada? ........................................................................ 61
Angular7 - Enrutamiento ...................................................................................................... 63
Inicio de componentes ......................................................................................................... 64
Componente Contáctenos ........................................................................................... 65
Angular7 - Servicios .............................................................................................................. 70
Angular7 - Cliente HTTP ....................................................................................................... 76
Angular7: indicaciones de la CLI ....................................................................................... 79
Comando para actualización angular ................................................................................ 79
Lista de comandos importantes angulares ....................................................................... 80
Angular7 - Formularios ......................................................................................................... 80
Formulario impulsado por plantilla ..................................................................................... 80
Modelo impulsado por la forma .......................................................................................... 83
Validación de formulario ...................................................................................................... 86
Angular7 - Materiales / CDK-Desplazamiento virtual .................................................... 90
Aplicaciones de Angular 7
Como se mencionó anteriormente, Angular 7 es uno de los lenguajes más
utilizados en la web. Voy a enumerar algunos de ellos aquí:
Comunidad admitida por Google : Google apoya activamente a Angular y su
desarrollo. Angular se usa en varias aplicaciones de Google.
Desarrollo basado en POJO : Angular objeto JavaScript plano simple muy utilizado
y ayuda a aprender Angular de una manera más fácil.
Interfaz de usuario declarativa : Angular utiliza HTML como lenguaje de
visualización y amplía su funcionalidad. Ayuda a manejar la diferencia entre la
interfaz de usuario y el código, y la interfaz de usuario está unida libremente con el
código.
Tipos de letra : Tipos de letra es un conjunto súper de JavaScript y es fácil de
depurar. Es altamente seguro y está orientado a objetos.
Estructura modular : el desarrollo angular es altamente modular, está basado en
componentes y es altamente mantenible.
Soporte multiplataforma : el código angular funciona bien en todas las plataformas
sin muchos cambios en el código.
Audiencia
Este tutorial está diseñado para programadores de software que desean
aprender los conceptos básicos de Angular 7 y sus conceptos de programación
de una manera simple y fácil. Este tutorial le dará suficiente comprensión sobre
las diversas funcionalidades de Angular 7 con ejemplos adecuados.
Prerrequisitos
Antes de continuar con este tutorial, debe tener una comprensión básica de
HTML, CSS, JavaScript, mecanografiado y modelo de objetos de documento
(DOM).
Actualización angular a V7
Angular 7 es una versión principal en la que en el marco de núcleo angular, CLI
angular, se actualizan los materiales angulares. En caso de que esté utilizando
Angular 5 o 6 y desee actualizar a Angular 7, a continuación se muestra el
comando que actualizará su aplicación a la versión reciente de Angular:
ng update @angular/cli @angular/core
CLI angular
Rendimiento de la aplicación
En Angular 7, se agrega un presupuesto de paquete en angular.json como se
muestra a continuación:
Nodejs
Npm
CLI angular
IDE para escribir su código
Nodejs
Para verificar si nodejs está instalado en su sistema, escriba node -v en la
terminal. Esto lo ayudará a ver la versión de nodejs actualmente instalada en su
sistema.
Nodejs tiene que ser mayor que 8.xo 10.x, y npm tiene que ser mayor que 5.6
o 6.4.
C:\>node
–v v10.15.1
Si no imprime nada, instale nodejs en su sistema. Para instalar nodejs, vaya a
la página de inicio, https://nodejs.org/en/download/ de nodejs e instale el
paquete según su sistema operativo.
La página de inicio de nodejs es la siguiente:
Escriba npm install –g @ angular / cli en su símbolo del sistema, para instalar
angular cli en su sistema. La instalación tardará un tiempo y una vez hecho esto,
puede verificar la versión con el siguiente comando:
ng version
Mostrará detalles de la versión de angular - cli, así como la versión de otros
paquetes como se muestra a continuación -
Una vez que haya instalado nodejs, npm también se instalará con él. Para
verificar la versión de npm, ejecute npm -v en la línea de comando como se
muestra a continuación:
Puede usar el nombre del proyecto que prefiera. Ejecutemos ahora el comando
anterior en la línea de comando.
Aquí, usamos el nombre del proyecto como angular7-app . Una vez que ejecute
el comando, le preguntará sobre el enrutamiento como se muestra a
continuación:
cd angular7-app
Usaremos IDE de Visual Studio Code para trabajar con Angular 7, puede usar
cualquier IDE, es decir, Atom, WebStorm, etc.
Para descargar Visual Studio Code, vaya a https://code.visualstudio.com/ y
haga clic en Descargar para Windows.
Una vez que ejecute url, http: // localhost: 4200 / en el navegador, se lo dirigirá
a la siguiente pantalla:
"@angular/animations": "~7.2.0",
"@angular/common": "~7.2.0",
"@angular/compiler": "~7.2.0",
"@angular/core": "~7.2.0",
"@angular/forms": "~7.2.0",
"@angular/platform-browser": "~7.2.0",
"@angular/platform-browser-dynamic": "~7.2.0",
"@angular/router": "~7.2.0",
"core-js": "^2.5.4",
"rxjs": "~6.3.3",
"tslib": "^1.9.0",
"zone.js": "~0.8.26"
En caso de que necesite agregar más bibliotecas, puede agregarlas aquí y
ejecutar el comando de instalación npm.
tsconfig.json : básicamente contiene las opciones del compilador necesarias
durante la compilación.
tslint.json : este es el archivo de configuración con reglas a tener en cuenta al
compilar.
La carpeta src / es la carpeta principal, que internamente tiene una estructura
de archivos diferente.
Aplicación
Contiene los archivos que se describen a continuación. Estos archivos se
instalan por angular-cli de forma predeterminada.
app.module.ts
Si abre el archivo, verá que el código hace referencia a diferentes bibliotecas,
que se importan. Angular-cli ha utilizado estas bibliotecas predeterminadas para
la importación: angular / core, plataforma-navegador.
Los nombres en sí explican el uso de las bibliotecas. Se importan y guardan en
variables como declaraciones, importaciones, proveedores y bootstrap.
Podemos ver que también se agrega app-routing.module . Esto se debe a que
habíamos seleccionado el enrutamiento al comienzo de la instalación. El
módulo es agregado por @ angular / cli.
A continuación se muestra la estructura del archivo:
@NgModule({
declarations: [
AppComponent
],
imports: [
BrowserModule,
AppRoutingModule
],
providers: [],
bootstrap: [AppComponent]
})
export class AppModule { }
@NgModule se importa desde @ angular / core y tiene un objeto con las
siguientes propiedades:
Declaraciones : en las declaraciones, se almacena la referencia a los
componentes. El componente de la aplicación es el componente
predeterminado que se crea cada vez que se inicia un nuevo
proyecto. Aprenderemos sobre la creación de nuevos componentes en una
sección diferente.
Importaciones : esto tendrá los módulos importados como se muestra
arriba. En la actualidad, BrowserModule es parte de las importaciones que se
importan desde @ angular / platform-browser. También hay un módulo de
enrutamiento agregado AppRoutingModule.
Proveedores : esto hará referencia a los servicios creados. El servicio se
discutirá en un capítulo posterior.
Bootstrap : hace referencia al componente predeterminado creado, es decir,
AppComponent.
app.component.css : puede escribir su CSS aquí. En este momento, hemos
agregado el color de fondo al div como se muestra a continuación.
La estructura del archivo es la siguiente:
.divdetails {
background-color: #ccc;
}
app.component.html
El código html estará disponible en este archivo.
La estructura del archivo es la siguiente:
ZXdCb3g9IjAgMCAyNTAgMjUwIj4KICAgIDxwYXRoIGZpbGw9IiNERDAwMzEiI
GQ9Ik0xMjUgMzBMMzEuOSA
2My4ybDE0LjIgMTIzLjFMMTI1IDIzMGw3OC45LTQzLjcgMTQuMi0xMjMuMXoi
IC8+CiAgICA8cGF0aCBma
WxsPSIjQzMwMDJGIiBkPSJNMTI1IDMwdjIyLjItLjFWMjMwbDc4LjktNDMuNy
AxNC4yLTEyMy4xTDEyNSA
zMHoiIC8+CiAgICA8cGF0aCAgZmlsbD0iI0ZGRkZGRiIgZD0iTTEyNSA1Mi4x
TDY2LjggMTgyLjZoMjEuN2
wxMS43LTI5LjJoNDkuNGwxMS43IDI5LjJIMTgzTDEyNSA1Mi4xem0xNyA4My4
zaC0zNGwxNy00MC45IDE3I
DQwLjl6IiAvPgogIDwvc3ZnPg=="7>
</div>
app.component.spec.ts
Estos son archivos generados automáticamente que contienen pruebas
unitarias para el componente fuente.
app.component.ts
La clase para el componente se define aquí. Puede hacer el procesamiento de
la estructura html en el archivo .ts. El procesamiento incluirá actividades como
conectarse a la base de datos, interactuar con otros componentes,
enrutamiento, servicios, etc.
La estructura del archivo es la siguiente:
import { Component } from '@angular/core';
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
export class AppComponent {
title = 'Angular 7';
}
app-routing.module.ts
Este archivo tratará con el enrutamiento requerido para su proyecto. Está
conectado con el módulo principal, es decir, app.module.ts.
La estructura del archivo es la siguiente:
import { NgModule } from '@angular/core';
import { Routes, RouterModule } from '@angular/router';
environment.prod.ts
environment.ts
Ambos archivos tienen detalles sobre si el archivo final debe compilarse en el
entorno de producción o en el entorno de desarrollo.
La estructura de archivos adicional de angular7-app / folder incluye lo siguiente:
favicon.ico
Este es un archivo que generalmente se encuentra en el directorio raíz de un
sitio web.
index.html
Este es el archivo que se muestra en el navegador.
<html lang = "en">
<head>
<meta charset = "utf-8"7gt;
<title>Angular7App</title>
<base href = "/">
<meta name = "viewport" content = "width=device-width,
initial-scale=1">
<link rel = "icon" type = "image/x-icon" href =
"favicon.ico">
</head>
<body>
<app-root></app-root>
</body>
</html>
El cuerpo tiene <app-root> </app-root> . Este es el selector que se utiliza en
el archivo app.component.ts y mostrará los detalles
del archivo app.component.html .
main.ts
main.ts es el archivo desde donde comenzamos el desarrollo de nuestro
proyecto. Comienza con la importación del módulo básico que necesitamos. En
este momento, si ve angular / core, angular / platform-browser-dynamic,
app.module y el entorno se importan de forma predeterminada durante la
instalación de angular-cli y la configuración del proyecto.
import { enableProdMode } from '@angular/core';
import { platformBrowserDynamic } from '@angular/platform-
browser-dynamic';
import { AppModule } from './app/app.module';
import { environment } from './environments/environment';
if (environment.production) {
enableProdMode();
}
platformBrowserDynamic().bootstrapModule(AppModule).catch(err
=> console.error(err));
PlatformBrowserDynamic (). BootstrapModule (AppModule) tiene la referencia
del módulo principal AppModule. Por lo tanto, cuando se ejecuta en el
navegador, el archivo se llama index.html. Index.html se refiere internamente a
main.ts que llama al módulo padre, es decir, AppModule cuando se ejecuta el
siguiente código:
platformBrowserDynamic().bootstrapModule(AppModule).catch(err
=> console.error(err));
Cuando se llama a AppModule, llama a app.module.ts, que luego llama a
AppComponent en función del bootstrap de la siguiente manera:
bootstrap: [AppComponent]
En app.component.ts , hay un selector: app-root que se usa en el archivo
index.html. Esto mostrará los contenidos presentes en app.component.html .
Lo siguiente se mostrará en el navegador:
polyfill.ts
Esto se utiliza principalmente para la compatibilidad con versiones anteriores.
styles.css
Este es el archivo de estilo requerido para el proyecto.
test.ts
Aquí, se manejarán los casos de prueba de unidad para probar el proyecto.
tsconfig.app.json
Esto se usa durante la compilación, tiene los detalles de configuración que
deben usarse para ejecutar la aplicación.
tsconfig.spec.json
Esto ayuda a mantener los detalles para las pruebas.
typings.d.ts
Se utiliza para gestionar la definición de Typecript.
La estructura final del archivo será la siguiente:
Angular7 - Componentes
La mayor parte del desarrollo con Angular 7 se realiza en los componentes. Los
componentes son básicamente clases que interactúan con el archivo .html del
componente, que se muestra en el navegador. Hemos visto la estructura de
archivos en uno de nuestros capítulos anteriores.
La estructura de archivos tiene el componente de la aplicación y consta de los
siguientes archivos:
app.component.css
app.component.html
app.component.spec.ts
app.component.ts
app.module.ts
Y si seleccionó el enrutamiento angular durante la configuración del proyecto,
los archivos relacionados con el enrutamiento también se agregarán y los
archivos son los siguientes:
app-routing.module.ts
Los archivos anteriores se crean por defecto cuando creamos un nuevo
proyecto usando el comando angular-cli.
Si abre el archivo app.module.ts , tiene algunas bibliotecas que se importan y
también un declarativo al que se le asigna el componente de la aplicación de la
siguiente manera:
import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';
import { AppRoutingModule } from './app-routing.module';
import { AppComponent } from './app.component';
@NgModule({
declarations: [
AppComponent
],
imports: [
BrowserModule,
AppRoutingModule
],
providers: [],
bootstrap: [AppComponent]
})
export class AppModule { }
Las declaraciones incluyen la variable AppComponent, que ya hemos
importado. Esto se convierte en el componente principal.
Ahora, angular-cli tiene un comando para crear su propio componente. Sin
embargo, el componente de la aplicación que se crea de manera
@Component({
// this is a declarator which starts with @ sign.
// The component word marked in bold needs to be the same.
selector: 'app-new-cmp', // selector to be used inside
.html file.
templateUrl: './new-cmp.component.html',
// reference to the html file created in the new
component.
styleUrls: ['./new-cmp.component.css'] // reference to the
style file.
})
export class NewCmpComponent implements OnInit {
constructor() { }
ngOnInit() { }
}
Si ve el archivo new-cmp.component.ts anterior, crea una nueva clase
llamada NewCmpComponent , que implementa OnInit en el que hay un
constructor y un método llamado ngOnInit (). ngOnInit se llama por defecto
cuando se ejecuta la clase.
Veamos cómo funciona el flujo. Ahora, el componente de la aplicación, que se
crea de manera predeterminada, se convierte en el componente
principal. Cualquier componente agregado más tarde se convierte en el
componente hijo.
Cuando pulsamos la URL en el navegador "http: // localhost: 4200 /" , primero
ejecuta el archivo index.html que se muestra a continuación:
<html lang = "en">
<head>
<meta charset = "utf-8">
<title>Angular7App</title>
<base href = "/">
<meta name = "viewport" content = "width = device-
width, initial-scale = 1">
<link rel = "icon" type = "image/x-icon" href =
"favicon.ico">
</head>
<body>
<app-root></app-root>
</body>
</html>
if (environment.production) {
enableProdMode();
}
platformBrowserDynamic().bootstrapModule(AppModule).catch(err
=> console.error(err));
AppModule se importa desde la aplicación del módulo principal principal, y lo
mismo se le da al módulo bootstrap, lo que hace que se cargue el módulo de
aplicación.
Veamos ahora el archivo app.module.ts :
import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';
import { AppRoutingModule } from './app-routing.module';
import { AppComponent } from './app.component';
import { NewCmpComponent } from './new-cmp/new-
cmp.component';
@NgModule({
declarations: [
AppComponent,
NewCmpComponent
],
imports: [
BrowserModule,
AppRoutingModule '
],
providers: [],
bootstrap: [AppComponent]
})
export class AppModule { }
Aquí, AppComponent es el nombre dado, es decir, la variable para almacenar
la referencia de app.component.ts y lo mismo se da al bootstrap. Veamos
ahora el archivo app.component.ts .
import { Component } from '@angular/core';
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
export class AppComponent {
title = 'Angular 7';
}
El núcleo angular se importa y se denomina Componente, y el mismo se usa en
el Declarador como:
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
En la referencia del declarador al selector, se proporcionan templateUrl y
styleUrl. El selector aquí no es más que la etiqueta que se coloca en el archivo
index.html que vimos anteriormente.
La clase AppComponent tiene una variable llamada título, que se muestra en el
navegador. @Component utiliza la templateUrl llamada app.component.html,
que es la siguiente:
<!--The content below is only a placeholder and can be
replaced.-->
<div style = "text-align:center">
<h1> Welcome to {{ title }}! </h1>
</div>
Solo tiene el código html y el título variable entre llaves. Se reemplaza con el
valor, que está presente en el archivo app.component.ts . Esto se llama
enlace. Discutiremos el concepto de vinculación en el capítulo siguiente.
Ahora que hemos creado un nuevo componente llamado new-cmp. Lo mismo
se incluye en el archivo app.module.ts , cuando se ejecuta el comando para
crear un nuevo componente.
app.module.ts tiene una referencia al nuevo componente creado.
Veamos ahora los nuevos archivos creados en new-cmp.
new-cmp.component.ts
import { Component, OnInit } from '@angular/core';
@Component({
selector: 'app-new-cmp',
templateUrl: './new-cmp.component.html',
styleUrls: ['./new-cmp.component.css']
})
export class NewCmpComponent implements OnInit {
constructor() { }
ngOnInit() { }
}
@Component({
selector: 'app-new-cmp',
templateUrl: './new-cmp.component.html',
styleUrls: ['./new-cmp.component.css']
})
export class NewCmpComponent implements OnInit {
constructor() { }
ngOnInit() { }
}
El selector, es decir, app-new-cmp , debe agregarse en app.component.html,
es decir, el padre principal creado de manera predeterminada de la siguiente
manera:
<!--The content below is only a placeholder and can be
replaced.-->
<div style = "text-align:center">
<h1>
Welcome to {{ title }}!
</h1>
</div>
<app-new-cmp7gt;</app-new-cmp>
Cuando se agrega la etiqueta <app-new-cmp> </app-new-cmp> , todo lo que
está presente en el archivo .html, es decir, new-cmp.component.html del nuevo
componente creado se mostrará en el navegador junto con los datos del
componente principal.
@Component({
selector: 'app-new-cmp',
templateUrl: './new-cmp.component.html',
styleUrls: ['./new-cmp.component.css']
})
export class NewCmpComponent implements OnInit {
newcomponent = "Entered in new component created";
constructor() { }
ngOnInit() { }
}
En la clase, hemos agregado una variable llamada newcomponent y el valor
es "Ingresado en el nuevo componente creado".
La variable anterior se agrega en el archivo new-cmp.component.html de la
siguiente manera:
<p>
{{newcomponent}}
</p>
<p>
new-cmp works!
</p>
Ahora, como hemos incluido el selector <app-new-cmp> </app-new-
cmp> en app.component.html, que es el .html del componente principal, el
contenido presente en new-cmp.component. El archivo html se muestra en el
navegador. También agregaremos algunos css para el nuevo componente en
el archivo new-cmp.component.css de la siguiente manera:
p {
color: blue;
font-size: 25px;
}
Por lo tanto, hemos agregado color azul y tamaño de fuente como 25px para las
etiquetas p.
La siguiente pantalla se mostrará en el navegador:
Angular7 - Módulos
Módulo en Angular se refiere a un lugar donde puede agrupar los componentes,
directivas, tuberías y servicios relacionados con la aplicación.
En caso de que esté desarrollando un sitio web, el encabezado, pie de página,
izquierda, centro y la sección derecha se convierten en parte de un módulo.
Para definir el módulo, podemos usar el NgModule. Cuando crea un nuevo
proyecto utilizando el comando Angular –cli, el ngmodule se crea en
el archivo app.module.ts de forma predeterminada y tiene el siguiente aspecto:
import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';
import { AppRoutingModule } from './app-routing.module';
import { AppComponent } from './app.component';
import { NewCmpComponent } from './new-cmp/new-
cmp.component';
@NgModule({
declarations: [
AppComponent,
NewCmpComponent
],
imports: [
BrowserModule,
AppRoutingModule
],
providers: [],
bootstrap: [AppComponent]
})
export class AppModule { }
El NgModule debe importarse de la siguiente manera:
import { NgModule } from '@angular/core';
La estructura para el ngmodule es como se muestra a continuación:
@NgModule({
declarations: [
AppComponent,
NewCmpComponent
],
imports: [
BrowserModule,
AppRoutingModule
],
providers: [],
bootstrap: [AppComponent]
})
Declaration
Es una matriz de componentes creados. Si se crea algún componente nuevo,
primero se importará y la referencia se incluirá en las declaraciones como se
muestra a continuación:
declarations: [
AppComponent,
NewCmpComponent
]
Import
Es una matriz de módulos necesarios para ser utilizados en la
aplicación. También puede ser utilizado por los componentes en la matriz
Declaración. Por ejemplo, en este momento en el @NgModule, vemos
importado el módulo del navegador. En caso de que su solicitud necesite
formularios, puede incluir el módulo con el siguiente código:
import { FormsModule } from '@angular/forms';
La importación en @NgModule será como la siguiente:
imports: [
BrowserModule,
FormsModule
]
Providers
Esto incluirá los servicios creados.
Bootstrap
Esto incluye el componente principal de la aplicación para comenzar la
ejecución.
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
export class AppComponent {
title = 'Angular 7';
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
export class AppComponent {
title = 'Angular 7';
<div> Months :
<select>
<option *ngFor = "let i of months">{{i}}</option>
</select>
</div>
<br/>
<div>
<span *ngIf = "isavailable">Condition is valid.</span>
//over here based on if condition the text condition is
valid is displayed.
//If the value of isavailable is set to false it will not
display the text.
</div>
Salida
<div> Months :
<select>
<option *ngFor = "let i of months">{{i}}</option>
</select>
</div>
<br/>
<div>
<span *ngIf = "isavailable; else condition1">Condition is
valid.</span>
<ng-template #condition1>Condition is invalid</ng-
template>
</div>
Si se usa con la condición else y la variable usada es condition1 . Lo mismo se
asigna como una identificación a la plantilla ng , y cuando la variable
disponible se establece en falso, se muestra el texto La condición
no es válida .
La siguiente captura de pantalla muestra la pantalla en el navegador:
<div> Months :
<select>
<option *ngFor="let i of months">{{i}}</option>
</select>
</div>
<br/>
<div>
<span *ngIf = "isavailable; then condition1 else
condition2">
Condition is valid.
</span>
<ng-template #condition1>Condition is valid</ng-template>
<ng-template #condition2>Condition is invalid</ng-
template>
</div>
Si la variable es verdadera, entonces condición1 , más condición2 . Ahora, se
crean dos plantillas con id # condition1 y # condition2 .
La visualización en el navegador es la siguiente:
<div> Months :
<select>
<option *ngFor = "let i of months">{{i}}</option>
</select>
</div>
<br/>
<div>
<span *ngIf = "isavailable; then condition1 else
condition2">
Condition is valid.
</span>
<ng-template #condition1>Condition is valid</ng-template>
<ng-template #condition2>Condition is invalid</ng-
template>
</div>
<button (click) = "myClickFunction($event)">
Click Me
</button>
En el archivo app.component.html , hemos definido un botón y le hemos
agregado una función usando el evento click.
La siguiente es la sintaxis para definir un botón y agregarle una función.
(click) = "myClickFunction($event)"
La función se define en: app.component.ts
import { Component } from '@angular/core';
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
export class AppComponent {
title = 'Angular 7';
<div> Months :
<select (change) = "changemonths($event)">
<option *ngFor = "let i of months">{{i}}</option>
</select>
</div>
<br/>
<div>
<span *ngIf = "isavailable; then condition1 else
condition2">
Condition is valid.
</span>
<ng-template #condition1>Condition is valid</ng-template>
Angular7 - Plantillas
Angular 7 usa <ng-template> como la etiqueta en lugar de <template> que se
usa en Angular2. <ng-template> ha estado en uso desde el lanzamiento de
Angular 4, y la versión anterior, es decir, Angular 2 usa <template> con el mismo
propósito. La razón por la que comenzó a usar <ng-template> en lugar de
<template> desde Angular 4 en adelante es porque hay un conflicto de nombre
entre la etiqueta <template> y la etiqueta estándar html <template>. Se
desaprobará por completo en el futuro. Este fue uno de los principales cambios
realizados en la versión Angular 4.
Ahora usemos la plantilla junto con la condición if else y veamos el resultado.
app.component.html
<!--The content below is only a placeholder and can be
replaced.-->
<div style = "text-align:center">
<h1>Welcome to {{title}}.</h1>
</div>
<div> Months :
<select (change) = "changemonths($event)" name = "month">
<option *ngFor = "let i of months">{{i}}</option>
</select>
</div>
<br/>
<div>
<span *ngIf = "isavailable;then condition1 else
condition2">
Condition is valid.
</span>
myClickFunction(event) {
//just added console.log which will display the event
details in browser on click of the button.
alert("Button is clicked");
console.log(event);
}
changemonths(event) {
alert("Changed month from the Dropdown");
}
}
La salida en el navegador es la siguiente:
<div> Months :
<select (change) = "changemonths($event)" name = "month">
<option *ngFor = "let i of months">{{i}}</option>
</select>
</div>
<br/>
<div>
<span *ngIf = "isavailable; else condition2">
Condition is valid.
</span>
<ng-template #condition1>Condition is valid from template
</ng-template>
<ng-template #condition2>Condition is invalid from
template</ng-template>
</div>
<button (click) = "myClickFunction($event)">Click Me</button>
Si eliminamos la condición de entonces , obtenemos el mensaje "La condición
es válida" en el navegador y la etiqueta span también está disponible en el
dom. Por ejemplo, en app.component.ts , hemos hecho que
la variable isavailable sea verdadera.
Angular7 - Directivas
Directivas en Angular es una clase js, que se declara como
@directive. Tenemos 3 directivas en angular. Las directivas se enumeran a
continuación:
Directivas de componentes
Estos forman la clase principal que tiene detalles de cómo se debe procesar,
instanciar y usar el componente en tiempo de ejecución.
Directivas estructurales
Una directiva de estructura básicamente trata con la manipulación de los
elementos dom. Las directivas estructurales tienen un signo * antes de la
directiva. Por ejemplo, * ngIf y * ngFor .
Directivas de atributos
Las directivas de atributos se ocupan de cambiar el aspecto y el comportamiento
del elemento dom. Puede crear sus propias directivas como se explica en la
siguiente sección.
@NgModule({
declarations: [
AppComponent,
NewCmpComponent,
ChangeTextDirective
],
imports: [
BrowserModule,
AppRoutingModule
],
providers: [],
bootstrap: [AppComponent]
})
export class AppModule { }
La clase ChangeTextDirective se incluye en las declaraciones en el archivo
anterior. La clase también se importa del archivo que figura a continuación:
change-text.directive
import { Directive } from '@angular/core';
@Directive({
selector: '[changeText]'
})
export class ChangeTextDirective {
constructor() { }
}
El archivo anterior tiene una directiva y también tiene una propiedad de
selector. Independientemente de lo que definamos en el selector, lo mismo
debe coincidir en la vista, donde asignamos la directiva personalizada.
En la vista app.component.html, agreguemos la directiva de la siguiente
manera:
<!--The content below is only a placeholder and can be
replaced.-->
<div style = "text-align:center">
<h1> Welcome to {{title}}. </h1>
</div>
<div style = "text-align:center">
<span changeText >Welcome to {{title}}.</span>
</div>
Escribiremos los cambios en el archivo change-text.directive.ts de la
siguiente manera:
change-text.directive.ts
import { Directive, ElementRef} from '@angular/core';
@Directive({
selector: '[changeText]'
})
Angular7 – Pipes(tuberías)
En este capítulo, discutiremos sobre Tuberías en Angular 7. Las tuberías se
llamaron anteriormente filtros en Angular1 y se llamaron tuberías desde
Angular2 en adelante.
El | El carácter se utiliza para transformar datos. La siguiente es la sintaxis para
el mismo:
{{ Welcome to Angular 7 | lowercase}}
Toma enteros, cadenas, matrices y fecha como entrada separada con | para
convertirse en el formato requerido y mostrar lo mismo en el navegador.
Consideremos algunos ejemplos usando tuberías. Aquí, queremos mostrar el
texto dado en mayúsculas. Esto se puede hacer usando tuberías de la siguiente
manera:
Lowercasepipe
Uppercasepipe
Datepipe
Currencypipe
Jsonpipe
Percentpipe
Decimalpipe
Slicepipe
Ya hemos visto las tuberías en minúsculas y mayúsculas. Veamos ahora cómo
funcionan las otras tuberías. La siguiente línea de código nos ayudará a definir
las variables requeridas en el archivo app.component.ts :
import { Component } from '@angular/core';
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
export class AppComponent {
title = 'Angular 7 Project!';
todaydate = new Date();
jsonval = {name:'Rox', age:'25', address:{a1:'Mumbai',
a2:'Karnataka'}};
months = ["Jan", "Feb", "Mar", "April", "May", "Jun",
"July", "Aug",
"Sept", "Oct", "Nov", "Dec"];
}
Usaremos las tuberías en el archivo app.component.html como se muestra a
continuación:
<!--The content below is only a placeholder and can be
replaced.-->
<div style = "width:100%;">
<div style = "width:40%;float:left;border:solid 1px
black;">
<h1>Uppercase Pipe</h1>
<b>{{title | uppercase}}</b>
<br/>
<h1>Lowercase Pipe</h1>
<b>{{title | lowercase}}</b>
<h1>Currency Pipe</h1>
<b>{{6589.23 | currency:"USD"}}</b>
<br/>
<b>{{6589.23 | currency:"USD":true}}</b>
// Boolean true is used to get the sign of the
currency.
<h1>Date pipe</h1>
<b>{{todaydate | date:'d/M/y'}}</b>
<br/>
<b>{{todaydate | date:'shortTime'}}</b>
<h1>Decimal Pipe</h1>
<b>{{ 454.78787814 | number: '3.4-4' }}</b>
// 3 is for main integer, 4 -4 are for integers to be
displayed.
</div>
</div>
Las siguientes capturas de pantalla muestran la salida de cada tubería:
@NgModule({
declarations: [
SqrtPipe,
AppComponent,
NewCmpComponent,
ChangeTextDirective
],
imports: [
BrowserModule,
AppRoutingModule
],
providers: [],
bootstrap: [AppComponent]
})
export class AppModule { }
Hemos creado la clase app.sqrt.ts. Tenemos que importar lo mismo
en app.module.ts y especificar la ruta del archivo. También debe incluirse en
las declaraciones como se muestra arriba.
Veamos ahora la llamada realizada a la tubería sqrt en
el archivo app.component.html .
<h1>Custom Pipe</h1>
<b>Square root of 25 is: {{25 | sqrt}}</b>
<br/>
<b>Square root of 729 is: {{729 | sqrt}}</b>
A continuación se muestra la salida:
Angular7 - Enrutamiento
Enrutar básicamente significa navegar entre páginas. Has visto muchos sitios
con enlaces que te dirigen a una nueva página. Esto se puede lograr mediante
el enrutamiento. Aquí las páginas a las que nos referimos estarán en forma de
componentes. Ya hemos visto cómo crear un componente. Ahora creemos un
componente y veamos cómo usar el enrutamiento con él.
Durante la configuración del proyecto, ya hemos incluido el módulo de
enrutamiento y el mismo está disponible en app.module.ts como se muestra a
continuación:
app.module.ts
import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';
import { AppRoutingModule } from './app-routing.module';
import { AppComponent } from './app.component';
import { NewCmpComponent } from './new-cmp/new-
cmp.component';
import { ChangeTextDirective } from './change-
text.directive';
import { SqrtPipe } from './app.sqrt';
@NgModule({
declarations: [
SqrtPipe,
AppComponent,
NewCmpComponent,
ChangeTextDirective
],
imports: [
BrowserModule,
AppRoutingModule
],
providers: [],
bootstrap: [AppComponent]
})
export class AppModule { }
AppRoutingModule se agrega como se muestra arriba y se incluye en la matriz
de importaciones.
Los detalles del archivo de app-routing.module se proporcionan a
continuación:
import { NgModule } from '@angular/core';
import { Routes, RouterModule } from '@angular/router';
Inicio de componentes
Primero, discutiremos sobre el hogar. La siguiente es la sintaxis para
Component Home:
ng g component home
C:\projectA7\angular7-app>ng g component home CREATE
src/app/home/home.component.html (23 bytes) CREATE
src/app/home/home.component.spec.ts (614 bytes) CREATE
src/app/home/home.component.ts (261 bytes) CREATE
src/app/home/home.component.css (0 bytes) UPDATE
@NgModule({
declarations: [
SqrtPipe,
AppComponent,
NewCmpComponent,
ChangeTextDirective,
HomeComponent,
ContactusComponent
],
imports: [
BrowserModule,
AppRoutingModule
],
providers: [],
bootstrap: [AppComponent]
})
export class AppModule { }
Ahora agreguemos los detalles de las rutas en app-routing.module .ts como
se muestra a continuación:
import { NgModule } from '@angular/core';
import { Routes, RouterModule } from '@angular/router';
@NgModule({
declarations: [
SqrtPipe,
AppComponent,
NewCmpComponent,
ChangeTextDirective,
RoutingComponent
],
imports: [
BrowserModule,
AppRoutingModule
],
providers: [],
bootstrap: [AppComponent]
})
export class AppModule { }
Así que ahora hemos terminado de definir las rutas. Necesitamos mostrar lo
mismo al usuario, así que agreguemos dos botones, Inicio y Contáctenos en
app.component.html y al hacer clic en los botones respectivos, mostrará la vista
de componentes dentro de la directiva <router-outlet> que he agregado en
add.component.html.
Cree el botón dentro de app.component.html y proporcione la ruta a las rutas
creadas.
app.component.html
<h1>Angular 7 Routing Demo</h1>
<nav>
<a routerLink = "/home">Home</a>
<a routerLink = "/contactus">Contact Us </a>
</nav>
<router-outlet></router-outlet>
En .html, agregamos enlaces de anclaje, Inicio y Contáctenos y usamos
routerLink para dar la ruta a las rutas que hemos creado en app-
routing.module.ts.
Probemos ahora lo mismo en el navegador:
Haga clic en el enlace Inicio para ver los detalles de los componentes de inicio
como se muestra a continuación:
Haga clic en Contáctenos para ver los detalles de sus componentes como se
muestra a continuación:
Angular7 - Servicios
Podríamos encontrarnos con una situación en la que necesitamos algún código
para usar en todas partes de la página. Por ejemplo, puede ser para una
conexión de datos que debe compartirse entre componentes. Esto se logra con
la ayuda de los Servicios. Con los servicios, podemos acceder a métodos y
propiedades a través de otros componentes en todo el proyecto.
Para crear un servicio, necesitamos utilizar la línea de comando como se
muestra a continuación:
ng g service myservice
C:\projectA7\angular7-app>ng g service myservice
CREATE src/app/myservice.service.spec.ts (348 bytes)
CREATE src/app/myservice.service.ts (138 bytes)
Los archivos creados en la carpeta de la aplicación son los siguientes:
Los siguientes son los archivos creados que se muestran en la parte inferior:
myservice.service.specs.ts y myservice.service.ts.
myservice.service.ts
import { Injectable } from '@angular/core';
@Injectable({
providedIn: 'root'
})
export class MyserviceService {
constructor() { }
}
Aquí, el módulo inyectable se importa desde @ angular / core. Contiene el
método @Injectable y una clase llamada MyserviceService. Crearemos nuestra
función de servicio en esta clase.
Antes de crear un nuevo servicio, es necesario incluir el servicio creado en las
principales matrices app.module.ts .
import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';
import { AppRoutingModule , RoutingComponent} from './app-
routing.module';
import { AppComponent } from './app.component';
import { NewCmpComponent } from './new-cmp/new-
cmp.component';
import { ChangeTextDirective } from './change-
text.directive';
import { SqrtPipe } from './app.sqrt';
import { MyserviceService } from './myservice.service';
@NgModule({
declarations: [
SqrtPipe,
AppComponent,
NewCmpComponent,
ChangeTextDirective,
RoutingComponent
],
imports: [
BrowserModule,
AppRoutingModule
],
providers: [MyserviceService],
bootstrap: [AppComponent]
})
export class AppModule { }
Hemos importado el Servicio con el nombre de la clase, y la misma clase se usa
en los proveedores. Ahora volvamos a la clase de servicio y creemos una
función de servicio.
En la clase de servicio, crearemos una función que mostrará la fecha de
hoy. Podemos usar la misma función en el componente principal principal
app.component.ts y también en el nuevo componente new-cmp.component.ts
que creamos en el capítulo anterior.
Veamos ahora cómo se ve la función en el servicio y cómo usarla en los
componentes.
import { Injectable } from '@angular/core';
@Injectable({
providedIn: 'root'
})
export class MyserviceService {
constructor() { }
showTodayDate() {
let ndate = new Date();
return ndate;
}
}
En el archivo de servicio anterior, hemos creado una
función showTodayDate . Ahora devolveremos la nueva Fecha ()
creada. Veamos cómo podemos acceder a esta función en la clase de
componente.
app.component.ts
import { Component } from '@angular/core';
import { MyserviceService } from './myservice.service';
@Component({ selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
export class AppComponent {
title = 'Angular 7 Project!';
todaydate;
constructor(private myservice: MyserviceService) {}
ngOnInit() {
this.todaydate = this.myservice.showTodayDate();
}
}
La función ngOnInit se llama por defecto en cualquier componente creado. La
fecha se obtiene del servicio como se muestra arriba. Para obtener más detalles
del servicio, primero debemos incluir el servicio en el archivo ts del componente.
Mostraremos la fecha en el archivo .html como se muestra a continuación:
app.component.html
{{todaydate}}
<app-new-cmp></app-new-cmp>
Veamos ahora cómo usar el servicio en el nuevo componente creado.
new-cmp.component.ts
import { Component, OnInit } from '@angular/core';
import { MyserviceService } from './../myservice.service';
@Component({
selector: 'app-new-cmp',
templateUrl: './new-cmp.component.html',
styleUrls: ['./new-cmp.component.css']
})
export class NewCmpComponent implements OnInit {
newcomponent = "Entered in new component created";
todaydate;
constructor(private myservice: MyserviceService) { }
ngOnInit() {
this.todaydate = this.myservice.showTodayDate();
}
}
En el nuevo componente que hemos creado, primero debemos importar el
servicio que queremos y acceder a los métodos y propiedades del
mismo. Verifique el código resaltado. todaydate se muestra en el componente
html de la siguiente manera:
new-cmp.component.html
<p>
{{newcomponent}}
</p>
<p>
Today's Date : {{todaydate}}
</p>
El selector del nuevo componente se utiliza en el archivo
app.component.html. El contenido del archivo html anterior se mostrará en el
navegador como se muestra a continuación:
console.log(this.myservice.serviceproperty);
this.myservice.serviceproperty = "component created";
// value is changed. this.componentproperty =
this.myservice.serviceproperty;
}
}
Ahora buscaremos la variable y trabajaremos en console.log. En la siguiente
línea, cambiaremos el valor de la variable a "componente creado". Haremos lo
mismo en new-cmp.component.ts.
import { Component, OnInit } from '@angular/core';
import { MyserviceService } from './../myservice.service';
@Component({
selector: 'app-new-cmp',
templateUrl: './new-cmp.component.html',
styleUrls: ['./new-cmp.component.css']
})
export class NewCmpComponent implements OnInit {
todaydate;
newcomponentproperty; newcomponent = "Entered in
newcomponent"; constructor(private myservice:
MyserviceService) {}
ngOnInit() {
this.todaydate = this.myservice.showTodayDate();
this.newcomponentproperty =
this.myservice.serviceproperty;
}
}
En el componente anterior, no estamos cambiando nada, sino asignando
directamente la propiedad a la propiedad del componente.
Ahora, cuando lo ejecute en el navegador, la propiedad del servicio cambiará
ya que su valor se cambia en app.component.ts y lo mismo se mostrará para
new-cmp.component.ts.
También verifique el valor en la consola antes de cambiarlo.
@NgModule({
declarations: [
SqrtPipe,
AppComponent,
NewCmpComponent,
ChangeTextDirective,
RoutingComponent
],
imports: [
BrowserModule,
AppRoutingModule,
HttpClientModule
],
providers: [MyserviceService],
bootstrap: [AppComponent]
})
export class AppModule { }
Si ve el código resaltado, hemos importado el HttpClientModule de @ angular
/ common / http y lo mismo también se agrega en la matriz de importaciones.
Obtendremos los datos del servidor utilizando el módulo httpclient declarado
anteriormente. Lo haremos dentro de un servicio que creamos en el capítulo
anterior y utilizaremos los datos dentro de los componentes que queramos.
myservice.service.ts
import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
@Injectable({
providedIn: 'root'
})
export class MyserviceService {
private finaldata = [];
private apiurl =
"http://jsonplaceholder.typicode.com/users";
constructor(private http: HttpClient) { }
getData() {
return this.http.get(this.apiurl);
}
}
Hay un método agregado llamado getData que devuelve los datos obtenidos
para la url dada.
El método getData se llama desde app.component.ts de la siguiente manera:
import { Component } from '@angular/core';
import { MyserviceService } from './myservice.service';
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
export class AppComponent {
1
Component
ng g componente nuevo componente
2
Directive
ng g directiva nueva directiva
3
Pipe
ng g pipe tubería nueva
4
Service
ng g service nuevo servicio
5
Módule
ng g módulo my-module
6
Test
ng prueba
7
Build
ng build --configuration = production // para el entorno de producción
ng build --configuration = puesta en escena // para indicar el entorno
Angular7 - Formularios
@NgModule({
declarations: [
SqrtPipe,
AppComponent,
NewCmpComponent,
ChangeTextDirective,
RoutingComponent
],
imports: [
BrowserModule,
AppRoutingModule,
HttpClientModule,
ScrollDispatchModule,
DragDropModule,
FormsModule
],
providers: [MyserviceService],
bootstrap: [AppComponent]
})
export class AppModule { }
Entonces, en app.module.ts , hemos importado el FormsModule y lo mismo
se agrega en la matriz de importaciones como se muestra en el código
resaltado.
Creemos ahora nuestro formulario en el archivo app.component.html .
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
export class AppComponent {
title = 'Angular 7 Project!';
constructor(private myservice: MyserviceService) { }
ngOnInit() { }
onClickSubmit(data) {
alert("Entered Email id : " + data.emailid);
}
}
En el archivo app.component.ts anterior, hemos definido la función
onClickSubmit. Cuando hace clic en el botón de envío del formulario, el control
pasará a la función anterior.
El css para el formulario de inicio de sesión se agrega en app.component.css -
input[type = text], input[type = password] {
width: 40%;
padding: 12px 20px;
margin: 8px 0;
display: inline-block;
border: 1px solid #B3A9A9;
box-sizing: border-box;
}
input[type = submit] {
padding: 12px 20px;
margin: 8px 0;
display: inline-block;
border: 1px solid #B3A9A9;
box-sizing: border-box;
}
Así se muestra el navegador:
@NgModule({
declarations: [
SqrtPipe,
AppComponent,
NewCmpComponent,
ChangeTextDirective,
RoutingComponent
],
imports: [
BrowserModule,
AppRoutingModule,
HttpClientModule,
ScrollDispatchModule,
DragDropModule,
ReactiveFormsModule
],
providers: [MyserviceService],
bootstrap: [AppComponent]
})
export class AppModule { }
En app.component.ts , necesitamos importar algunos módulos para el
formulario controlado por modelo. Por ejemplo, importe {FormGroup,
FormControl} desde ' @ angular / forms '.
import { Component } from '@angular/core';
import { MyserviceService } from './myservice.service';
import { FormGroup, FormControl } from '@angular/forms';
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
export class AppComponent {
title = 'Angular 7 Project!';
emailid;
formdata;
constructor(private myservice: MyserviceService) { }
ngOnInit() {
this.formdata = new FormGroup({
emailid: new FormControl("angular@gmail.com"),
passwd: new FormControl("abcd1234")
});
}
onClickSubmit(data) {this.emailid = data.emailid;}
}
Los datos de formulario variable se inicializan al comienzo de la clase y lo mismo
se inicializa con FormGroup como se muestra arriba. Las variables emailid y
passwd se inicializan con valores predeterminados que se mostrarán en el
formulario. Puede mantenerlo en blanco en caso de que lo desee.
Así es como se verán los valores en la forma UI.
Hemos utilizado formdata para inicializar los valores del formulario; necesitamos
usar el mismo en el formulario UI app.component.html .
<div>
<form [formGroup] = "formdata" (ngSubmit) =
"onClickSubmit(formdata.value)" >
<input type = "text" class = "fortextbox" name =
"emailid" placeholder = "emailid"
formControlName = "emailid">
<br/>
Validación de formulario
Analicemos ahora la validación de formularios utilizando el formulario basado
en modelos. Puede usar la validación de formulario incorporada o también usar
el enfoque de validación personalizado. Utilizaremos ambos enfoques en el
formulario. Continuaremos con el mismo ejemplo que creamos en una de
nuestras secciones anteriores. Con Angular 7, necesitamos
importar Validadores desde @ angular / formas como se muestra a
continuación:
import { FormGroup, FormControl, Validators} from
'@angular/forms'
Angular tiene validadores integrados como campo obligatorio , longitud
mínima , longitud máxima y patrón . Se debe acceder a ellos utilizando el
módulo Validadores.
Simplemente puede agregar validadores o una serie de validadores necesarios
para decirle a Angular si un campo en particular es obligatorio. Probemos ahora
lo mismo en uno de los cuadros de texto de entrada, es decir, ID de correo
electrónico. Para la identificación del correo electrónico, hemos agregado los
siguientes parámetros de validación:
Necesario
La coincidencia de patrones
Así es como se valida un código en app.component.ts .
import { Component } from '@angular/core';
import { FormGroup, FormControl, Validators} from
'@angular/forms';
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
export class AppComponent {
title = 'Angular 4 Project!';
todaydate;
componentproperty;
emailid;
formdata;
ngOnInit() {
this.formdata = new FormGroup({
emailid: new FormControl("", Validators.compose([
Validators.required,
Validators.pattern("[^ @]*@[^ @]*")
])),
passwd: new FormControl("")
});
}
onClickSubmit(data) {this.emailid = data.emailid;}
}
En Validators.compose , puede agregar la lista de cosas que desea validar en
el campo de entrada. En este momento, hemos agregado
los parámetros necesarios y los parámetros de coincidencia de
patrones para tomar solo correos electrónicos válidos.
En app.component.html , el botón enviar está deshabilitado si alguna de las
entradas del formulario no es válida. Esto se hace de la siguiente manera:
<div>
<form [formGroup] = "formdata" (ngSubmit) =
"onClickSubmit(formdata.value)">
<input type = "text" class = "fortextbox" name =
"emailid"
placeholder = "emailid" formControlName = "emailid">
<br/>
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
export class AppComponent {
title = 'Angular 7 Project!';
todaydate;
componentproperty;
emailid;
formdata;
ngOnInit() {
this.formdata = new FormGroup({
emailid: new FormControl("", Validators.compose([
Validators.required,
Validators.pattern("[^ @]*@[^ @]*")
])),
passwd: new FormControl("", this.passwordvalidation)
});
}
passwordvalidation(formcontrol) {
if (formcontrol.value.length < 5) {
return {"passwd" : true};
}
}
onClickSubmit(data) {this.emailid = data.emailid;}
}
En el ejemplo anterior, hemos creado una función de validación
de contraseña y la misma se utiliza en una sección anterior en formcontrol
- passwd: new FormControl ("", this.passwordvalidation) .
En la función que hemos creado, verificaremos si la longitud de los caracteres
ingresados es adecuada. Si los caracteres son menores de cinco, regresará con
passwd true como se muestra arriba - return {"passwd": true}; Si los caracteres
son más de cinco, lo considerará válido y se habilitará el inicio de sesión.
Veamos ahora cómo se muestra esto en el navegador:
@NgModule({
declarations: [
SqrtPipe,
AppComponent,
NewCmpComponent,
ChangeTextDirective,
RoutingComponent
],
imports: [
BrowserModule,
AppRoutingModule,
HttpClientModule,
ScrollDispatchModule
],
providers: [MyserviceService],
bootstrap: [AppComponent]
})
export class AppModule { }
En app.module.ts, hemos importado ScrollDispatchModule y lo mismo se
agrega a la matriz de importaciones como se muestra en el código anterior.
El siguiente paso es obtener los datos que se mostrarán en la
pantalla. Continuaremos usando el servicio que creamos en el último capítulo.
Obtendremos datos de la
URL, https://jsonplaceholder.typicode.com/photos , que tiene datos para
alrededor de 5000 imágenes. Obtendremos los datos y los mostraremos al
usuario utilizando el módulo de desplazamiento virtual.
Los detalles en la url, https://jsonplaceholder.typicode.com/photos son los
siguientes:
Son los datos json los que tienen url de imagen y url de miniatura. Mostraremos
la URL en miniatura a los usuarios.
El siguiente es el servicio que buscará datos:
myservice.service.ts
import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
@Injectable({
providedIn: 'root'
})
export class MyserviceService {
private finaldata = [];
private apiurl =
"https://jsonplaceholder.typicode.com/photos";
constructor(private http: HttpClient) { }
getData() {
return this.http.get(this.apiurl);
}
}
Llamaremos al servicio desde app.component.ts de la siguiente manera:
import { Component } from '@angular/core';
import { MyserviceService } from './myservice.service';
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
export class AppComponent {
title = 'Angular 7 Project!';
public albumdetails = [];
constructor(private myservice: MyserviceService) {}
ngOnInit() {
this.myservice.getData().subscribe((data) => {
this.albumdetails = Array.from(Object.keys(data),
k=>data[k]);
console.log(this.albumdetails);
});
}
}
Ahora la variable albumdetails tiene todos los datos de la API y el recuento
total es 5000.
Ahora que tenemos los datos listos para mostrarse, trabajemos dentro de
app.component.html para mostrar los datos.
Necesitamos agregar la etiqueta, <cdk-virtual-scroll-viewport> </cdk-virtual-
scroll-viewport> para trabajar con el módulo de desplazamiento virtual. La
etiqueta debe agregarse al archivo .html donde queremos que se muestren los
datos.
Aquí está el trabajo de <cdk-virtual-scroll-viewport> en app.component.html.
<h3>Angular 7 - Virtual Scrolling</h3>
<cdk-virtual-scroll-viewport [itemSize] = "20">
<table>
<thead>
<tr>
<td>ID</td>
<td>ThumbNail</td>
</tr>
</thead>
<tbody>
<tr *cdkVirtualFor = "let album of albumdetails">
<td>{{album.id}}</td>
<td>
@NgModule({
declarations: [
SqrtPipe,
AppComponent,
NewCmpComponent,
ChangeTextDirective,
RoutingComponent
],
imports: [
BrowserModule,
AppRoutingModule,
HttpClientModule,
ScrollDispatchModule,
DragDropModule
],
providers: [MyserviceService],
bootstrap: [AppComponent]
})
export class AppModule { }
DragDropModule se importa desde '@ angular / cdk / drag-drop' y el módulo
se agrega a la matriz de importación como se muestra arriba.
Utilizaremos los detalles de la
API (http://jsonplaceholder.typicode.com/users) para que se muestren en la
pantalla. Tenemos un servicio que obtendrá los datos de la API como se
muestra a continuación:
myservice.service.ts
import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
@Injectable({
providedIn: 'root'
})
export class MyserviceService {
private finaldata = [];
private apiurl =
"http://jsonplaceholder.typicode.com/users";
constructor(private http: HttpClient) { }
getData() {
return this.http.get(this.apiurl);
}
}
Una vez hecho esto, llame al servicio dentro de app.component.ts como se
muestra a continuación:
import { Component } from '@angular/core';
import { MyserviceService } from './myservice.service';
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
export class AppComponent {
title = 'Angular 7 Project!';
public personaldetails = [];
constructor(private myservice: MyserviceService) {}
ngOnInit() {
this.myservice.getData().subscribe((data) => {
this.personaldetails = Array.from(Object.keys(data),
k=>data[k]);
console.log(this.personaldetails);
});
}
}
Tenemos los datos requeridos disponibles en la variable personaldetails. Ahora
usemos lo mismo para mostrar al usuario como se muestra a continuación:
<h3>Angular 7 - Drag and Drop Module</h3>
<div>
<div *ngFor="let item of personaldetails; let i = index"
class="divlayout”>
{{item.name}}
</div >
</div>
Hemos agregado class = "divlayout" y los detalles de la clase están en
app.component.css.
.divlayout{
width: 40%;
background-color: #ccc;
margin-bottom: 5px;
padding: 10px 10px;
border: 3px solid #73AD21;
}
La siguiente pantalla se mostrará en el navegador:
</div >
</div&t;
Los resaltados son todas las propiedades requeridas para realizar arrastrar y
soltar. Cuando se registra en el navegador, le permite arrastrar el elemento. No
lo colocará en la lista y permanecerá como está cuando deje el puntero del
mouse.
Aquí permite arrastrar el elemento de la lista, pero una vez que deje el puntero
del mouse, se irá y se asentará en el mismo lugar. Para agregar la función de
soltar, necesitamos agregar el evento onDrop en app.component.ts como se
muestra a continuación:
Primero tenemos que importar los módulos dragdrap cdk como se muestra a
continuación:
import {CdkDragDrop, moveItemInArray, transferArrayItem}
from '@angular/cdk/drag-drop';
Aquí está el código completo en app.component.ts -
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
export class AppComponent {
title = 'Angular 7 Project!';
public personaldetails = [];
constructor(private myservice: MyserviceService) {}
ngOnInit() {
this.myservice.getData().subscribe((data) => {
this.personaldetails = Array.from(Object.keys(data),
k=>data[k]);
console.log(this.personaldetails);
});
}
onDrop(event: CdkDragDrop<string[]>) {
if (event.previousContainer === event.container) {
moveItemInArray(event.container.data,
event.previousIndex, event.currentIndex);
} else {
transferArrayItem(event.previousContainer.data,
event.container.data,
event.previousIndex,
event.currentIndex);
}
}
}
La función onDrop se encarga de soltar el elemento arrastrado en la posición
requerida.
Hace uso de moveItemInArray y transferArrayItem que hemos importado del
módulo cdk dragdrop.
Ahora veamos la demo nuevamente en el navegador.
Angular7 - Animaciones
Las animaciones agregan mucha interacción entre los elementos html. La
animación estaba disponible con Angular 2, desde Angular 4 en adelante, la
animación ya no forma parte de la biblioteca @ angular / core, sino que es un
paquete separado que debe importarse en app.module.ts.
Para empezar, necesitamos importar la biblioteca con la siguiente línea de
código:
import { BrowserAnimationsModule } from '@angular/platform-
browser/animations';
El BrowserAnimationsModule necesita ser añadido a la matriz de importación
en app.module.ts como se muestra a continuación -
import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';
import { AppRoutingModule , RoutingComponent} from './app-
routing.module';
import { AppComponent } from './app.component';
import { NewCmpComponent } from './new-cmp/new-
cmp.component';
import { ChangeTextDirective } from './change-
text.directive';
import { SqrtPipe } from './app.sqrt';
import { MyserviceService } from './myservice.service';
@NgModule({
declarations: [
SqrtPipe,
AppComponent,
NewCmpComponent,
ChangeTextDirective,
RoutingComponent
],
imports: [
BrowserModule,
AppRoutingModule,
HttpClientModule,
ScrollDispatchModule,
DragDropModule,
ReactiveFormsModule,
BrowserAnimationsModule
],
providers: [MyserviceService],
bootstrap: [AppComponent]
})
export class AppModule { }
En app.component.html , hemos agregado los elementos html, que deben ser
animados.
<div>
<button (click) = "animate()">Click Me</button>
<div [@myanimation] = "state" class = "rotate">
<img src = "assets/images/img.png" width = "100" height
= "100">
</div>
</div>
Para el div principal, hemos agregado un botón y un div con una imagen. Hay
un evento de clic para el que se llama la función animada. Y para el div, se
agrega la directiva @myanimation y se le da el valor como estado.
Veamos ahora app.component.ts donde se define la animación.
import { Component } from '@angular/core';
import { FormGroup, FormControl, Validators} from
'@angular/forms';
import { trigger, state, style, transition, animate } from
'@angular/animations';
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css'],
styles:[`
div {
margin: 0 auto;
text-align: center;
width:200px;
}
.rotate {
width:100px;
height:100px;
border:solid 1px red;
}
`],
animations: [
trigger('myanimation',[
state('smaller',style({
transform : 'translateY(100px)'
})),
state('larger',style({
transform : 'translateY(0px)'
})),
transition('smaller <=> larger',animate('300ms ease-
in'))
])
]
})
export class AppComponent {
state: string = "smaller";
animate() {
this.state= this.state == 'larger' ? 'smaller' :
'larger';
}
}
Tenemos que importar la función de animación que se utilizará en el archivo .ts
como se muestra arriba.
import { trigger, state, style, transition, animate } from
'@angular/animations';
Aquí hemos importado disparador, estado, estilo, transición y animación de @
angular / animaciones.
Ahora, agregaremos la propiedad de animaciones al decorador @Component
() -
animations: [
trigger('myanimation',[
state('smaller',style({
transform : 'translateY(100px)' })),
state('larger',style({
Angular7 - Materiales
Los materiales ofrecen muchos módulos integrados para su proyecto. Las
funciones como autocompletar, selector de fecha, control deslizante, menús,
"@angular/cdk": "^7.3.4",
"@angular/common": "~7.2.0",
"@angular/compiler": "~7.2.0",
"@angular/core": "~7.2.0",
"@angular/forms": "~7.2.0",
"@angular/material": "^7.3.4",
"@angular/platform-browser": "~7.2.0",
"@angular/platform-browser-dynamic": "~7.2.0",
"@angular/router": "~7.2.0",
"core-js": "^2.5.4",
"rxjs": "~6.3.3",
"tslib": "^1.9.0",
"zone.js": "~0.8.26"
},
"devDependencies": {
"@angular-devkit/build-angular": "~0.13.0",
"@angular/cli": "~7.3.2",
"@angular/compiler-cli": "~7.2.0",
"@angular/language-service": "~7.2.0",
"@types/node": "~8.9.4",
"@types/jasmine": "~2.8.8",
"@types/jasminewd2": "~2.0.3",
"codelyzer": "~4.5.0",
"jasmine-core": "~2.99.1",
"jasmine-spec-reporter": "~4.2.1",
"karma": "~3.1.1",
"karma-chrome-launcher": "~2.2.0",
"karma-coverage-istanbul-reporter": "~2.0.1",
"karma-jasmine": "~1.1.2",
"karma-jasmine-html-reporter": "^0.2.2",
"protractor": "~5.4.0",
"ts-node": "~7.0.0",
"tslint": "~5.11.0",
"typescript": "~3.2.2"
}
}
Hemos resaltado los paquetes que están instalados para trabajar con
materiales.
Ahora importaremos los módulos en el módulo principal - app.module.ts como
se muestra a continuación.
import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';
import { AppRoutingModule , RoutingComponent} from './app-
routing.module';
import { AppComponent } from './app.component';
import { NewCmpComponent } from './new-cmp/new-
cmp.component';
import { ChangeTextDirective } from './change-
text.directive';
import { SqrtPipe } from './app.sqrt';
@NgModule({
declarations: [
SqrtPipe,
AppComponent,
NewCmpComponent,
ChangeTextDirective,
RoutingComponent
],
imports: [
BrowserModule,
AppRoutingModule,
HttpClientModule,
ScrollDispatchModule,
DragDropModule,
ReactiveFormsModule,
BrowserAnimationsModule,
MatButtonModule,
MatMenuModule,
MatSidenavModule
],
providers: [MyserviceService],
bootstrap: [AppComponent]
})
export class AppModule { }
En el archivo anterior, hemos importado los siguientes módulos de @ angular /
materials .
import { MatButtonModule, MatMenuModule, MatSidenavModule }
from '@angular/material';
Y lo mismo se usa en la matriz de importaciones como se muestra a
continuación:
imports: [
BrowserModule,
AppRoutingModule,
HttpClientModule,
ScrollDispatchModule,
DragDropModule,
ReactiveFormsModule,
BrowserAnimationsModule,
MatButtonModule,
MatMenuModule,
MatSidenavModule
],
El app.component.ts es como se muestra a continuación:
import { Component } from '@angular/core';
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
export class AppComponent {
constructor() {}
}
Agreguemos ahora el soporte de material-css en styles.css .
@import "~@angular/material/prebuilt-themes/indigo-pink.css";
Ahora agreguemos materiales dentro de app.component.html
Menú
Para agregar menú, se usa <mat-menu> </mat-menu> . El archivo y los
elementos Guardar como se agregan al botón debajo del menú mat. Hay un
botón principal añadido Menú . La referencia de la misma se le da al <mat-
menu> usando [matMenuTriggerFor] = "menu" y usando el menú con # en
<mat-menu> .
app.component.html
<button mat-button [matMenuTriggerFor] = "menu">Menu</button>
<mat-menu #menu = "matMenu">
<button mat-menu-item> File </button>
<button mat-menu-item> Save As </button>
</mat-menu>
La siguiente imagen se muestra en el navegador:
SideNav
Para agregar sidenav, necesitamos <mat-sidenav-container> </mat-sidenav-
container> . <mat-sidenav> </mat-sidenav> se agrega como un elemento
secundario al contenedor. Hay otro div agregado, que activa el sidenav
usando (click) = "sidenav.open ()" .
app.component.html
<mat-sidenav-container class="example-container" fullscreen>
<mat-sidenav #sidenav class = "example-sidenav">
Angular 7
</mat-sidenav>
<div class = "example-sidenav-content">
<button type = "button" mat-button (click) =
"sidenav.open()">
Open sidenav
</button>
</div>
</mat-sidenav-container>
app.component.css
.example-container {
width: 500px;
height: 300px;
border: 1px solid rgba(0, 0, 0, 0.5);
}
.example-sidenav {
padding: 20px;
width: 150px;
font-size: 20px;
border: 1px solid rgba(0, 0, 0, 0.5);
background-color: #ccc;
color:white;
}
A continuación se muestra el menú y el menú lateral en el navegador:
Selector de fechas
Ahora agreguemos un selector de fechas utilizando materiales. Para agregar un
selector de fechas, necesitamos importar los módulos necesarios para mostrar
el selector de fechas.
@NgModule({
declarations: [
SqrtPipe,
AppComponent,
NewCmpComponent,
ChangeTextDirective,
RoutingComponent
],
imports: [
BrowserModule,
AppRoutingModule,
HttpClientModule,
ScrollDispatchModule,
DragDropModule,
ReactiveFormsModule,
BrowserAnimationsModule,
MatDatepickerModule,
MatInputModule,
MatNativeDateModule
],
providers: [MyserviceService],
bootstrap: [AppComponent]
})
export class AppModule { }
Aquí, hemos importado módulos como MatDatepickerModule, MatInputModule
y MatNativeDateModule.
Ahora, app.component.ts es como se muestra a continuación:
describe('AppComponent', () => {
beforeEach(async(() => {
TestBed.configureTestingModule({
imports: [
RouterTestingModule
],
declarations: [
AppComponent
],
}).compileComponents();
}));
it('should create the app', () => {
const fixture = TestBed.createComponent(AppComponent);
const app = fixture.debugElement.componentInstance;
expect(app).toBeTruthy();
});
it(`should have as title 'angular7-app'`, () => {
const fixture = TestBed.createComponent(AppComponent);
const app = fixture.debugElement.componentInstance;
expect(app.title).toEqual('angular7-app');
});
it('should render title in a h1 tag', () => {
const fixture = TestBed.createComponent(AppComponent);
fixture.detectChanges();
const compiled = fixture.debugElement.nativeElement;
expect(compiled.querySelector('h1').textContent).toContain(
'Welcome to angular7-app!');
})
});
app.component.ts
import { Component } from '@angular/core';
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
export class AppComponent {
title = 'angular7-app';
}
Ahora ejecutemos el comando para ver los casos de prueba en ejecución.
describe('AppComponent', () => {
beforeEach(async(() => {
TestBed.configureTestingModule({
imports: [
RouterTestingModule
],
declarations: [
AppComponent
],
}).compileComponents();
}));
it('should create the app', () => {
const fixture = TestBed.createComponent(AppComponent);
const app = fixture.debugElement.componentInstance;
expect(app).toBeTruthy();
});
it(`should have as title 'angular7-app'`, () => {
const fixture = TestBed.createComponent(AppComponent);
const app = fixture.debugElement.componentInstance;
expect(app.title).toEqual('Angular 7'); // change the
title from angular7-app to Angular 7
});
it('should render title in a h1 tag', () => {
const fixture = TestBed.createComponent(AppComponent);
fixture.detectChanges();
const compiled = fixture.debugElement.nativeElement;
expect(compiled.querySelector('h1').textContent).toContain(
'Welcome to angular7-app!');
});
});
En el archivo anterior, los casos de prueba verifican el título, Angular 7 . Pero
en app.component.ts, tenemos el título, angular7-app como se muestra a
continuación:
import { Component } from '@angular/core';
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
export class AppComponent {
title = 'angular7-app';
}
Aquí el caso de prueba fallará y a continuación se muestran los detalles en la
línea de comandos y el navegador.
En línea de comando
La siguiente pantalla se muestra en la línea de comando -
En el navegador
La siguiente pantalla se muestra en el navegador:
@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
export class AppComponent {
title = 'angular7-app';
}
El reemplazo del entorno de predeterminado a producción que estamos
tratando de hacer se define dentro de la sección de Reemplazos
de archivos angular.json de la siguiente manera:
"production": {
"fileReplacements": [
{
"replace": "src/environments/environment.ts",
"with": "src/environments/environment.prod.ts"
}
],
}
Cuando se ejecuta el comando para la compilación, el archivo se reemplaza
por src / assets / environment.prod.ts . La configuración adicional, como la
preparación o la prueba, se puede agregar aquí, como se muestra en el
siguiente ejemplo:
"configurations": {
"production": { ... },
"staging": {
"fileReplacements": [
{
"replace": "src/environments/environment.ts",
"with": "src/environments/environment.staging.ts"
}
]
}
}
Entonces, el comando para ejecutar la compilación es el siguiente:
ng build --configuration = production // for production
environmnet
ng build --configuration = staging // for stating enviroment
Ahora ejecutemos el comando de compilación para producción, el comando
creará una carpeta dist dentro de nuestro proyecto que tendrá los archivos
finales después de la compilación.
Los archivos finales se compilan dentro de la carpeta dist / que se puede alojar
en el servidor de producción en su extremo.
Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.
Alternative Proxies: