ReactJS组件之间如何进行通信

最近在学习react.js,不得不说***次接触组件化开发很神奇,当然也很不习惯。

成都创新互联是一家专注于网站设计制作、成都做网站与策划设计,连云港网站建设哪家好?成都创新互联做网站,专注于网站建设十多年,网设计领域的专业建站公司;建站业务涵盖:连云港等地区。连云港做网站价格咨询:13518219792

react的思想还是蛮独特的,当然围绕react的一系列自动化工具也是让我感觉亚历山大

今天总结一下react组件之间的通信,权当是自己的学习笔记:

reactJs中数据流向的的特点是:单项数据流

react组件之间的组合不知道为什么给我一种数据结构当中树的感觉,数据就是从根节点(顶端或其他子树的顶端)“流”下来,大概就是这个样子:

 比如这是一个组件树,数据就可以从main组件流到jumbotron组件、queationList组件、form组件,类似的queation组件的数据也可以流到下边的question组件里边。

但是很遗憾,这个从上到下的数据流动,只能解决很少的问题,还有一部分的数据流动就是类似从jumbotron组件到form组件的这样的兄弟组件的流动形式,或者隔着几个层级的数据流动,再或者子组件发生了数据的变化,想通知父组件,数据流向从子组件到父组件流,这些问题才是大多数的开发者需要面临的问题。所以这篇笔记总结下基础的组件通信:

