中国领先的IT技术网站
|
|

想知道如何写出漂亮的React组件吗?

在Walmart Labs的产品开发中,我们进行了大量的Code Review工作,这也保证了我有机会从很多优秀的工程师的代码中学习他们的代码风格与样式。在这篇博文里我会分享出我最欣赏的五种组件模式与代码片。不过我首先还是要谈谈为什么我们需要执着于提高代码的阅读体验。

作者:佚名来源:前端大全|2017-09-01 14:18

Tech Neo技术沙龙 | 11月25号,九州云/ZStack与您一起探讨云时代网络边界管理实践


在Walmart Labs的产品开发中,我们进行了大量的Code Review工作,这也保证了我有机会从很多优秀的工程师的代码中学习他们的代码风格与样式。在这篇博文里我会分享出我最欣赏的五种组件模式与代码片。不过我首先还是要谈谈为什么我们需要执着于提高代码的阅读体验。就好像你有很多种方式去装扮一只猫,如果你把你的爱猫装扮成了如下这样子:

你或许可以认为萝卜青菜各有所爱,但是代码本身是应当保证其可读性,特别是在一个团队中,你的代码是注定要被其他人阅读的。电脑是不会在意这些的,不管你朝它们扔过去什么,它们都会老老实实的解释,但是你的队友们可不会这样,他们会把丑陋的代码扔回到你的脸上。而所谓的Pretty Components,应该包含如下的特性:

  • 即使没有任何注释的情况下也易于理解
  • 比乱麻般的代码有更好的性能表现
  • 更易于进行Bug追溯
  • 简洁明了,一句顶一万句

SFC:Stateless Functional Component

我觉得我们在开发中经常忽略掉的一个模式就是所谓的Stateless Functional Component,不过这是我个人最爱的React组件优化模式,没有之一。我喜爱这种模式不仅仅因为它们能够减少大量的模板代码,而且因为它们能够有效地提高组件的性能表现。总而言之,SFC能够让你的应用跑的更快,长的更帅。

直观来看,SFC就是指那些仅有一个渲染函数的组件,不过这简单的改变就可以避免很多的无意义的检测与内存分配。下面我们来看一个实践的例子来看下SFC的具体作用,譬如:

