|
|
|
|
公众号矩阵

适合Vue用户的React教程,你值得拥有

小编日常工作中使用的是Vue,对于React只是做过简单的了解,并没有做过深入学习。趁着这个双节假期,小编决定好好学一学React,今天这篇文章就是小编在学习React之后,将React与Vue的用法做的一个对比,通过这个对比,方便使用Vue的小伙伴可以快速将Vue中的写法转换为React的写法。

作者:前端进击者来源:前端有的玩|2020-10-09 11:54

                   

 插槽,在React中没找到??
在使用Vue的时候,插槽是一个特别常用的功能,通过定义插槽,可以在调用组件的时候将外部的内容传入到组件内部,显示到指定的位置。在Vue中,插槽分为默认插槽,具名插槽和作用域插槽。其实不仅仅Vue,在React中其实也有类似插槽的功能,只是名字不叫做插槽,下面我将通过举例来说明。

默认插槽
现在项目需要开发一个卡片组件,如下图所示,卡片可以指定标题,然后卡片内容可以用户自定义,这时候对于卡片内容来说,就可以使用插槽来实现,下面我们就分别使用Vue和React来实现这个功能

Vue实现

1.首先实现一个card组件,如下代码所示

  1. <template> 
  2.   <div class="card"
  3.     <div class="card__title"
  4.       <span>{{ title }}</span> 
  5.     </div> 
  6.     <div class="card__body"
  7.       <slot></slot> 
  8.     </div> 
  9.   </div> 
  10. </template> 
  11. <script> 
  12. export default { 
  13.   props: { 
  14.     title: { 
  15.       type: String, 
  16.       default'' 
  17.     } 
  18.   } 
  19. </script> 

可以看到上面我们使用了<slot></slot>,这个就是组件的默认插槽,在使用组件的时候,传入的内容将会被放到<slot></slot>所在位置

2.在外部使用定义的card组件

  1. <template> 
  2.   <div> 
  3.     <my-card> 
  4.       <div>我将被放在card组件的默认插槽里面</div> 
  5.     </my-card> 
  6.   </div> 
  7. </template> 
  8. <script> 
  9. import MyCard from '../components/card' 
  10. export default { 
  11.   components: { 
  12.     MyCard 
  13.   } 
  14. </script> 

如上代码,就可以使用组件的默认插槽将外部的内容应用到组件里面指定的位置了。

React实现
虽然在React里面没有插槽的概念,但是React里面也可以通过props.children拿到组件标签内部的子元素的,就像上面代码<my-card>标签内的子元素,通过这个我们也可以实现类似Vue默认插槽的功能,一起看看代码。

1.使用React定义Card组件

  1. import React from 'react' 
  2.  
  3. export interface CardProps { 
  4.   title: string, 
  5.   children: React.ReactNode 
  6.  
  7. export default function(props: CardProps) { 
  8.  
  9.   return ( 
  10.     <div className="card"
  11.       <div className="card__title"
  12.         <span>{props.title}</span> 
  13.       </div> 
  14.       <div className="card__body"
  15.         {/**每个组件都可以获取到 props.children。它包含组件的开始标签和结束标签之间的内容 */} 
  16.         {props.children} 
  17.       </div> 
  18.     </div> 
  19.   ); 

  1. import React from 'react' 
  2. import Card from './components/Card' 
  3.  
  4. export default function () { 
  5.  
  6.   return ( 
  7.     <div> 
  8.       <Card title="标题"
  9.         <div>我将被放在card组件的body区域内容</div> 
  10.       </Card> 
  11.     </div> 
  12.   ); 

b.在外部使用Card组件
具名插槽
继续以上面的Card组件为例,假如我们现在需求发生了变化,组件的title也可以使用插槽,这时候对于Vue就可以使用具名插槽了,而React也是有办法实现的哦。

Vue实现
Vue的具名插槽主要解决的是一个组件需要多个插槽的场景,其实现是为<slot>添加name属性来实现了。

1.我们就上面的需求对card组件进行修改

  1. <template> 
  2.   <div class="card"
  3.     <div class="card__title"
  4.       <!--如果传入了title,则使用title属性,否则是否具名插槽--> 
  5.       <span v-if="title">{{ title }}</span> 
  6.       <slot v-else name="title"></slot> 
  7.     </div> 
  8.     <div class="card__body"
  9.       <!--对于内容区域依然使用默认插槽--> 
  10.       <slot></slot> 
  11.     </div> 
  12.   </div> 
  13. </template> 
  14. <script> 
  15. export default { 
  16.   props: { 
  17.     title: { 
  18.       type: String, 
  19.       default'' 
  20.     } 
  21.   } 
  22. </script> 

2.card组件修改完之后,我们再去调整一下使用card组件的地方

  1. <template> 
  2.   <div> 
  3.     <my-card> 
  4.       <!--通过v-slot:title 使用具名插槽--> 
  5.       <template v-slot:title> 
  6.         <span>这里是标题</span> 
  7.       </template> 
  8.       <div>我将被放在card组件的默认插槽里面</div> 
  9.     </my-card> 
  10.   </div> 
  11. </template> 
  12. <script> 
  13. import MyCard from '../components/card' 
  14. export default { 
  15.   components: { 
  16.     MyCard 
  17.   } 
  18. </script> 

React实现
React连插槽都没有, 更别提具名插槽了,但是没有不代表不能模拟出来。对于React的props,我们不仅仅可以传入普通的属性,还可以传入一个函数,这时候我们就可以在传入的这个函数里面返回JSX,从而就实现了具名插槽的功能。

1.对原有的Card组件进行修改

  1. import React from 'react' 
  2.  
  3. export interface CardProps { 
  4.   title?: string, 
  5.   // 加入了一个renderTitle属性,属性类型是Function 
  6.   renderTitle?: Function
  7.   children: React.ReactNode 
  8.  
  9. export default function(props: CardProps) { 
  10.  
  11.   const {title, renderTitle} = props 
  12.   // 如果指定了renderTtile,则使用renderTitle,否则使用默认的title 
  13.   let titleEl = renderTitle ? renderTitle() : <span>{title}</span> 
  14.  
  15.   return ( 
  16.     <div className="card"
  17.       <div className="card__title">{titleEl}</div> 
  18.       <div className="card__body"
  19.         {/**每个组件都可以获取到 props.children。它包含组件的开始标签和结束标签之间的内容 */} 
  20.         {props.children} 
  21.       </div> 
  22.     </div> 
  23.   ); 

2.这时候就可以在外部自定义title了

  1. import React from 'react' 
  2. import Card from './components/Card' 
  3.  
  4. export default function () { 
  5.   return ( 
  6.     <div> 
  7.       <Card  renderTitle={ 
  8.         () => { 
  9.           return <span>我是自定义的标题</span> 
  10.         } 
  11.       }> 
  12.         <div>我将被放在card组件的body区域内容</div> 
  13.       </Card> 
  14.     </div> 
  15.   ); 

作用域插槽
有时让插槽内容能够访问子组件中才有的数据是很有用的,这个就是Vue提供作用域插槽的原因。我们继续使用上面的Card组件为例,现在我基于上面的卡片组件开发了一个人员信息卡片组件,用户直接使用人员信息卡片组件就可以将人员信息显示到界面中,但是在某些业务模块需要自定义人员信息显示方式,这时候我们就需要使用到作用域插槽了。

Vue实现
实现用户信息卡片组件,里面使用了作用域插槽

  1. <template> 
  2.   <custom-card title="人员信息卡片"
  3.     <div class="content"
  4.       <!--这里使用了作用域插槽,将userInfo传出去了--> 
  5.       <slot name="userInfo" :userInfo="userInfo"
  6.         <!--如果没有使用插槽,则显示默认内容--> 
  7.         <span>姓名: {{ userInfo.name }}</span> 
  8.         <span>性别: {{ userInfo.sex }}</span> 
  9.         <span>年龄: {{ userInfo.age }}</span> 
  10.       </slot> 
  11.     </div> 
  12.   </custom-card> 
  13. </template> 
  14. <script> 
  15. import CustomCard from '../card' 
  16. export default { 
  17.   components: { 
  18.     CustomCard 
  19.   }, 
  20.   data() { 
  21.     return { 
  22.       userInfo: { 
  23.         name'张三'
  24.         sex: '男'
  25.         age: 25 
  26.       } 
  27.     } 
  28.   } 
  29. </script> 

2.在外部使用人员信息组件

  1. <template> 
  2.   <div> 
  3.     <user-card> 
  4.       <template v-slot:userInfo="{ userInfo }"
  5.         <div class="custom-user"
  6.           <ul> 
  7.             <li>姓名: {{ userInfo.name }}</li> 
  8.             <li>年龄: {{ userInfo.age }}</li> 
  9.           </ul> 
  10.         </div> 
  11.       </template> 
  12.     </user-card> 
  13.   </div> 
  14. </template> 
  15. <script> 
  16. import UserCard from '../components/user-card' 
  17. export default { 
  18.   components: { 
  19.     UserCard 
  20.   } 
  21. </script> 

React实现
在具名插槽那一小节我们通过给组件传入了一个函数,然后在函数中返回JSX的方式来模拟了具名插槽,那么对于作用域插槽,我们依然可以使用函数的这种方式,而作用域插槽传递的参数我们可以使用给函数传参的方式来替代

1.实现人员信息卡片组件

  1. import React, { useState } from 'react' 
  2.  
  3. import Card from './Card' 
  4.  
  5. interface UserCardProps { 
  6.   renderUserInfo?: Function 
  7.  
  8. export interface UserInfo { 
  9.   name: string; 
  10.   age: number; 
  11.   sex: string; 
  12.  
  13. export default function(props: UserCardProps) { 
  14.   const [userInfo] = useState<UserInfo>({ 
  15.     name"张三"
  16.     age: 25, 
  17.     sex: "男"
  18.   }); 
  19.  
  20.   const content = props.renderUserInfo ? ( 
  21.     props.renderUserInfo(userInfo) 
  22.   ) : ( 
  23.     <div> 
  24.       <span>姓名: {userInfo.name}</span> 
  25.       <span>年龄: {userInfo.age}</span> 
  26.       <span>性别: {userInfo.sex}</span> 
  27.     </div> 
  28.   ); 
  29.  
  30.   return <Card title="人员信息"
  31.     {content} 
  32.   </Card> 

2.在外部使用人员信息卡片组件

  1. import React from 'react' 
  2. import UserCard, { UserInfo } from "./components/UserCard"
  3.  
  4. export default function () { 
  5.  
  6.   return ( 
  7.     <div> 
  8.       <UserCard 
  9.         renderUserInfo={(userInfo: UserInfo) => { 
  10.           return ( 
  11.             <ul> 
  12.               <li>姓名: {userInfo.name}</li> 
  13.             </ul> 
  14.           ); 
  15.         }} 
  16.       ></UserCard> 
  17.     </div> 
  18.   ); 

Context, React中的provide/inject
通常我们在项目开发中,对于多组件之间的状态管理,在Vue中会使用到Vuex,在React中会使用到redux或者Mobx,但对于小项目来说,使用这些状态管理库就显得比较大材小用了,那么在不使用这些库的情况下,如何去完成数据管理呢?比如面试最常问的祖孙组件通信。在Vue中我们可以使用provide/inject,在React中我们可以使用Context。

假设有这样一个场景,系统现在需要提供一个换肤功能,用户可以切换皮肤,现在我们分别使用Vue和React来实现这个功能。

Vue中的provide/inject
在Vue中我们可以使用provide/inject来实现跨多级组件进行传值,就以上面所说场景为例,我们使用provide/inject来实现以下

首先,修改App.vue内容为以下内容

  1. <template> 
  2.   <div id="app"
  3.     <router-view /> 
  4.   </div> 
  5. </template> 
  6.  
  7. <script> 
  8. export default { 
  9.   data() { 
  10.     return { 
  11.       themeInfo: { 
  12.         theme: 'dark' 
  13.       } 
  14.     } 
  15.   }, 
  16.   provide() { 
  17.     return { 
  18.       theme: this.themeInfo 
  19.     } 
  20.   } 
  21. </script> 

然后在任意层级的子组件中像下面这样使用

  1. <template> 
  2.   <div :class="`child-${theme.theme}`"
  3.   </div> 
  4. </template> 
  5. <script> 
  6. export default { 
  7.   inject: ['theme'
  8. </script> 

这样就可以实现theme在所有子组件中进行共享了

React中的Context
在Vue中我们使用provide/inject实现了组件跨层级传值功能,在React中也提供了类似的功能即Context,下面我们使用Context来实现相同的功能。

在项目src目录下新建context目录,添加MyContext.js文件,然后添加以下内容

  1. import {createContext} from 'react' 
  2. // 定义 MyContext,指定默认的主题为`light` 
  3. export const MyContext = createContext({ 
  4.   theme: 'light' 
  5. }) 

MyContext提供了一个Provider,通过Provider可以将theme共享到所有的子组件。现在我们在所有的组件的共同父组件比如App.js上面添加MyContext.Provider将theme共享出去

  1. import { MyContext } from '@/context/MyContext'
  2.  
  3. export default function() { 
  4.    
  5.   const [theme, setTheme] = useState('dark'
  6.    
  7.   return ( 
  8.     <MyContext.Provider 
  9.         value={{ 
  10.           theme 
  11.         }} 
  12.       > 
  13.         <Children></Children> 
  14.      </MyContext.Provider> 
  15.     ) 
  16.   } 

然后这时候就可以直接在所有的子组件里面使用定义的主题theme了

  1. import React, { useContext } from 'react' 
  2. import { MyContext } from '@/context/MyContext'
  3.  
  4. export default function() { 
  5.    const {theme}  = useContext(MyContext) 
  6.    return <div className={`child-${theme}`}> 

没有了v-model,但也不影响使用
我们知道React和Vue都是单向数据流的,即数据的流向都是由外层向内层组件进行传递和更新的,比如下面这段React代码就是标准的单向数据流.

  1. import React, { useState } from "react"
  2.  
  3. export default function(){ 
  4.   const [name] = useState('子君'
  5.   return <input value={name}></input> 

在vue中使用v-model
如上代码,我们在通过通过value属性将外部的值传递给了input组件,这个就是一个简单的单向数据流。但是在使用Vue的时候,还有两个比较特殊的语法糖v-model和.sync,这两个语法糖可以让Vue组件拥有双向数据绑定的能力,比如下面的代码

  1. <template> 
  2.    <input v-model="name"/> 
  3. </template> 
  4. <script> 
  5.   export default { 
  6.     data() { 
  7.       return { 
  8.         name:'子君' 
  9.       } 
  10.     } 
  11.   } 
  12. </script> 

通过v-model,当用户修改input的值的时候,外部的name的值也将同步被修改。但这是Vue的语法糖啊,React是不支持的,所以React应该怎么办呢?这时候再想想自定义v-model,v-model实际上是通过定义value属性同时监听input事件来实现的,比如这样:

  1. <template> 
  2.   <div class="custom-input"
  3.      <input :value="value" @input="$_handleChange"/> 
  4.   </div> 
  5. </template> 
  6. <script> 
  7.   export default { 
  8.     props:{ 
  9.       value:{ 
  10.         type: String, 
  11.         default'' 
  12.       } 
  13.     }, 
  14.     methods:{ 
  15.       $_handleChange(e) { 
  16.         this.$emit('input', e.target.value) 
  17.       } 
  18.     } 
  19.   } 
  20. </script> 

在react寻找v-model替代方案
同理,React虽然没有v-model语法糖,但是也可以通过传入属性然后监听事件来实现数据的双向绑定。

  1. import React, { useState } from 'react' 
  2.  
  3. export default function() { 
  4.   const [name, setName] = useState('子君'
  5.  
  6.   const handleChange = (e) => { 
  7.     setName(e.target.value) 
  8.   } 
  9.   return <div> 
  10.     <input value={name} onChange={handleChange}></input> 
  11.   </div> 

小编刚开始使用react,感觉没有v-model就显得比较麻烦,不过麻烦归麻烦,代码改写也要写。就像上文代码一样,每一个表单元素都需要监听onChange事件,越发显得麻烦了,这时候就可以考虑将多个onChange事件合并成一个,比如像下面代码这样

  1. import React, { useState } from 'react' 
  2.  
  3. export default function () { 
  4.   const [name, setName] = useState('子君'
  5.   const [sex, setSex] = useState('男'
  6.  
  7.   const handleChange = (e:any, method: Function) => { 
  8.     method(e.target.value) 
  9.   } 
  10.   return <div> 
  11.     <input value={name} onChange={(e) => handleChange(e, setName)}></input> 
  12.     <input value={sex} onChange={(e) => handleChange(e, setSex)}></input> 
  13.   </div> 

没有了指令,我感觉好迷茫
在Vue中我们一般绘制页面都会使用到template,template里面提供了大量的指令帮助我们完成业务开发,但是在React中使用的是JSX,并没有指令,那么我们应该怎么做呢?下面我们就将Vue中最常用的一些指令转换为JSX里面的语法(注意: 在Vue中也可以使用JSX)

v-show与v-if
在Vue中我们隐藏显示元素可以使用v-show或者v-if,当然这两者的使用场景是有所不同的,v-show是通过设置元素的display样式来显示隐藏元素的,而v-if隐藏元素是直接将元素从dom中移除掉。

1.看一下Vue中的v-show与v-if的用法

  1. <template> 
  2.   <div> 
  3.     <span v-show="showName">姓名:{{ name }}</span> 
  4.     <span v-if="showDept">{{ dept }}</span> 
  5.   </div> 
  6. </template> 
  7. <script> 
  8. export default { 
  9.   data() { 
  10.     return { 
  11.       name'子君'
  12.       dept: '银河帝国'
  13.       showName: false
  14.       showDept: true 
  15.     } 
  16.   } 
  17. </script> 

2.将v-show,v-if转换为JSX中的语法

在Vue中指令是为了在template方便动态操作数据而存在的,但是到了React中我们写的是JSX,可以直接使用JS,所以指令是不需要存在的,那么上面的v-show,v-if如何在JSX中替代呢

  1. import React, { useState } from 'react' 
  2.  
  3. export default function() { 
  4.   const [showName] = useState(false
  5.  
  6.   const [showDept] = useState(true
  7.  
  8.   const [userInfo] = useState({ 
  9.     name:'子君'
  10.     dept: '银河帝国' 
  11.   }) 
  12.  
  13.   return ( 
  14.     <div> 
  15.       {/**模拟 v-show */} 
  16.       <span style={{display: showName ? 'block' : 'none'}}>{userInfo.name}</span> 
  17.       {/**模拟 v-show */} 
  18.       {showDept ? <span>{userInfo.dept}</span>: undefined} 
  19.     </div> 
  20.   ) 

v-for
v-for在Vue中是用来遍历数据的,同时我们在使用v-for的时候需要给元素指定key,key的值一般是数据的id或者其他唯一且固定的值。不仅在Vue中,在React中也是存在key的,两者的key存在的意义基本一致,都是为了优化虚拟DOM diff算法而存在的。

1.在Vue中使用v-for

  1. <template> 
  2.   <div> 
  3.     <ul> 
  4.       <li v-for="item in list" :key="item.id"
  5.         {{ item.name }} 
  6.       </li> 
  7.     </ul> 
  8.   </div> 
  9. </template> 
  10. <script> 
  11. export default { 
  12.   data() { 
  13.     return { 
  14.       list: [ 
  15.         { 
  16.           id: 1, 
  17.           name'子君' 
  18.         }, 
  19.         { 
  20.           id: '2'
  21.           name'张三' 
  22.         }, 
  23.         { 
  24.           id: '3'
  25.           name'李四' 
  26.         } 
  27.       ] 
  28.     } 
  29.   } 
  30. </script> 

2.在React中使用v-for的替代语法

在react中虽然没有v-for,但是JSX中可以直接使用JS,所以我们可以直接遍历数组

  1. import React from 'react' 
  2.  
  3. export default function() { 
  4.   const data = [ 
  5.     { 
  6.       id: 1, 
  7.       name"子君"
  8.     }, 
  9.     { 
  10.       id: "2"
  11.       name"张三"
  12.     }, 
  13.     { 
  14.       id: "3"
  15.       name"李四"
  16.     }, 
  17.   ]; 
  18.  
  19.   return ( 
  20.     <div> 
  21.       <ul> 
  22.         { 
  23.         data.map(item => { 
  24.           return <li key={item.id}>{item.name}</li> 
  25.         }) 
  26.       } 
  27.       </ul> 
  28.     </div> 
  29.   ) 

v-bind与v-on
v-bind在Vue中是动态绑定属性的,v-on是用于监听事件的,因为React也有属性和事件的概念,所以我们在React也能发现可替代的方式。

1.在Vue中使用v-bind与v-on

  1. <template> 
  2.   <div> 
  3.     <!--:value是v-bind:value的简写, @input是v-on:input的简写--> 
  4.     <input :value="value" @input="handleInput" /> 
  5.   </div> 
  6. </template> 
  7. <script> 
  8. export default { 
  9.   data() { 
  10.     return { 
  11.       value: '子君' 
  12.     } 
  13.   }, 
  14.   methods: { 
  15.     handleInput(e) { 
  16.       this.value = e.target.value 
  17.     } 
  18.   } 
  19. </script> 

2.在React中寻找替代方案

在Vue中,作者将事件和属性进行了分离,但是在React中,其实事件也是属性,所以在本小节我们不仅看一下如何使用属性和事件,再了解一下如何在React中自定义事件

开发一个CustomInput组件

  1. import React from 'react' 
  2.  
  3. export interface CustomInputProps { 
  4.   value: string; 
  5.   //可以看出 onChange是一个普通的函数,也被定义到了组件的props里面了 
  6.   onChange: ((value: string,event: React.ChangeEvent<HTMLInputElement>) => void) | undefined; 
  7.  
  8. export default function(props: CustomInputProps) { 
  9.    
  10.   function handleChange(e: React.ChangeEvent<HTMLInputElement>) { 
  11.     // props.onChange是一个属性,也是自定义的一个事件 
  12.     props.onChange && props.onChange(e.target.value, e) 
  13.   } 
  14.  
  15.   return ( 
  16.     <input value={props.value} onChange={handleChange}></input> 
  17.   ) 

使用CustomInput组件

  1. import React, { useState } from 'react' 
  2.  
  3. import CustomInput from './components/CustomInput' 
  4.  
  5. export default function() { 
  6.  const [value, setValue] =  useState(''
  7.  
  8.  function handleChange(value: string) { 
  9.    setValue(value) 
  10.  } 
  11.  
  12.   return ( 
  13.     <div> 
  14.       <CustomInput value={value} onChange={handleChange}></CustomInput> 
  15.     </div> 
  16.   ) 

总结
刚开始从Vue转到React的时候,其实是有点不适应的,但是当慢慢的习惯之后,就会发现Vue和React是存在很多共性的,可以参考的去学习。当然无论Vue还是React,上手比较快,但是想深入学习还是需要下功夫的,后续小编将会对Vue和React的用法在做更深入的介绍,敬请期待。

【编辑推荐】

  1. 在Spring Boot中从类路径加载文件
  2. 人工智能加速目标瞄准 助力人机融合即时打击
  3. 如何确定DevOps变更的优先级?
  4. iPhone12mini没有5G吗
  5. 物联网对会计行业有何益处?
【责任编辑:姜华 TEL:(010)68476606】

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

订阅专栏+更多

云原生架构实践

云原生架构实践

新技术引领移动互联网进入急速赛道
共3章 | KaliArch

26人订阅学习

数据中心和VPDN网络建设案例

数据中心和VPDN网络建设案例

漫画+案例
共20章 | 捷哥CCIE

189人订阅学习

搭建数据中心实验Lab

搭建数据中心实验Lab

实验平台Datacenter
共5章 | ITGO(老曾)

118人订阅学习

订阅51CTO邮刊

点击这里查看样刊

订阅51CTO邮刊

51CTO服务号

51CTO官微