搜索
您的当前位置:首页在Angular2中如何实现组件交互

在Angular2中如何实现组件交互

时间:2023-11-29 来源:红星娱乐

这篇文章主要介绍了Angular2实现组件交互的方法,结合实例形式总结分析了Angular2中组件交互的相关操作技巧与注意事项,需要的朋友可以参考下

本文实例讲述了Angular2实现组件交互的方法。分享给大家供大家参考,具体如下:

前言

在Angular开发中,我们经常会涉及到组件之间的交互,比如会引用自己部门开发的组件有时候,我们需要向引用的组件里面绑定一些数据,或者我们需要引用的子组件输出一些数据这时,我们就需要处理好组件之间的交互

组件交互的关键代码

父组件绑定数据到子组件

子组件

<h3>{{hero.name}} says:</h3>@Input() hero: Hero;

父组件

<hero-child [hero]="myhero" ></hero-child>myhero = "Mr.IQ";

这里子组件的@Input表示它需要hero这个实体,之后父组件引入子组件的时候,就得在子组件标签内写入hero,同时在自己的组件内为hero赋值就实现了父组件数据绑定到子组件

父组件监听子组件的事件

子组件

<button (click)="vote(true)" >Agree</button>@Output() onVoted = new EventEmitter<boolean>();vote(agreed: boolean) { this.onVoted.emit(agreed);}

父组件

<my-voter (myonVoted)="onVoted($event)"></my-voter>myonVoted(agreed: boolean) { agreed ? this.agreed++ : this.disagreed++; }

子组件的@Output表示它会用onVoted方法向父组件传递一个boolean值,父组件引入子组件之后,通过把子组件的方法绑定到自己的方法上,就可以达到监听子组件的效果

setter截听输入属性值的变化

子组件

<h3>"{{name}}"</h3>private _name = '';@Input()set name(name: string) { this._name = (name && name.trim()) || '<no name set>'; }get name(): string { return this._name; }

父组件

<name-child [name]="myname"></name-child>

父组件引用子组件之后,向子组件绑定数据,子组件通过set,get对父组件传过来的数据进行修改显示

父组件与子组件通过本地变量互动

子组件

seconds = 11;stop() { this.message = `Holding at T-${this.seconds} seconds`; }

父组件

<button (click)="timer.stop()">Stop</button><p class="seconds">{{timer.seconds}}</p><countdown-timer #timer></countdown-timer>

子组件定义了变量和方法,父组件引用子组件标签之后,通过在标签建立本地变量来代表子组件,然后通过变量就可以实现访问子组件的变量和方法

上面是我整理给大家的,希望今后会对大家有帮助。

相关文章:

在Angular中如何实现orderBy排序与模糊查询

vue vuex vue-rouert 权限路由(详细教程)

在javascript中如何获取键盘的keyCode

小编还为您整理了以下内容,可能对您也有帮助:

angular2 在不确定父组件的情况下,子组件怎么调用父组件的方法

1、页面中首先引入相关 js
<script src="js/react.js"></script>
<script src="js/react-dom.js"></script>
<script src="js/browser.min.js"></script>
<script src="js/jquery.min.js"></script>

2、此例子中:table组件为父组件,弹层组件为子组件
3、html代码
<div id="showHide"></div>
4、js代码

//列表组件
var PopShow = React.createClass({
getInitialState: function() {
return {
hideParent: false,
id:null
};
},

deleteClick:function(data){
console.log(this.state.hideParent);
this.setState({
hideParent:!this.state.hideParent,
id:data
});
},
cancelClick:function(){
this.setState({
hideParent: !this.state.hideParent
});
},
sureClick:function(){
this.setState({
hideParent: !this.state.hideParent
});
console.log(this.state.id);
//也可进行异步方法调用
},
render:function (){
return(
<div>
<table className="tab"><thead><tr><td>序号</td><td>名称</td><td>操作</td></tr></thead><tbody>
<tr><td>1</td><td>海南大学</td><td> <button onClick={this.deleteClick.bind(this,"11")}>删除</button></td></tr>
</tbody></table>
{this.state.hideParent ?<PopAlert callbackParentSure={this.sureClick} callbackParentCancel={this.cancelClick}/>:null}
</div>

);
}
});

ReactDOM.render(
<PopShow />,
document.getElementById('showHide')
);

