Angular 2
Direttive e componenti: @Input @Output

Sintassi

1. Associazione unidirezionale dal componente principale al componente nidificato: [propertyName]
2. Associazione unidirezionale dal componente nidificato al componente principale: (propertyName)
3. Associazione a due vie (nota anche come notazione della scatola di banane): [(propertyName)]

Esempio di input

@input è utile per legare i dati tra i componenti

Innanzitutto, importalo nel tuo componente

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

Quindi, aggiungi l'input come una proprietà della classe del componente

@Input() car: any;

Diciamo che il selettore del tuo componente è 'car-component', quando chiami il componente, aggiungi l'attributo 'car'

<car-component [car]="car"></car-component>

Ora la tua auto è accessibile come un attributo nel tuo oggetto (this.car)

Esempio completo:

1. car.entity.ts

    export class CarEntity {
       constructor(public brand : string, public color : string) {
       }  
    }

2. car.component.ts

    import { Component, Input } from '@angular/core';
    import {CarEntity} from "./car.entity";
    
    @Component({
        selector: 'car-component',
        template: require('./templates/car.html'),
    })
    
    export class CarComponent {
        @Input() car: CarEntity;
    
        constructor() {
            console.log('gros');
        }
    }

3. garage.component.ts

    import { Component } from '@angular/core';
    import {CarEntity} from "./car.entity";
    import {CarComponent} from "./car.component";
    
    @Component({
        selector: 'garage',
        template: require('./templates/garage.html'),
        directives: [CarComponent]
    })
    
    export class GarageComponent {
        public cars : Array<CarEntity>;
    
        constructor() {
            var carOne : CarEntity = new CarEntity('renault', 'blue');
            var carTwo : CarEntity = new CarEntity('fiat', 'green');
            var carThree : CarEntity = new CarEntity('citroen', 'yellow');
            this.cars = [carOne, carTwo, carThree];
        }
    }

4. garage.html

    <div *ngFor="let car of cars">
    <car-component [car]="car"></car-component>
    </div>

5. car.html

    <div>
        <span>{{ car.brand }}</span> |
        <span>{{ car.color }}</span>
    </div>

Angular2 @Input e @Output in un componente nidificato

Una direttiva Button che accetta un @Input() per specificare un limite di clic fino a quando il pulsante non viene disabilitato. Il componente principale può ascoltare un evento che verrà emesso quando viene raggiunto il limite di clic tramite @Output :

import { Component, Input, Output, EventEmitter } from '@angular/core';

@Component({
    selector: 'limited-button',
    template: `<button (click)="onClick()" 
                       [disabled]="disabled">
                   <ng-content></ng-content>
               </button>`,
    directives: []
})

export class LimitedButton {
    @Input() clickLimit: number;
    @Output() limitReached: EventEmitter<number> = new EventEmitter();

    disabled: boolean = false;

    private clickCount: number = 0;

    onClick() {
        this.clickCount++;
        if (this.clickCount === this.clickLimit) {
            this.disabled = true;
            this.limitReached.emit(this.clickCount);
        }
    }
}

Componente padre che utilizza la direttiva Button e avvisa un messaggio quando viene raggiunto il limite di clic:

import { Component } from '@angular/core';
import { LimitedButton } from './limited-button.component';

@Component({
    selector: 'my-parent-component',
    template: `<limited-button [clickLimit]="2"
                               (limitReached)="onLimitReached($event)">
                   You can only click me twice
               </limited-button>`,
    directives: [LimitedButton]
})

export class MyParentComponent {
    onLimitReached(clickCount: number) {
        alert('Button disabled after ' + clickCount + ' clicks.');
    }
}

Angular2 @Input con dati asincroni

A volte è necessario recuperare i dati in modo asincrono prima di passarli a un componente figlio da utilizzare. Se il componente figlio tenta di utilizzare i dati prima che sia stato ricevuto, genera un errore. È possibile utilizzare ngOnChanges per rilevare le modifiche nei componenti ' @Input s e attendere fino a quando non vengono definiti prima di agire su di essi.

Componente padre con chiamata asincrona a un endpoint

import { Component, OnChanges, OnInit } from '@angular/core';
import { Http, Response } from '@angular/http';
import { ChildComponent } from './child.component';

@Component ({
    selector : 'parent-component',
    template : `
        <child-component [data]="asyncData"></child-component>
    `
})
export class ParentComponent {
    
    asyncData : any;

    constructor(
        private _http : Http
    ){}

    ngOnInit () {
        this._http.get('some.url')
            .map(this.extractData)
            .subscribe(this.handleData)
            .catch(this.handleError);
    }

    extractData (res:Response) {
        let body = res.json();
        return body.data || { };
    }

    handleData (data:any) {
        this.asyncData = data;
    }

    handleError (error:any) {
        console.error(error);
    }
}

Componente figlio che ha dati asincroni come input

Questo componente figlio accetta i dati asincroni come input. Pertanto, prima di utilizzarlo, è necessario attendere che i dati esistano. Usiamo ngOnChanges che si attiva ogni volta che l'input di un componente cambia, controlla se i dati esistono e li usa se lo fa. Si noti che il modello per il bambino non mostrerà se una proprietà che si basa sui dati passati non è vera.

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

@Component ({
    selector : 'child-component',
    template : `
        <p *ngIf="doesDataExist">Hello child</p>
    `
})
export class ChildComponent {
    
    doesDataExist: boolean = false;

    @Input('data') data : any;

    // Runs whenever component @Inputs change
    ngOnChanges () {
        // Check if the data exists before using it
        if (this.data) {
            this.useData(data);
        {
    }

    // contrived example to assign data to reliesOnData    
    useData (data) {
        this.doesDataExist = true; 
    }
}