数据从父组件到子组件

 最简单的通信就是父子间的通信,比如上边图上的有个jsonObj从main流进了QueationList参考代码:

 
 
  1. //这里模拟出几条数据 
  2. var jsonObj=[ 
  3.     {name:"A",question:"从小被人打怎么办?",TextArea:"习惯就好了",applaud:35,disagree:1}, 
  4.     {name:"B",question:"长的太帅被人砍怎么办?",TextArea:"食屎啦你",applaud:35,disagree:10}, 
  5.     {name:"C",question:"因为太胖被人摸怎么办?",TextArea:"享受就好了",applaud:35,disagree:45}, 
  6.     {name:"D",question:"被老师打不开心",TextArea:"用钱打脸",applaud:35,disagree:6}, 
  7.     {name:"E",question:"不爱洗澡怎么办?",TextArea:"打一顿就好了",applaud:35,disagree:9} 
  8.  
  9. var QuestionList=React.createClass({ 
  10.     prepareToRender:function(list){ 
  11.         var array=[]; 
  12.         for(var i=0;i
  13.             array.push(); 
  14.         } 
  15.         return array; 
  16.     }, 
  17.     render:function(){ 
  18.         var array=this.prepareToRender(this.props.jsonObj); 
  19.         return 
    {array}
  20.     } 
  21. }); 
  22. var Main = React.createClass({ 
  23.     //开始渲染 
  24.     render: function () { 
  25.         return ( 
  26.             
     
  27.                  
  28.                      
  29.                          
  30.                     
 
  •             
  •  
  •         ); 
  •     } 
  • }); 
  • ReactDOM.render( 
  •     
  •     document.getElementById('container') 
  • );  
  • 代码写的不怎么规范,但是数据的传递就是这样的:

    这样就可以把父组件的数据带到子组件里边

    数据从子组件到父组件

    理论上来说数据只能是单向的,所以不借助插件数据还真不好从子组件到父组件,一种很简单的手段是回调函数:

    在父组件当中写个回调函数,然后传递到子组件,什么时候子组件数据变化了,直接调这个回调函数就可以了。

     比如现在的jumbotron的按钮被点击了,我们想把被点击这个事件发给它的父组件也就是main组件,那么我们可以这个做:

     
     
    1. var Jumbotron = React.createClass({ 
    2.     handleClick: function () { 
    3.         this.props.openTheWindow(false); 
    4.     }, 
    5.     render: function () { 
    6.         return ( 
    7.                  
    8.                      
    9.                         开始体验 
    10.                          
    11.                     
     
  •                  
  •              
  •         ); 
  •     } 
  • }); 
  •  
  • var Main = React.createClass({ 
  •     getInitialState: function () { 
  •         return { 
  •             openTheWindow: true 
  •         }; 
  •     }, 
  •     //开始给子组件一个回调函数,用来做子组件给父组件通信使用 
  •     buttonResponse:function(windowSatus){ 
  •         this.setState({openTheWindow : windowSatus}); 
  •     }, 
  •     //开始渲染 
  •     render: function () { 
  •         console.log(jsonObj) 
  •         return ( 
  •             
     
  •                  
  •              
  •         ); 
  •     } 
  • }); 
  • ReactDOM.render( 
  •     
  •     document.getElementById('container') 
  • );  
  • 子组件通知父组件状态变化就是这样,就好像是儿子找爸爸要零花钱,零花钱以及给不给都是爸爸说了算的。

    兄弟组件之间的通信

    这个其实应该是一个动态应用中最常见的通信,比如jubotron组件的点击按钮,form组件的表单出现:

    这就是一个典型的兄弟之间的通信:

     兄弟节点其实可以就是子父通信&&父子通信的叠加

    首先按钮被点击,子组件通知负组件这个事件,然后父组件把这个消息带给另一个子组件

    下边是个点击按钮显示表单的例子:

     
     
    1. /** 
    2.  * Created by niuGuangzhe on 2016/9/10. 
    3.  */ 
    4. var Jumbotron = React.createClass({ 
    5.     handleClick: function () { 
    6.         this.props.openTheWindow(false); 
    7.     }, 
    8.     render: function () { 
    9.         return ( 
    10.              
    11.                  
    12.                      
    13.                         开始体验 
    14.                          
    15.                      
    16.                  
    17.              
    18.         ); 
    19.     } 
    20. }); 
    21.  
    22. var Form = React.createClass({ 
    23.     getInitialState:function(){ 
    24.         return { 
    25.             inputTitle:"请输入标题", 
    26.             mainBody:"在此输入正文" 
    27.         }; 
    28.     }, 
    29.     //点击按钮触发事件:清除所有已经输入的文字 
    30.     cleanText:function(){ 
    31.         this.setState({ 
    32.             inputTitle:"", 
    33.             mainBody:""}); 
    34.     }, 
    35.     //表单监视事件 
    36.     handleChange(name,e) { 
    37.         var newState = {}; 
    38.         console.log(name); 
    39.         newState[name] =event.target.value; 
    40.         this.setState(newState); 
    41.     }, 
    42.     render: function () { 
    43.         return ( 
    44.              
    45.                  
    46.                      
    47.                         标题 
    48.                          
    49.                      
    50.  
    51.                      
    52.                         正文 
    53.                          
    54.                      
    55.                      
    56.  
    57.                          
    58.                          
    59.                      
    60.                  
    61.              
    62.         ) 
    63.     } 
    64. }) 
    65.  
    66.  
    67. var Main = React.createClass({ 
    68.     getInitialState: function () { 
    69.         return { 
    70.             openTheWindow: true 
    71.         }; 
    72.     }, 
    73.     //开始给子组件一个回调函数,用来做子组件给父组件通信使用 
    74.     buttonResponse:function(windowSatus){ 
    75.         this.setState({openTheWindow : windowSatus}); 
    76.     }, 
    77.     //开始渲染 
    78.     render: function () { 
    79.         console.log(jsonObj) 
    80.         return ( 
    81.             
       
    82.                  
    83.                  
    84.                      
    85.                  
    86.              
    87.         ); 
    88.     } 
    89. }); 
    90. ReactDOM.render( 
    91.     
    92.     document.getElementById('container') 
    93. );  

    就是这样,

    其实上边的代码是我从之前的没事干做的一个单页面上拿过来改的,为了不出现代码无法运行的问题,下边贴出所有代码:

     
     
    1. /** 
    2.  * Created by niuGuangzhe on 2016/9/10. 
    3.  */ 
    4. var Jumbotron = React.createClass({ 
    5.     handleClick: function () { 
    6.         this.props.openTheWindow(false); 
    7.     }, 
    8.     render: function () { 
    9.         return ( 
    10.              
    11.                  
    12.                      
    13.                         React+bootstrap简单实例 
    14.                      
    15.                  
    16.                  
    17.                      
    18.                         上手体验:***次尝试组件化开发

       
    19.                      
    20.                  
    21.                  
    22.                      
    23.                         开始体验 
    24.                          
    25.                      
    26.                  
    27.              
    28.         ); 
    29.     } 
    30. }); 
    31.  
    32. var Form = React.createClass({ 
    33.     getInitialState:function(){ 
    34.         return { 
    35.             inputTitle:"请输入标题", 
    36.             mainBody:"在此输入正文" 
    37.         }; 
    38.     }, 
    39.     //点击按钮触发事件:清除所有已经输入的文字 
    40.     cleanText:function(){ 
    41.         this.setState({ 
    42.             inputTitle:"", 
    43.             mainBody:""}); 
    44.     }, 
    45.     //表单监视事件 
    46.     handleChange(name,e) { 
    47.         var newState = {}; 
    48.         console.log(name); 
    49.         newState[name] =event.target.value; 
    50.         this.setState(newState); 
    51.     }, 
    52.     render: function () { 
    53.         return ( 
    54.              
    55.                  
    56.                      
    57.                         标题 
    58.                          
    59.                      
    60.  
    61.                      
    62.                         标题 
    63.                          
    64.                      
    65.                      
    66.  
    67.                          
    68.                          
    69.                      
    70.                  
    71.              
    72.         ) 
    73.     }, 
    74.     //监测从新渲染 
    75.     componentDidUpdate:function(){ 
    76.         console.log("子组件重新渲染;"); 
    77.     } 
    78. }) 
    79.  
    80. var Question = React.createClass({ 
    81.     getInitialState : function(){ 
    82.         return { 
    83.             click:true, 
    84.             disClick:true 
    85.         }; 
    86.     }, 
    87.     numberHandle:function(){ 
    88.         if(this.state.click===true){ 
    89.             //奇数次点击,开始增加数据 
    90.             this.props.obj.applaud+=1; 
    91.             this.setState({click:false}); 
    92.         }else{ 
    93.             //偶数次点击,减去数据 
    94.             this.props.obj.applaud-=1; 
    95.             this.setState({click:true}); 
    96.         } 
    97.     }, 
    98.     decreateHandle:function(){ 
    99.         if(this.state.disClick===true){ 
    100.             //奇数次点击,开始增加数据 
    101.             this.props.obj.applaud-=1; 
    102.             this.setState({disClick:false}); 
    103.         }else{ 
    104.             //偶数次点击,减去数据 
    105.             this.props.obj.applaud+=1; 
    106.             this.setState({disClick:true}); 
    107.         } 
    108.     }, 
    109.     render: function () { 
    110.         return ( 
    111.              
    112.                  
    113.                      
    114.                         {this.props.obj.applaud-this.props.obj.disagree}
    115.                             className="glyphicon glyphicon-chevron-up"> 
    116.                      
    117.                      
    118.                      
    119.                         
    120.                             className="glyphicon glyphicon-chevron-down"> 
    121.                          
    122.                      
    123.                  
    124.                  
    125.                     

      {this.props.obj.question}

       
    126.                     

      {this.props.obj.TextArea}

       
    127.                  
    128.              
    129.         ); 
    130.     } 
    131. }); 
    132.  
    133. var QuestionList=React.createClass({ 
    134.     prepareToRender:function(list){ 
    135.         var array=[]; 
    136.         for(var i=0;i
    137.             array.push(); 
    138.         } 
    139.         return array; 
    140.     }, 
    141.     render:function(){ 
    142.         var array=this.prepareToRender(this.props.jsonObj); 
    143.         return 
      {array}
    144.     } 
    145. }); 
    146.  
    147.  
    148. //这里模拟出几条数据 
    149. var jsonObj=[ 
    150.     {name:"A",question:"从小被人打怎么办?",TextArea:"习惯就好了",applaud:35,disagree:1}, 
    151.     {name:"B",question:"长的太帅被人砍怎么办?",TextArea:"食屎啦你",applaud:35,disagree:10}, 
    152.     {name:"C",question:"因为太胖被人摸奶怎么办?",TextArea:"享受就好了",applaud:35,disagree:45}, 
    153.     {name:"D",question:"被老师打不开心",TextArea:"用钱打ta脸",applaud:35,disagree:6}, 
    154.     {name:"E",question:"不爱洗澡怎么办?",TextArea:"打一顿就好了",applaud:35,disagree:9} 
    155.  
    156. var Main = React.createClass({ 
    157.     getInitialState: function () { 
    158.         return { 
    159.             openTheWindow: true 
    160.         }; 
    161.     }, 
    162.     //开始给子组件一个回调函数,用来做子组件给父组件通信使用 
    163.     buttonResponse:function(windowSatus){ 
    164.         this.setState({openTheWindow : windowSatus}); 
    165.     }, 
    166.     //开始渲染 
    167.     render: function () { 
    168.         console.log(jsonObj) 
    169.         return ( 
    170.             
       
    171.                  
    172.                  
    173.                      
    174.                     

       
    175.                      
    176.                          
    177.                      
    178.                  
    179.              
    180.         ); 
    181.     }, 
    182. //    执行hook函数:重新渲染完成的时候调这个函数 
    183.     componentDidUpdate:function(){ 
    184.         console.log(this.state.openTheWindow); 
    185.     } 
    186. }); 
    187. ReactDOM.render( 
    188.     
    189.     document.getElementById('container') 
    190. );  

    ***就是一个很重要的问题:就是多层级的据数据传输,如果还用这个方式来传播的话,效率貌似是个大问题,解决办法看大家的做法目前暂时还是flux之类的其他框架,等研究出来单独写篇文章吧

    文章题目:ReactJS组件之间如何进行通信
    标题网址:http://www.hantingmc.com/qtweb/news32/257632.html

    网站建设、网络推广公司-创新互联,是专注品牌与效果的网站制作,网络营销seo公司;服务项目有等

    广告

    声明:本网站发布的内容(图片、视频和文字)以用户投稿、用户转载内容为主,如果涉及侵权请尽快告知,我们将会在第一时间删除。文章观点不代表本网站立场,如需处理请联系客服。电话:028-86922220;邮箱:631063699@qq.com。内容未经允许不得转载,或转载时需注明来源: 创新互联

    猜你还喜欢下面的内容

    搜索引擎优化知识

    同城分类信息