//弹层组件
var PopAlert = React.createClass({
childCancel:function(){
this.props.callbackParentCancel();
},
childSure:function(){
this.props.callbackParentSure();
},
render: function() {
return <div className="pop"><div><h4>确定删除?</h4>
<button onClick={this.childCancel}>取消</button><button onClick={this.childSure}>确定</button>
</div></div>
}
});
5、页面效果

angular2 在不确定父组件的情况下,子组件怎么调用父组件的方法

1、页面中首先引入相关 js
<script src="js/react.js"></script>
<script src="js/react-dom.js"></script>
<script src="js/browser.min.js"></script>
<script src="js/jquery.min.js"></script>

2、此例子中:table组件为父组件,弹层组件为子组件
3、html代码
<div id="showHide"></div>
4、js代码

//列表组件
var PopShow = React.createClass({
getInitialState: function() {
return {
hideParent: false,
id:null
};
},

deleteClick:function(data){
console.log(this.state.hideParent);
this.setState({
hideParent:!this.state.hideParent,
id:data
});
},
cancelClick:function(){
this.setState({
hideParent: !this.state.hideParent
});
},
sureClick:function(){
this.setState({
hideParent: !this.state.hideParent
});
console.log(this.state.id);
//也可进行异步方法调用
},
render:function (){
return(
<div>
<table className="tab"><thead><tr><td>序号</td><td>名称</td><td>操作</td></tr></thead><tbody>
<tr><td>1</td><td>海南大学</td><td> <button onClick={this.deleteClick.bind(this,"11")}>删除</button></td></tr>
</tbody></table>
{this.state.hideParent ?<PopAlert callbackParentSure={this.sureClick} callbackParentCancel={this.cancelClick}/>:null}
</div>

);
}
});

ReactDOM.render(
<PopShow />,
document.getElementById('showHide')
);

//弹层组件
var PopAlert = React.createClass({
childCancel:function(){
this.props.callbackParentCancel();
},
childSure:function(){
this.props.callbackParentSure();
},
render: function() {
return <div className="pop"><div><h4>确定删除?</h4>
<button onClick={this.childCancel}>取消</button><button onClick={this.childSure}>确定</button>
</div></div>
}
});
5、页面效果

angular组件间共享数据的四种方式

组件间数据共享是angular必须要理解的基础概念,本文介绍四种不同的共享式。

这是最常用直观的数据共享方式。使用 @Input() 修饰符通过模板进行数据传递。

ViewChild 允许从一个组件注入到另一个,父组件可以访问子组件的参数和方法。但是,在视图初始化之前,该子项将不可用。这意味着我们需要实现AfterViewInit生命周期钩子来接收来自子生命周期的数据(这块我也不太理解)。

另外一种方式是通过在子组件里emit数据到父组件里。这种一般用在子组件进行按钮单击、表单提交或其他用户事件产生数据变化时触发的向父组件的数据共享。父组件需要建立一个函数来接收消息为变量赋值。

在下面的样例中我们定义一个带Output修饰符的messageEvent变量并实例化成一个emitter。然后创建一个名为sendMessage的函数调用emit事件发送消息数据。最后创建一个按钮触发这个函数。

父组件通过订阅(subscribe)到子组建的messageEvent输出,然后在子组件按下按钮后触发消息数据接收函数。

非直连组件间数据传值应该通过在共享服务层加入RxJS BeahaviorSubject。

在可以用RxJS其他Subject通过服务层共享数据时为什么要选择用BehaviorSubject?

1.订阅后会返回当前值 ,不需要调用 onnext

2.通过getValues()函数提取最后值做为raw data。

3.确保组件能收到最新的数据。

在以下服务中,创建一个私有BehaviorSubject提供消息数据。首先定义一个currentMessage变量存放observable数据流,然后创建一个组件里的函数来改变变量值。

父、子、兄弟组件在订阅后都会收到相同的变量值。把DataService注入到contructor中,然后订阅其中的currentMessage observable来接收信息。

组件中创建一个发送消息函数广播到其他组件中接收函数进行数据接收。

原文链接

Angular 兄弟组件怎么通信

这篇文章主要介绍了关于对angular的组件通信的解析,有着一定的参考价值,现在分享给大家,有需要的朋友可以参考一下

单页面应用组件通信有以下几种,这篇文章主要讲 Angular 通信

653298713-5b46f88e9188a_articlex[1].png

  1. 父组件 => 子组件

  2. 子组件 => 父组件

  3. 组件A = > 组件B

父组件 => 子组件子组件 => 父组件sibling => sibling
@input@output
setters (本质上还是@input)注入父组件
ngOnChanges() (不推荐使用)