如果我们用正统的React组件的写法,可以得出如下代码:

  1. export default class RelatedSearch extends React.Component { 
  2.  
  3.   constructor(props) { 
  4.  
  5.     super(props); 
  6.  
  7.     this._handleClick = this._handleClick.bind(this); 
  8.  
  9.   } 
  10.  
  11.   _handleClick(suggestedUrl, event) { 
  12.  
  13.     event.preventDefault(); 
  14.  
  15.     this.props.onClick(suggestedUrl); 
  16.  
  17.   } 
  18.  
  19.   render() { 
  20.  
  21.     return ( 
  22.  
  23.       <section className="related-search-container"
  24.  
  25.         <h1 className="related-search-title">Related Searches:</h1> 
  26.  
  27.         <Layout x-small={2} small={3} medium={4} padded={true}> 
  28.  
  29.           {this.props.relatedQueries.map((query, index) => 
  30.  
  31.             <Link 
  32.  
  33.               className="related-search-link" 
  34.  
  35.               onClick={(event) => 
  36.  
  37.                 this._handleClick(query.searchQuery, event)} 
  38.  
  39.               key={index}> 
  40.  
  41.               {query.searchText} 
  42.  
  43.             </Link> 
  44.  
  45.           )} 
  46.  
  47.         </Layout> 
  48.  
  49.       </section
  50.  
  51.     ); 
  52.  
  53.   } 
  54.  
  55.  

而使用SFC模式的话,大概可以省下29%的代码:

  1. const _handleClick(suggestedUrl, onClick, event) => { 
  2.  
  3.   event.preventDefault(); 
  4.  
  5.   onClick(suggestedUrl); 
  6.  
  7. }; 
  8.  
  9. const RelatedSearch = ({ relatedQueries, onClick }) => 
  10.  
  11.   <section className="related-search-container"
  12.  
  13.     <h1 className="related-search-title">Related Searches:</h1> 
  14.  
  15.     <Layout x-small={2} small={3} medium={4} padded={true}> 
  16.  
  17.       {relatedQueries.map((query, index) => 
  18.  
  19.         <Link 
  20.  
  21.           className="related-search-link" 
  22.  
  23.           onClick={(event) => 
  24.  
  25.             _handleClick(query.searchQuery, onClick, event)} 
  26.  
  27.           key={index}> 
  28.  
  29.           {query.searchText} 
  30.  
  31.         </Link> 
  32.  
  33.       )} 
  34.  
  35.     </Layout> 
  36.  
  37.   </section
  38.  
  39. export default RelatedSearch;  

代码量的减少主要来源两个方面:

  • 没有构造函数(5行)
  • 以Arrow Function的方式替代Render语句(4行)

实际上,SFC最迷人的地方不仅仅是其代码量的减少,还有就是对于可读性的提高。SFC模式本身就是所谓纯组件的一种最佳实践范式,而移除了构造函数并且将_handleClick()这个点击事件回调函数提取出组件外,可以使JSX代码变得更加纯粹。另一个不错的地方就是SFC以Arrow Function的方式来定义了输入的Props变量,即以Object Destructring语法来声明组件所依赖的Props:

  1. const RelatedSearch = ({ relatedQueries, onClick }) => 

这样不仅能够使组件的Props更加清晰明确,还能够避免冗余的this.props表达式,从而使代码的可读性更好。

最后,我还想要强调下虽然我很推崇SFC,不过也不能滥用它。最合适使用SFC的地方就是之前你用纯组件的地方。在Walmart Labs中,我们使用Redux来管理应用的状态,也就意味着我们绝大部分的组件都是纯组件,也就给了SFC广阔的应用空间。一般来说,有以下特征的组件式绝对不适合使用SFC的:

  • 需要自定义整个组件的生命周期管理
  • 需要使用到refs

Conditional Components

JSX本身不支持if表达式,不过我们可以使用逻辑表达式的方式来避免将代码切分到不同的子模块中,大概是如下样子:

  1. render() { 
  2.  
  3.   <div class="search-results-container"
  4.  
  5.     {this.props.isGrid 
  6.  
  7.       ? <SearchResultsGrid /> 
  8.  
  9.       : <SearchResultsList />} 
  10.  
  11.   </div> 
  12.  
  13.  

这种表达式在二选一渲染的时候很有效果,不过对于选择性渲染一个的情况很不友好,譬如如下的情况:

  1. render() { 
  2.  
  3.   <div class="search-results-list"
  4.  
  5.     {this.props.isSoftSort 
  6.  
  7.       ? <SoftSortBanner /> 
  8.  
  9.       : null 
  10.  
  11.     } 
  12.  
  13.   </div> 
  14.  
  15.  

这样子确实能起作用,不过看上去感觉怪怪的。我们可以选用另一种更加语义化与友好的方式来实现这个功能,即使用逻辑与表达式然后返回组件:

  1. render() { 
  2.  
  3.   <div class="search-results-list"
  4.  
  5.     {!!this.props.isSoftSort && <SoftSortBanner />} 
  6.  
  7.   </div> 
  8.  
  9.  

不过这一点也是见仁见智,每个人按照自己的喜好来就行了。

Arrow Syntax In React And Redux

ES2015里包含了不少可口的语法糖,我最爱的就是那个Arrow Notation。这个特性在编写组件时很有作用:

  1. const SoftSort = ({ hardSortUrl, sortByName, onClick }) => { 
  2.  
  3.   return ( 
  4.  
  5.     <div className="SearchInfoMessage"
  6.  
  7.       Showing results sorted by both Relevance and {sortByName}. 
  8.  
  9.       <Link 
  10.  
  11.         href={`?${hardSortUrl}`} 
  12.  
  13.         onClick={(ev) => onClick(ev, hardSortUrl)}> 
  14.  
  15.         Sort results by {sortByName} only 
  16.  
  17.       </Link> 
  18.  
  19.     </div> 
  20.  
  21.   ); 
  22.  
  23. };  

该函数的功能就是返回JSX对象,我们也可以忽略return语句:

  1. const SoftSort = ({ hardSortUrl, sortByName, onClick }) => 
  2.  
  3.   <div className="SearchInfoMessage"
  4.  
  5.     Showing results sorted by both Relevance and {sortByName}. 
  6.  
  7.     <Link 
  8.  
  9.       href={`?${hardSortUrl}`} 
  10.  
  11.       onClick={(ev) => onClick(ev, hardSortUrl)}> 
  12.  
  13.       Sort results by {sortByName} only 
  14.  
  15.     </Link> 
  16.  
  17.   </div>  

代码行数又少了不少咯!

另一块我觉得非常适用Arrow Function的地方就是Redux的mapStateToProps函数:

  1. const mapStateToProps = ({isLoading}) => { 
  2.  
  3.   return ({ 
  4.  
  5.     loading: isLoading, 
  6.  
  7.   }); 
  8.  
  9. };  

需要注意的是,如果你返回的是Object,你需要包裹在大括号内:

  1. const mapStateToProps = ({isLoading}) => ({ 
  2.  
  3.   loading: isLoading 
  4.  
  5. });  

使用Arrow Function优化的核心点在于其能够通过专注于函数的重要部分而提升代码的整体可读性,并且避免过多的模板代码带来的噪音。

合理使用Object Destructing与Spread Attributes

大的组件往往受困于this.props过长的窘境,典型的如下所示:

  1. render() { 
  2.  
  3.   return ( 
  4.  
  5.     <ProductPrice 
  6.  
  7.       hidePriceFulfillmentDisplay= 
  8.  
  9.        {this.props.hidePriceFulfillmentDisplay} 
  10.  
  11.       primaryOffer={this.props.primaryOffer} 
  12.  
  13.       productType={this.props.productType} 
  14.  
  15.       productPageUrl={this.props.productPageUrl} 
  16.  
  17.       inventory={this.props.inventory} 
  18.  
  19.       submapType={this.props.submapType} 
  20.  
  21.       ppu={this.props.ppu} 
  22.  
  23.       isLoggedIn={this.props.isLoggedIn} 
  24.  
  25.       gridView={this.props.isGridView} 
  26.  
  27.     /> 
  28.  
  29.   ); 
  30.  
  31.  

这么多的Props估计看着都头疼,如果我们要将这些Props继续传入下一层,大概就要变成下面这个样子了:

  1. render() { 
  2.  
  3.   const { 
  4.  
  5.     hidePriceFulfillmentDisplay, 
  6.  
  7.     primaryOffer, 
  8.  
  9.     productType, 
  10.  
  11.     productPageUrl, 
  12.  
  13.     inventory, 
  14.  
  15.     submapType, 
  16.  
  17.     ppu, 
  18.  
  19.     isLoggedIn, 
  20.  
  21.     gridView 
  22.  
  23.   } = this.props; 
  24.  
  25.   return ( 
  26.  
  27.     <ProductPrice 
  28.  
  29.       hidePriceFulfillmentDisplay={hidePriceFulfillmentDisplay} 
  30.  
  31.       primaryOffer={primaryOffer} 
  32.  
  33.       productType={productType} 
  34.  
  35.       productPageUrl={productPageUrl} 
  36.  
  37.       inventory={inventory} 
  38.  
  39.       submapType={submapType} 
  40.  
  41.       ppu={ppu} 
  42.  
  43.       isLoggedIn={isLoggedIn} 
  44.  
  45.       gridView={isGridView} 
  46.  
  47.     /> 
  48.  
  49.   ); 
  50.  
  51.  

暂时不考虑unKnown Props,我们可以使用解构赋值来实现这个功能:

  1. render() { 
  2.  
  3.   const props = this.props; 
  4.  
  5.   return <ProductPrice {...props} /> 
  6.  
  7.  

Method Definition Shorthand

最后这个方法不一定多有用,不过还是能让你的代码变得更加漂亮。如果你希望在Object中添加函数,你可以使用ES2015 Method Definition Shorthand来代替传统的ES5的表达式,譬如:

如果你想设置一个默认的空方法,也可以利用这种方式:

  1. ProductRating.defaultProps = { 
  2.  
  3.   onStarsClick() {} 
  4.  
  5. };  

【编辑推荐】

  1. 前端面试中的常见的算法问题
  2. 移动动态化方案在蜂鸟的架构演进(含React Native与Weex对比)
  3. 纯前端解决跨域问题
  4. 暑期干货!2017年8月前端开发者超实用干货大合集
  5. 实现前端资源增量式更新的一种思路
【责任编辑:庞桂玉 TEL:(010)68476606】

点赞 0
分享:
大家都在看
猜你喜欢

读 书 +更多

Java编程思想 第4版

本书共22章,包括操作符、控制执行流程、访问权限控制、复用类、多态、接口、通过异常处理错误、字符串、泛型、数组、容器深入研究、Java I...

订阅51CTO邮刊

点击这里查看样刊

订阅51CTO邮刊
× CTO训练营(深圳站)