如果com1和com2是兄弟姐妹，可以使用

@component({
  selector:'com1',
})
export class com1{
  function1(){...}
}

com2使用EventEmitter触发一个事件

@component({
  selector:'com2',
  template: `<button (click)="function2()">click</button>`
)
export class com2{
  @Output() myEvent = new EventEmitter();
  function2(){...
    this.myEvent.emit(null)
  }
}

在这里，父组件添加了一个事件绑定来监听myEvent事件，然后在发生此类事件时调用com1.function1()。 #com1是一个模板变量，允许从模板的其他地方引用这个元素。我们使用这个来使function1()成为com2的myEvent的事件处理程序:

@component({
  selector:'parent',
  template: `<com1 #com1></com1><com2 (myEvent)="com1.function1()"></com2>`
)
export class com2{
}

有关组件间通信的其他选项，请参见组件交互

我在父组件中使用触发器函数1(子函数)，如下所示:

组件1(孩子):

@Component(
  selector:'com1'
)
export class Component1{
  function1(){...}
}

组件2(父):

@Component(
  selector:'com2',
  template: `<button (click)="component1.function1()"
             <com1 #component1></com1>`
)
export class Component2{
}

#component1是一个模板变量。您可以用任何名称替换它。(例:# hello1)

在现实世界中，场景不是调用一个简单的函数，而是调用一个具有适当值的函数。让我们深入研究一下。这就是情境 用户需要从自己的组件中触发事件，并且在结束时还希望调用另一个组件的函数。假设这两个组件的服务文件是相同的

componentOne.html

    <button (click)="savePreviousWorkDetail()" data-dismiss="modal" class="btn submit-but" type="button">
          Submit
        </button>

当用户单击提交按钮时，他需要在自己的组件componentOne中调用savePreviousWorkDetail()。t，最后他还需要调用另一个组件的函数。为此，可以从componentOne调用服务类中的函数。ts，当它被调用时，componentTwo中的函数将被触发。

componentOne.ts

constructor(private httpservice: CommonServiceClass) {
  }

savePreviousWorkDetail() {
// Things to be Executed in this function

this.httpservice.callMyMethod("Niroshan");
}

commontServiceClass.ts

import {Injectable,EventEmitter} from '@angular/core';

@Injectable()
export class CommonServiceClass{

  invokeMyMethod = new EventEmitter();

  constructor(private http: HttpClient) {
  }

  callMyMethod(params: any = 'Niroshan') {
    this.invokeMyMethod.emit(params);
  }

}

下面是componentTwo，它有需要从componentOne调用的函数。在ngOnInit()中，我们必须订阅被调用的方法，因此当它触发methodtobeccalled()时将被调用

componentTwo.ts

import {Observable,Subscription} from 'rxjs';


export class ComponentTwo implements OnInit {

 constructor(private httpservice: CommonServiceClass) {
  }

myMethodSubs: Subscription;

ngOnInit() {
    
    this.myMethodSubs = this.httpservice.invokeMyMethod.subscribe(res => {
      console.log(res);
      this.methodToBeCalled();
    });
    
methodToBeCalled(){
//what needs to done
}
  }

}

如果com1和com2是兄弟姐妹，可以使用

@component({
  selector:'com1',
})
export class com1{
  function1(){...}
}

com2使用EventEmitter触发一个事件

@component({
  selector:'com2',
  template: `<button (click)="function2()">click</button>`
)
export class com2{
  @Output() myEvent = new EventEmitter();
  function2(){...
    this.myEvent.emit(null)
  }
}

在这里，父组件添加了一个事件绑定来监听myEvent事件，然后在发生此类事件时调用com1.function1()。 #com1是一个模板变量，允许从模板的其他地方引用这个元素。我们使用这个来使function1()成为com2的myEvent的事件处理程序:

@component({
  selector:'parent',
  template: `<com1 #com1></com1><com2 (myEvent)="com1.function1()"></com2>`
)
export class com2{
}

有关组件间通信的其他选项，请参见组件交互

使用Dataservice，我们可以从另一个组件调用该函数

Component1:我们调用该函数的组件

constructor( public bookmarkRoot: dataService ) { } 

onClick(){
     this.bookmarkRoot.callToggle.next( true );
}

dataservice.ts

import { Injectable } from '@angular/core';
@Injectable()
export class dataService {
     callToggle = new Subject();
}

Component2:包含函数的组件

constructor( public bookmarkRoot: dataService ) { 
  this.bookmarkRoot.callToggle.subscribe(( data ) => {
            this.closeDrawer();
        } )
} 

 closeDrawer() {
        console.log("this is called")
    }

对于不相关的组件，使用共享服务使用这个简单的方法。

/ / YourService

private subject = new Subject<any>();
sendClickEvent() {
  this.subject.next();
}
getClickEvent(): Observable<any>{ 
  return this.subject.asObservable();
}
}

//有按钮的组件

clickMe(){
this.YourServiceObj.sendClickEvent();
}

<button (click)="clickMe()">Click Me</button>

//你接收点击事件的组件

    this.sharedService.getClickEvent().subscribe(()=>{
    this.doWhateverYouWant();
    }

)