局部变量

@ViewChild()

serviceserviceservice
Rxjs的ObservalbeRxjs的ObservalbeRxjs的Observalbe
localStorage,sessionStoragelocalStorage,sessionStoragelocalStorage,sessionStorage

上面图表总结了能用到通信方案,期中最后3种,是通用的,angular的组件之间都可以使用这3种,其中Rxjs是最最牛逼的用法,甩redux,promise,这些同样基于函数式的状态管理几条街,下面一一说来

父组件 => 子组件

@input,最常用的一种方式

@Component({ selector: 'app-parent',template: '<p>childText:<app-child [textContent] = "varString"></app-child></p>', styleUrls: ['./parent.component.css']})export class ParentComponent implements OnInit { varString: string; constructor() { } ngOnInit() { this.varString = '从父组件传过来的' ; }}
import { Component, OnInit, Input } from '@angular/core';@Component({ selector: 'app-child', template: '<h1>{{textContent}}</h1>', styleUrls: ['./child.component.css']})export class ChildComponent implements OnInit { @Input() public textContent: string ; constructor() { } ngOnInit() { }}

setter

setter 是拦截@input 属性,因为我们在组件通信的时候,常常需要对输入的属性处理下,就需要setter了,setter和getter常配套使用,稍微修改下上面的child.component.ts
child.component.ts

import { Component, OnInit, Input } from '@angular/core';@Component({ selector: 'app-child', template: '<h1>{{textContent}}</h1>', styleUrls: ['./child.component.css']})export class ChildComponent implements OnInit {_textContent:string; @Input() set textContent(text: string){ this._textContent = !text: "啥都没有给我" ? text ; } ; get textContent(){ return this._textContent; } constructor() { } ngOnInit() { }}

onChange

这个是通过angular生命周期钩子来检测,不推荐使用,要使用的话可以参angular文档

@ViewChild()

@ViewChild() 一般用在调用子组件非私有的方法

 import {Component, OnInit, ViewChild} from '@angular/core'; import {ViewChildChildComponent} from "../view-child-child/view-child-child.component"; @Component({ selector: 'app-parent', templateUrl: './parent.component.html', styleUrls: ['./parent.component.css'] }) export class ParentComponent implements OnInit { varString: string; @ViewChild(ViewChildChildComponent) viewChildChildComponent: ViewChildChildComponent; constructor() { } ngOnInit() { this.varString = '从父组件传过来的' ; } clickEvent(clickEvent: any) { console.log(clickEvent); this.viewChildChildComponent.myName(clickEvent.value); } }
 import { Component, OnInit } from '@angular/core'; @Component({ selector: 'app-view-child-child', templateUrl: './view-child-child.component.html', styleUrls: ['./view-child-child.component.css'] }) export class ViewChildChildComponent implements OnInit { constructor() { } name: string; myName(name: string) { console.log(name); this.name = name ; } ngOnInit() { } }

局部变量

局部变量和viewChild类似,只能用在html模板里,修改parent.component.html,通过#viewChild这个变量来表示子组件,就能调用子组件的方法了.

<p class="panel-body"> <input class="form-control" type="text" #viewChildInputName > <button class=" btn btn-primary" (click)="viewChild.myName(viewChildInputName.value)">局部变量传值</button> <app-view-child-child #viewChild></app-view-child-child> </p>

child 组件如下

@Component({ selector: 'app-view-child-child', templateUrl: './view-child-child.component.html', styleUrls: ['./view-child-child.component.css']})export class ViewChildChildComponent implements OnInit { constructor() { } name: string; myName(name: string) { console.log(name); this.name = name ; } ngOnInit() { }}

子组件 => 父组件

@output()

output这种常见的通信,本质是给子组件传入一个function,在子组件里执行完某些方法后,再执行传入的这个回调function,将值传给父组件

parent.component.ts@Component({ selector: 'app-child-to-parent', templateUrl: './parent.component.html', styleUrls: ['./parent.component.css']})export class ChildToParentComponent implements OnInit { childName: string; childNameForInject: string; constructor( ) { } ngOnInit() { } showChildName(name: string) { this.childName = name; }}

parent.component.html

