Llamar al método del componente secundario desde la clase principal - Angular

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

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

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 testpropiedad también?

Aug 16 '16 19:08 shammelburg

Creo que la forma más sencilla es utilizar Asunto. En el siguiente código de ejemplo, se notificará al niño cada vez que se llame a 'tellChild()'.

Padre.componente.ts

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

Padre.componente.html

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

Componentes.secundarios.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

May 10 '2018 20:05 user6779899

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

Padre.componente.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(); } 
}

Componentes.secundarios.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!"; 
  }
 }

Jul 04 '2017 14:07 Kaur A

Angular: llame al método del componente secundario en la plantilla del componente principal

Tienes ParentComponent y ChildComponent que se ven así.

padre.componente.html

padre.componente.ts

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

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

componente.niño.html

<p>
  This is child
</p>

componente.secundario.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 se sirve, se ve así:

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

Simplemente haz esto:

1. Asigne al selector app-child 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 que desea llamar) al evento de enfoque del elemento de entrada.

El resultado:

Jun 13 '2019 11:06 Hemant Ramphul