enviar - pasar parametros entre componentes angular 4

Llamar al método del componente hijo desde la clase padre-Angular

Question

He creado un componente hijo que tiene un método que quiero invocar.

Cuando invoco este método, solo console.log() línea console.log() , ¿no establecerá la propiedad de test ?

A continuación se muestra la aplicación angular de inicio rápido con mis cambios.

Padre

import { Component } from ''@angular/core'';
import { NotifyComponent }  from ''./notify.component'';

@Component({
    selector: ''my-app'',
    template:
    `
    <button (click)="submit()">Call Child Component Method</button>
    `
})
export class AppComponent {
    private notify: NotifyComponent;

    constructor() { 
      this.notify = new NotifyComponent();
    }

    submit(): void {
        // execute child component method
        notify.callMethod();
    }
}

Niño

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

@Component({
    selector: ''notify'',
    template: ''<h3>Notify {{test}}</h3>''
})
export class NotifyComponent implements OnInit {
   test:string; 
   constructor() { }

    ngOnInit() { }

    callMethod(): void {
        console.log(''successfully executed.'');
        this.test = ''Me'';
    }
}

¿Cómo puedo configurar la propiedad de test también?

Answer 1

¡Esto funcionó para mí! Para Angular 2, llame al método del componente hijo en el componente padre

Parent.component.ts

    import { Component, OnInit, ViewChild } from ''@angular/core'';
    import { ChildComponent } from ''../child/child''; 
    @Component({ 
               selector: ''parent-app'', 
               template: `<child-cmp></child-cmp>` 
              }) 
    export class parentComponent implements OnInit{ 
        @ViewChild(ChildComponent ) child: ChildComponent ; 

        ngOnInit() { 
           this.child.ChildTestCmp(); } 
}

Child.component.ts

import { Component } from ''@angular/core'';
@Component({ 
  selector: ''child-cmp'', 
  template: `<h2> Show Child Component</h2><br/><p> {{test }}</p> ` 
})
export class ChildComponent {
  test: string;
  ChildTestCmp() 
  { 
    this.test = "I am child component!"; 
  }
 }

Answer 2

Angular: método del componente secundario de llamada en la plantilla del componente primario

Tiene ParentComponent y ChildComponent que se ve así.

parent.component.html

parent.component.ts

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

@Component({
  selector: ''app-parent'',
  templateUrl: ''./parent.component.html'',
  styleUrls: [''./parent.component.css'']
})
export class ParentComponent {
  constructor() {
  }
}

child.component.html

<p>
  This is child
</p>

child.component.ts

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

@Component({
  selector: ''app-child'',
  templateUrl: ''./child.component.html'',
  styleUrls: [''./child.component.css'']
})
export class ChildComponent {
  constructor() {
  }

  doSomething() {
    console.log(''do something'');
  }
}

Cuando sirve, se ve así:

Cuando el usuario se concentra en el elemento de entrada de ParentComponent, desea llamar al método doSomething () de ChildComponent.

Simplemente haz esto:

1. Proporcione al selector de aplicación-hijo en parent.component.html un nombre de variable DOM (prefijo con # - hashtag) , en este caso lo llamamos appChild.
2. Asigne el valor de expresión (del método al que desea llamar) al evento de foco del elemento de entrada.

El resultado:

Answer 3

Creo que la manera más fácil es usar Asunto. En el siguiente código de ejemplo, se notificará al niño cada vez que se llame a ''tellChild''.

Parent.component.ts

import {Subject} from ''rxjs/Subject'';
...
export class ParentComp {
    changingValue: Subject<boolean> = new Subject();
    tellChild(){
    this.changingValue.next(true);
  }
}

Parent.component.html

<my-comp [changing]="changingValue"></my-comp>

Child.component.ts

...
export class ChildComp implements OnInit{
@Input() changing: Subject<boolean>;
ngOnInit(){
  this.changing.subscribe(v => { 
     console.log(''value is changing'', v);
  });
}

Muestra de trabajo en Stackblitz

Answer 4

La respuesta del usuario6779899 es clara y más genérica. Sin embargo, según la solicitud de Imad El Hitti, aquí se propone una solución ligera. Esto se puede usar cuando un componente hijo está estrechamente conectado a un solo padre.

Parent.component.ts

export class Notifier {
    valueChanged: (data: number) => void = (d: number) => { };
}

export class Parent {
    notifyObj = new Notifier();
    tellChild(newValue: number) {
        this.notifyObj.valueChanged(newValue); // inform child
    }
}

Parent.component.html

<my-child-comp [notify]="notifyObj"></my-child-comp>

Child.component.ts

export class ChildComp implements OnInit{
    @Input() notify = new Notifier(); // create object to satisfy typescript
    ngOnInit(){
      this.notify.valueChanged = (d: number) => {
            console.log(`Parent has notified changes to ${d}`);
            // do something with the new value 
        };
    }
 }

Answer 5

Puede hacerlo utilizando @ViewChild para obtener más información, consulte este link

Con selector de tipo

@Component({
  selector: ''child-cmp'',
  template: ''<p>child</p>''
})
class ChildCmp {
  doSomething() {}
}
@Component({
  selector: ''some-cmp'',
  template: ''<child-cmp></child-cmp>'',
  directives: [ChildCmp]
})
class SomeCmp {
  @ViewChild(ChildCmp) child:ChildCmp;
  ngAfterViewInit() {
    // child is set
    this.child.doSomething();
  }
}

Con selector de cuerda

@Component({
  selector: ''child-cmp'',
  template: ''<p>child</p>''
})
class ChildCmp {
  doSomething() {}
}
@Component({
  selector: ''some-cmp'',
  template: ''<child-cmp #child></child-cmp>'',
  directives: [ChildCmp]
})
class SomeCmp {
  @ViewChild(''child'') child:ChildCmp;
  ngAfterViewInit() {
    // child is set
    this.child.doSomething();
  }
}