<p class="panel-body"> <p>output方式 childText:{{childName}}</p> <br> <app-output-child (childNameEventEmitter)="showChildName($event)"></app-output-child></p>
 child.component.ts export class OutputChildComponent implements OnInit { // 传入的回调事件 @Output() public childNameEventEmitter: EventEmitter<any> = new EventEmitter(); constructor() { } ngOnInit() { } showMyName(value) { //这里就执行,父组件传入的函数 this.childNameEventEmitter.emit(value); }}

注入父组件

这个原理的原因是父,子组件本质生命周期是一样的

export class OutputChildComponent implements OnInit { // 注入父组件 constructor(private childToParentComponent: ChildToParentComponent) { } ngOnInit() { } showMyName(value) { this.childToParentComponent.childNameForInject = value; }}

sibling组件 => sibling组件

service

Rxjs

通过service通信

angular中service是单例的,所以三种通信类型都可以通过service,很多前端对单例理解的不是很清楚,本质就是
,你在某个module中注入service,所有这个modul的component都可以拿到这个service的属性,方法,是共享的,所以常在app.moudule.ts注入日志service,http拦截service,在子module注入的service,只能这个子module能共享,在component注入的service,就只能子的component的能拿到service,下面以注入到app.module.ts,的service来演示

user.service.ts@Injectable()export class UserService { age: number; userName: string; constructor() { }}app.module.ts@NgModule({ declarations: [ AppComponent, SiblingAComponent, SiblingBComponent ], imports: [ BrowserModule ], providers: [UserService], bootstrap: [AppComponent]})export class AppModule { }SiblingBComponent.ts@Component({ selector: 'app-sibling-b', templateUrl: './sibling-b.component.html', styleUrls: ['./sibling-b.component.css']})export class SiblingBComponent implements OnInit { constructor(private userService: UserService) { this.userService.userName = "王二"; } ngOnInit() { }}SiblingAComponent.ts@Component({ selector: 'app-sibling-a', templateUrl: './sibling-a.component.html', styleUrls: ['./sibling-a.component.css']})export class SiblingAComponent implements OnInit { userName: string; constructor(private userService: UserService) { } ngOnInit() { this.userName = this.userService.userName; }}

通过Rx.js通信

这个是最牛逼的,基于订阅发布的这种流文件处理,一旦订阅,发布的源头发生改变,订阅者就能拿到这个变化;这样说不是很好理解,简单解释就是,b.js,c.js,d.js订阅了a.js里某个值变化,b.js,c.js,d.js立马获取到这个变化的,但是a.js并没有主动调用b.js,c.js,d.js这些里面的方法,举个简单的例子,每个页面在处理ajax请求的时候,都有一弹出的提示信息,一般我会在
组件的template中中放一个提示框的组件,这样很繁琐每个组件都要来一次,如果基于Rx.js,就可以在app.component.ts中放这个提示组件,然后app.component.ts订阅公共的service,就比较省事了,代码如下
首先搞一个alset.service.ts

import {Injectable} from "@angular/core";import {Subject} from "rxjs/Subject";@Injectable()export class AlertService { private messageSu = new Subject<string>(); // messageObserve = this.messageSu.asObservable(); private setMessage(message: string) { this.messageSu.next(message); } public success(message: string, callback?: Function) { this.setMessage(message); callback(); }}

sibling-a.component.ts

@Component({ selector: 'app-sibling-a', templateUrl: './sibling-a.component.html', styleUrls: ['./sibling-a.component.css']})export class SiblingAComponent implements OnInit { userName: string; constructor(private userService: UserService, private alertService: AlertService) { } ngOnInit() { this.userName = this.userService.userName; // 改变alertService的信息源 this.alertService.success("初始化成功"); }}

app.component.ts

@Component({ selector: 'app-root', templateUrl: './app.component.html', styleUrls: ['./app.component.css']})export class AppComponent { title = 'app'; message: string; constructor(private alertService: AlertService) { //订阅alertServcie的message服务 this.alertService.messageObserve.subscribe((res: any) => { this.message = res; }); }}

这样订阅者就能动态的跟着发布源变化

总结:

Angular 兄弟组件怎么通信

这篇文章主要介绍了关于对angular的组件通信的解析,有着一定的参考价值,现在分享给大家,有需要的朋友可以参考一下

单页面应用组件通信有以下几种,这篇文章主要讲 Angular 通信

653298713-5b46f88e9188a_articlex[1].png

  1. 父组件 => 子组件

  2. 子组件 => 父组件

  3. 组件A = > 组件B

父组件 => 子组件子组件 => 父组件sibling => sibling
@input@output
setters (本质上还是@input)注入父组件
ngOnChanges() (不推荐使用)

局部变量

@ViewChild()

serviceserviceservice
Rxjs的ObservalbeRxjs的ObservalbeRxjs的Observalbe
localStorage,sessionStoragelocalStorage,sessionStoragelocalStorage,sessionStorage

上面图表总结了能用到通信方案,期中最后3种,是通用的,angular的组件之间都可以使用这3种,其中Rxjs是最最牛逼的用法,甩redux,promise,这些同样基于函数式的状态管理几条街,下面一一说来

父组件 => 子组件

@input,最常用的一种方式

@Component({ selector: 'app-parent',template: '<p>childText:<app-child [textContent] = "varString"></app-child></p>', styleUrls: ['./parent.component.css']})export class ParentComponent implements OnInit { varString: string; constructor() { } ngOnInit() { this.varString = '从父组件传过来的' ; }}
import { Component, OnInit, Input } from '@angular/core';@Component({ selector: 'app-child', template: '<h1>{{textContent}}</h1>', styleUrls: ['./child.component.css']})export class ChildComponent implements OnInit { @Input() public textContent: string ; constructor() { } ngOnInit() { }}

setter

setter 是拦截@input 属性,因为我们在组件通信的时候,常常需要对输入的属性处理下,就需要setter了,setter和getter常配套使用,稍微修改下上面的child.component.ts
child.component.ts

import { Component, OnInit, Input } from '@angular/core';@Component({ selector: 'app-child', template: '<h1>{{textContent}}</h1>', styleUrls: ['./child.component.css']})export class ChildComponent implements OnInit {_textContent:string; @Input() set textContent(text: string){ this._textContent = !text: "啥都没有给我" ? text ; } ; get textContent(){ return this._textContent; } constructor() { } ngOnInit() { }}

onChange

这个是通过angular生命周期钩子来检测,不推荐使用,要使用的话可以参angular文档

@ViewChild()

@ViewChild() 一般用在调用子组件非私有的方法

 import {Component, OnInit, ViewChild} from '@angular/core'; import {ViewChildChildComponent} from "../view-child-child/view-child-child.component"; @Component({ selector: 'app-parent', templateUrl: './parent.component.html', styleUrls: ['./parent.component.css'] }) export class ParentComponent implements OnInit { varString: string; @ViewChild(ViewChildChildComponent) viewChildChildComponent: ViewChildChildComponent; constructor() { } ngOnInit() { this.varString = '从父组件传过来的' ; } clickEvent(clickEvent: any) { console.log(clickEvent); this.viewChildChildComponent.myName(clickEvent.value); } }
 import { Component, OnInit } from '@angular/core'; @Component({ selector: 'app-view-child-child', templateUrl: './view-child-child.component.html', styleUrls: ['./view-child-child.component.css'] }) export class ViewChildChildComponent implements OnInit { constructor() { } name: string; myName(name: string) { console.log(name); this.name = name ; } ngOnInit() { } }

局部变量

局部变量和viewChild类似,只能用在html模板里,修改parent.component.html,通过#viewChild这个变量来表示子组件,就能调用子组件的方法了.

<p class="panel-body"> <input class="form-control" type="text" #viewChildInputName > <button class=" btn btn-primary" (click)="viewChild.myName(viewChildInputName.value)">局部变量传值</button> <app-view-child-child #viewChild></app-view-child-child> </p>

child 组件如下

@Component({ selector: 'app-view-child-child', templateUrl: './view-child-child.component.html', styleUrls: ['./view-child-child.component.css']})export class ViewChildChildComponent implements OnInit { constructor() { } name: string; myName(name: string) { console.log(name); this.name = name ; } ngOnInit() { }}

子组件 => 父组件

@output()

output这种常见的通信,本质是给子组件传入一个function,在子组件里执行完某些方法后,再执行传入的这个回调function,将值传给父组件

parent.component.ts@Component({ selector: 'app-child-to-parent', templateUrl: './parent.component.html', styleUrls: ['./parent.component.css']})export class ChildToParentComponent implements OnInit { childName: string; childNameForInject: string; constructor( ) { } ngOnInit() { } showChildName(name: string) { this.childName = name; }}

parent.component.html

<p class="panel-body"> <p>output方式 childText:{{childName}}</p> <br> <app-output-child (childNameEventEmitter)="showChildName($event)"></app-output-child></p>
 child.component.ts export class OutputChildComponent implements OnInit { // 传入的回调事件 @Output() public childNameEventEmitter: EventEmitter<any> = new EventEmitter(); constructor() { } ngOnInit() { } showMyName(value) { //这里就执行,父组件传入的函数 this.childNameEventEmitter.emit(value); }}

注入父组件

这个原理的原因是父,子组件本质生命周期是一样的

export class OutputChildComponent implements OnInit { // 注入父组件 constructor(private childToParentComponent: ChildToParentComponent) { } ngOnInit() { } showMyName(value) { this.childToParentComponent.childNameForInject = value; }}

sibling组件 => sibling组件

service

Rxjs

通过service通信

angular中service是单例的,所以三种通信类型都可以通过service,很多前端对单例理解的不是很清楚,本质就是
,你在某个module中注入service,所有这个modul的component都可以拿到这个service的属性,方法,是共享的,所以常在app.moudule.ts注入日志service,http拦截service,在子module注入的service,只能这个子module能共享,在component注入的service,就只能子的component的能拿到service,下面以注入到app.module.ts,的service来演示

user.service.ts@Injectable()export class UserService { age: number; userName: string; constructor() { }}app.module.ts@NgModule({ declarations: [ AppComponent, SiblingAComponent, SiblingBComponent ], imports: [ BrowserModule ], providers: [UserService], bootstrap: [AppComponent]})export class AppModule { }SiblingBComponent.ts@Component({ selector: 'app-sibling-b', templateUrl: './sibling-b.component.html', styleUrls: ['./sibling-b.component.css']})export class SiblingBComponent implements OnInit { constructor(private userService: UserService) { this.userService.userName = "王二"; } ngOnInit() { }}SiblingAComponent.ts@Component({ selector: 'app-sibling-a', templateUrl: './sibling-a.component.html', styleUrls: ['./sibling-a.component.css']})export class SiblingAComponent implements OnInit { userName: string; constructor(private userService: UserService) { } ngOnInit() { this.userName = this.userService.userName; }}

通过Rx.js通信

这个是最牛逼的,基于订阅发布的这种流文件处理,一旦订阅,发布的源头发生改变,订阅者就能拿到这个变化;这样说不是很好理解,简单解释就是,b.js,c.js,d.js订阅了a.js里某个值变化,b.js,c.js,d.js立马获取到这个变化的,但是a.js并没有主动调用b.js,c.js,d.js这些里面的方法,举个简单的例子,每个页面在处理ajax请求的时候,都有一弹出的提示信息,一般我会在
组件的template中中放一个提示框的组件,这样很繁琐每个组件都要来一次,如果基于Rx.js,就可以在app.component.ts中放这个提示组件,然后app.component.ts订阅公共的service,就比较省事了,代码如下
首先搞一个alset.service.ts

import {Injectable} from "@angular/core";import {Subject} from "rxjs/Subject";@Injectable()export class AlertService { private messageSu = new Subject<string>(); // messageObserve = this.messageSu.asObservable(); private setMessage(message: string) { this.messageSu.next(message); } public success(message: string, callback?: Function) { this.setMessage(message); callback(); }}

sibling-a.component.ts

@Component({ selector: 'app-sibling-a', templateUrl: './sibling-a.component.html', styleUrls: ['./sibling-a.component.css']})export class SiblingAComponent implements OnInit { userName: string; constructor(private userService: UserService, private alertService: AlertService) { } ngOnInit() { this.userName = this.userService.userName; // 改变alertService的信息源 this.alertService.success("初始化成功"); }}

app.component.ts

@Component({ selector: 'app-root', templateUrl: './app.component.html', styleUrls: ['./app.component.css']})export class AppComponent { title = 'app'; message: string; constructor(private alertService: AlertService) { //订阅alertServcie的message服务 this.alertService.messageObserve.subscribe((res: any) => { this.message = res; }); }}

这样订阅者就能动态的跟着发布源变化

总结:

Angular 用service 在组件间传递数据

0,把service中的数据传给组件:

1, 创建Service.ts file

--所有需要维护的数据

--一个数据对应一个EventEmitter

--对数据的set,get或其他操作

2,创建trigger component 该文件用于关联html和ts中的emit,html中绑定了onSetToActive方法,在onSetToActive方法中调用service中的event。

3,trigger事件被创建, 接下来创建listen方法监听。

用对应EventEmitter的subscribe方法监听,在subscribe方法中写监听到后,具体对service数据的操作,一般这个操作是写在service.ts中。

备注:

有关service的dependecy inject

1,创建service

2,引入mole(import),引入provider,在construc中引入(别忘加private)

3,引入mole(import),在construc中需要每用到一次都引入,但providers只要在最顶层引入即可(子组件都可以用)

在angular中如何实现列表全选交互组件

本篇文章主要介绍了angular写一个列表的选择全选交互组件的示例,现在分享给大家,也给大家做个参考。

开发业务后台经常要用到表格里的选择,全选这种交互。而且不同系统不同场景的UI还不一样。比如:表格里就是简简单单的checkbox;图片列表这种,UI设计师会搞点花样,用户选择一下,会在图片上盖一层半透明的勾选提示等等。我们的系统是用angular 1.X版本开发。所以,我采用angular的装饰性指令编写几个指令,把它们配合在一起使用,来封装这样的场景。这与之前我们遇到的组件的开发思路又不太一样。我们先来分析一下需求及扩展点。

需求分析

实现单选;

实现全选;

可以设置允许多选还是单选。如果多选,有最大选择数;

实现跨页选择。这里的跨页选择指的是切换到下一页后,还能记住上一页的选择。以前我们遇到的选择往往都是只记住当前页,一旦刷新就清空了。这是一个不同的地方;

要求自己定义UI及交互触发;

设计思路

这里其实是相同的地方就是选择的交互逻辑,所以重点考虑如何封装这个逻辑。这里的交互逻辑主要是: 2. 点击全选; 3. 点击列表item的选择切换。如果是单选,要清空之前的选择;如果是多选,要检查是否超过最大选择;

再来看一下应用场景相同的地方。我们将设定上下文肯定有一个list数组,一个已选数组。 因此,我们得到如下的指令。

moSelect指令

封装全选逻辑的指令。适应场景:

有一个list集合;

每一个item是一个对象;

跨页选择;

使用方式

<table mo-select="list" select-all-name="isSelectedAll" item-name="item" item-select-name="select" selected-list-name="selectedList" init-selected-list="initSelectedList" allow-multiple-select="false" select-count-limit="2" item-equal-func="itemEqual">

<thead>

<tr>

<th><input type="checkbox" ng-checked="isSelectedAll" mo-select-all></th>

<th>商户名称</th>

<th>电话</th>

<th>地点</th>

<th>更新时间</th>

<th>播放</th>

</tr>

</thead>

<tbody>

<tr ng-repeat="item in list" mo-select-single >

<td>

<input type="checkbox" ng-checked="item.select" mo-select-single1 >

</td>

<td>{{item.name}}</td>

<td>{{item.tel}}</td>

<td>{{item.addr}}</td>

<td>{{item.updateTime|msDateFormat:'YYYY-MM-DD'}}</td>

<td>

<p audio-playable="item.url" play-trigger=".audio-play" pause-trigger=".audio-pause">

<button class="btn btn-primary audio-play" ng-show="!audioInfo.playing" >播放</button>

<button class="btn btn-primary audio-pause" ng-show="audioInfo.playing" >暂停</button>

</p>

</td>

</tr>

</tbody>

</table>说明:

1、主要通过三个指令实现全选相关的代码封装;

2、mo-select 是容器指令,定义了全选,以及单选 item 的方法,定义在列表容器dom上;

mo-select的 值是scope的 list 对象,与 ng-repeat 里的 items 一致;

item-name :告诉指令,每一项的对象名,指令会通过该名称在每一项的scope里查找。与ng-repeat里的 item 一致;

select-all-name :全选的状态变量。默认: isSelectedAll

item-select-name : 记录的每一项对象是否选中的变量名,将会存储在 item 对象上,为了避免与现有业务字段重合,可以配置,也可以不配置,默认: select ;

selected-list-name :已选对象列表的变量名。默认: selectedList ;

init-selected-list :初始化选择对象列表。该变量只用于初始化,类似 vue 组件里的 prop 属性;

allow-multiple-select :是否允许多选;

select-count-limit :如果允许多选,最多可以选择多少个。如果不传,则无限;

item-equal-func :对象判等函数,用于封装业务对象自己的判等原则。比如:有些场景是根据id,有些是根据其他业务逻辑。如果不传,默认根据对象的id属性;

3、mo-select-all 全选指令。定义在全选 dom 上,一版是一个 input checkbox 。其值表示在当前scope保存的是否全选的变量名;

4、mo-select-single 单选指令。 定义在每一项 dom 上。可以有两个地方:

定义在自己的 input chebox 上

定义在 input 的容器上。类似 tr ,实现点击整行选中。也可以定义在某个单个元素上。

如果要获取已选项,直接在当前scope获取 selected-list-name 指定的变量名即可。

使用步骤:

在容器定义 mo-select ,根据实际需求,配置相关参数。必须: mo-select , item-name ;

在需要全选的按钮 dom 上添加 mo-select-all 指令,不需要配置任何参数;

在 ng-repeat 的单项模板里,在需要添加单选交互的 dom 上添加 mo-select-single 指令,不需要配置任何参数;

完成配置。

注意事项

mo-select 的值一定要和ng-repeat的 items 一致;

item-name 的值一定要和ng-repeat的 item 一致;

总结

这样的指令在我们的业务开发中使用还是很灵活的。可能看起来配置项有点麻烦,其实大多数都是可以采用默认值的。我们看看它的不同表现形式:

代码不多,200来行,代码是从项目里摘出来的,不是很复杂,就没做demo,这里分享出来,代码链接。 有兴趣要改进的同学可以拿去随便改。

上面是我整理给大家的,希望今后会对大家有帮助。

相关文章:

在vue中scroller返回页面并且记住滚动位置如何实现

如何看待vue中的深复制

在JavaScript中如何实现读取和写入cookie

pace.js和NProgress.js如何使用加载进度插件(详细教程)

在微信小程序中有关App生命周期(详细教程)

在jQuery中有关NProgress.js加载进度插件使用方法

红星娱乐还为您提供以下相关内容希望对您有帮助:

angular2 在不确定父组件的情况下,子组件怎么调用父组件的方法

1、页面中首先引入相关 js 2、此例子中:table组件为父组件,弹层组件为子组件 3、html代码 4、js代码 //列表组件 var PopShow = React.createClass({ getInitialState: function() { return { hideParent: fal...

在angular中如何实现列表全选交互组件

这里的交互逻辑主要是: 2. 点击全选; 3. 点击列表item的选择切换。如果是单选,要清空之前的选择;如果是多选,要检查是否超过最大选择限制;再来看一下应用场景相同的地方。我们将设定上下文肯定有一个list数组,一个已选...

请教大神.angular2里父组件向子组件传值问题

methods: { listenToMyBoy: function (somedata){ this.childWords = somedata } } 1 2 3 4 5 6 7 8 9 子组件component-a这么写 like! methods: { onClickMe: function(){ this.$emit('child-say',this.so...

Angular2中如何使用Dom

DOM是复杂的,因此使组件与它分离,会让我们的应用程序,更容易测试和重构。为了支持跨平台,Angular还通过抽象封装了不同平台的差异。内容1.为什么不能直接操作DOM? Angular2采用AOT静态编译模式,这种形式下需要我们的模板...

angular2 子路由怎么给父路由传递数据

Angular 使用双向绑定,Vue 也支持双向绑定,不过默认为单向绑定,数据从父组件单向传给子组件。在大型应用中使用单向绑定让数据流易于理解。在 Vue.js 中指令和组件分得更清晰。指令只封装 DOM 操作,而组件代表一个自给...

使用Angular2如何整合插件(详细教程)

那我们先不管怎么来集成zTree,我们先来解决如何将jQuery引入进来的问题:3.引入jQuery到angular2项目中,当然,如果你使用的插件没有依赖jQuery的话可以跳过这个步骤,不过一般第3方插件都依赖它,对吧。引入jQuery的话,...

如何在Angular2中使用jQuery及其插件的方法

Angular2中使用jQuery 首先在index.html中引用jquery。然后我们编写我们的app.component.ts 首先需要使用declare生命我们的jQuery,使之成为一个可用的变量,然后,我们需要导入OnInit模块并实现,我们编写的jquery代码就在这里,问...

angular具有的指令类型

组件是Angular应用的基本构建块,它们通常包含模板、样式以及用于处理数据和用户交互的控制器。例如,我们可以通过@Component装饰器创建一个组件,这个装饰器实际上就是一个组件指令。在组件模板中,我们可以使用内置的指令(如ng...

angular2的select多选插件ng-multiselect-dropdown使用总结

1 首先在项目文件中导入插件 npm i ng-multiselect-dropdown 2 插件的github地址为 https://github.com/NileshPatel17/ng-multiselect-dropdown 3 参考文档使用 4 修改默认配置 在node_modules中找到多选插件 找到下面的...

如何在Angular2中使用jQuery及其插件的方法

在Angular2中使用jQuery及其插件的方法

Top