react 試題

時間  2019-11-13
標籤 react 試題 欄目 React 简体版
原文   原文鏈接

 

  react生命週期函數

這個問題要考察的是組件的生命週期css

1、 初始化階段：html

getDefaultProps:獲取實例的默認屬性vue

getInitialState:獲取每一個實例的初始化狀態node

componentWillMount:組件即將被裝載、渲染到頁面上react

render:組件在這裏生成虛擬的DOM節點webpack

componentDidMount:組件真正在被裝載以後,最經常使用ios

2、 運行中狀態：git

componentWillReceiveProps:組件將要接收到屬性的時候調用github

shouldComponentUpdate(prestate, props):組件接受到新屬性或者新狀態的時候（能夠返回false,接收數據後不更新，阻止render調用，後面的函數不會被繼續執行了）web

componentWillUpdate:組件即將更新不能修改屬性和狀態

render:組件從新描繪

componentDidUpdate:組件已經更新

3、 銷燬階段：

componentWillUnmount:組件即將銷燬,清理工做，事件解除綁定，清理定時器，釋放資源

 詳見：https://my.oschina.net/feiyangxiaomi/blog/644418

 更改狀態

this.state({}) //更經常使用

setState(fuction(){ //性能更好
　　　　return {}
})

 官方推薦第二種寫法，由於function會存入隊列中執行，能夠提升性能，而第一種表示當即執行，（setState原理關鍵詞：異步、隊列、事務（transaction，一串批處理，完成全完成，失敗全失敗，保證數據的一致性））

//設count = 0
componentDidMount(){
  this.setState({
      count:this.state.count + 1    
  })
    this.setState({
      count:this.state.count + 1    
  })    
}  //最終渲染後state==1

componentDidMount(){
    this.setState(function(preState, props){
        return {count: preState + 1}
    })
    this.setState(function(preState, props){
        return {count: preState + 1}
    })
}  //最終渲染後state==2

React使用refs取得多個dom的方式

參考文檔：https://facebook.github.io/react/docs/refs-and-the-dom.html

1 構造器constructor中 聲明 this.textInput = [];
2 render裏面：
<input type="text" ref={(input) => { this.textInput.push(input); }} />
<input type="text" ref={(input) => { this.textInput.push(input); }} />
3 方法中能夠用this.textInput取得多個

數據類型

Symbol，表示獨一無二的值。它是 JavaScript 語言的第七種數據類型，前六種是：undefined、null、布爾值（Boolean）、字符串（String）、數值（Number）、對象（Object）。

react或者vue作prop驗證的時候的類型。
String
Number
Boolean
Function
Object
Array
Symbol

JSX語法：

JS + XHTML的混寫。
語法要求：
1.只能有一個頂層元素
2.組件首字母必須大寫
3.html中的class應該寫成className，for應該寫成htmlFor。
4.標籤必須封閉。
5.事件必須修正this指針。
constructor中寫 this.fun = this.fun.bind(this)
onClick={()=>{}}
onClick={this.fun.bind(this)}
6.事件綁定時，事件的首字母要大寫。 例如：onClick

2. 聲明組件
ES5:

React.createClass({
    render: function() {
        return (
            html....
        )
    }
})

ES6:

有狀態組件

class App extends Component {
    render() {
        return (
            html....
        )
    }
}

無狀態組件

const App = (props)=>(
    <div>
        ....
    </div>
)

 二者區別：

無狀態組件沒有this指針(所以不能綁定ref），沒有state，惟一的參數是props

組件數據傳遞？ 

父-子 經過prop傳遞
子-父 在父中建立一個能夠修改state的方法，以後把這個方法經過prop傳遞給子，在子中調用這個方法從而達到修改父state的目的。

非父子組件如何數據共享or數據通訊：建立全局對象，監視對象on，數據發送方觸發自定義事件同時傳遞數據。

var EventEmmiter = require("events").EventEmitter;
var obj = new Objcet();
Object.assign(obj ,EventEmmiter.protoype)
obj.on("abc", function(data){

})
obj.emit("abc", data);

 數據通訊： axios whatwg-fetch

開發過哪些組件？

項目中經常使用到的組件好比：頭部，底部、輪播圖

在項目中使用輪播圖，在github上找了幾個輪播圖插件，感受都很差用，當圖片數據是動態加載時每每就會出現錯誤（須要從新計算）。索性就本身在swiper的基礎上進行了二次封裝，要注意對數據進行校驗

//AmazingSwiper.js
import React, { Component } from 'react';
import Swiper from 'swiper';
import '../style/swiper.min.css';

export default class AmazingSwiper extends Component {
    componentDidUpdate() {
        console.log("new"); // 這裏注意在update上進行綁定
        var op = this.props.option;
        var sp = new Swiper(".swiper-container", {
          loop: op.loop ? op.loop : false,
          autoplay: op.autoplay ? {delay: 2500} : false
        })
    }
    render() {
        console.log("a render");
        let arr = this.props.ldata;
        return (
            <div className="swiper-container">
                <div className="swiper-wrapper">
                {this.props.children}
                </div>
            </div>
        )
    }
}
// Home.js
render() {
        var arr = [
            "https://pic.maizuo.com/usr/movie/c879dc398937b864f2424d7e1abf4edf.jpg",
            "https://pic.maizuo.com/usr/movie/d8dc842930a9744b7cc8c1eca7f6e402.jpg",
            "https://pic.maizuo.com/usr/movie/77780e34723cf9200071bec049c11ea4.jpg"
        ];
        return (
            <div>
                {this.state.position}
                <AmazingSwiper option={{autoplay:true, loop: true}}>
                    {
                        arr.map((item)=>{
                            return <div key={item} className="swiper-slide"><img src={item}/></div>
                        })
                    }
                </AmazingSwiper>
            </div>
        )
    }
View Code

使用create-react-app後建立的工程下有registerServiceWorker.js是作什麼用的？

registerServiceWorker就是爲react項目註冊了一個service worker，用來作資源的緩存，這樣你下次訪問時，就能夠更快的獲取資源。並且由於資源被緩存，因此即便在離線的狀況下也能夠訪問應用（此時使用的資源是以前緩存的資源）。注意，registerServiceWorker註冊的service worker 只在生產環境中生效（process.env.NODE_ENV === ‘production’）

有了解過React.js嗎？

React.js 只是一個視圖庫

　　（1）聲明式設計

　　（2）高效：經過對DOM的模擬，最大限度的減小與DOM的交互。

　　（3）靈活：能夠與已知的框架或庫很好的配合。

　　（4）JSX：是js語法的擴展，不必定使用，但建議用。

　　（5）組件：構建組件，使代碼更容易獲得複用，可以很好地應用在大項目的開發中。

　　（6）單向響應的數據流：React實現了單向響應的數據流，從而減小了重複代碼，這也是解釋了它爲何比傳統數據綁定更簡單。

jsx語法使用時須要注意哪些內容？

 {/*JSX 中的註釋方式*/}

JSX中全部的標籤都必須有閉標籤

在JSX中咱們一般是經過 {} 的方式插入值，可是設置style屬性須要{{ }}

由於jsx最終要轉成js進行編譯，所以html標籤上的屬性名與JavaScript關鍵字和保留字相沖突的都須要作一些變化，其規則同js中操做dom屬性時同樣，

通常來講，在使用js操做標籤屬性時，若出現與JavaScript關鍵字和保留字相沖突的狀況，除html標籤class（轉爲className）之外的屬性，在屬性前加上小寫的html便可，如

html標籤的class在jsx語法中變爲 className

html標籤的for屬性（如：<label for="msg" ></label>）在jsx中變爲<label htmlFor="msg" ></label>，

import classes form './myCss.css'

{/*調用.css 文件中的css屬性, mycss 爲css文件中的類*/}
<div className={classes['mycss']}></div>

 

詳見：http://www.cnblogs.com/fanlinqiang/p/7989255.html

react配置反向代理？

執行package.json中script定義的命令，即：npm run eject

"eject": "react-scripts eject"

tips：這個操做是不可逆的

在package.json文件中

"proxy": {
    "/v4": {
      "target": "https://m.maizuo.com",
      "changeOrigin": true,
      "pathRewrite": {
        "^/v4": "/v4"
      },
      "ws": true
    }
  }

或者在webpackDevServer.config.js中配置，示例：

proxy: {
      '/api': {
        target: 'https://api.douban.com/',
        changeOrigin: true,
        pathRewrite: {
          '^/api': ''
        }
      }
}

 setState後發生了什麼？ 

點擊事件開始時，框架調用ReactEventListener.dispatchEvent
以後執行batchedUpdates開啓事務。

setState中經過this.updater.enqueueSetState方法把state加入隊列
(react-dom中實現了enqueueSetState方法)

事件綁定的方法執行完成之後，框架會繼續執行batchedUpdates進行批量更新。

 

react性能優化是哪一個周期函數？

shouldComponentUpdate這個方法用來判斷是否須要調用render方法從新描繪dom。由於dom的描繪很是消耗性能，若是咱們能在shouldComponentUpdate方法中可以寫出更優化的dom diff算法，能夠極大的提升性能。

詳細參考：http://www.javashuo.com/article/p-eqdqeqmg-eh.html

 爲何虛擬dom會提升性能？

虛擬dom至關於在js和真實dom中間加了一個緩存，利用dom diff算法避免了沒有必要的dom操做，從而提髙性能。

具體實現步驟以下：

1． 用JavaScript對象結構表示DOM樹的結構；而後用這個樹構建一個真正的DOM樹，插到文檔當中

2．當狀態變動的時候，從新構造一棵新的對象樹。而後用新的樹和舊的樹進行比較，記錄兩棵樹差別

3．把2所記錄的差別應用到步驟1所構建的真正的DOM樹上，視圖就更新了。

參考連接：https://www.zhihu.com/question/29504639?sort=created

diff 算法？

1)     把樹形結構按照層級分解，只比較同級元素。

2)     給列表結構的每一個單元添加惟_的key屬性，方便比較。

3)     React只會匹配相同class的component (這裏面的class指的是組件的名字）

4)     合併操做，調用component的setState方法的時候,React將其標記爲dirty.到每個事件循環 結束,React檢查全部標記dirty的component從新繪製.

5)     選擇性子樹渲染。開發人員能夠重寫shouldComponentUpdate提升diff的性能。

參考連接：http://www.javashuo.com/article/p-qmngkjkx-kn.html

 react性能優化方案

1)     重寫shouldComponentUpdate來避免沒必要要的dom操做0

2)     使用 production 版本的react.js0

3)     使用key來幫助React識別列表中全部子組件的最小變化。

參考連接：

http://www.javashuo.com/article/p-eqdqeqmg-eh.html http://blog.csdn.net/limm33/article/details/50948869

   React項目用過什麼腳手架？ Mern? Yeoman?

Mern: MERN是腳手架的工具，它能夠很容易地使用Mongo, Express, React and NodeJS生成

同構JS應用。它最大限度地減小安裝時間，並獲得您使用的成熟技術來加速開發。

參考連接：http://www.open一open.com/lib/view/open1455953055292.html

當你調用setState的時候，發生了什麼事？

當調用 setState 時，React會作的第一件事情是將傳遞給 setState 的對象合併到組件的當前狀態。這將啓動一個稱爲和解（reconciliation）的過程。和解（reconciliation）的最終目標是以最有效的方式，根據這個新的狀態來更新UI。 爲此，React將構建一個新的 React 元素樹（您能夠將其視爲 UI 的對象表示）。

一旦有了這個樹，爲了弄清 UI 如何響應新的狀態而改變，React 會將這個新樹與上一個元素樹相比較（ diff ）。

經過這樣作， React 將會知道發生的確切變化，而且經過了解發生什麼變化，只需在絕對必要的狀況下進行更新便可最小化 UI 的佔用空間。

無狀態組件與有狀態的組件的區別？

 無狀態組件：沒有狀態，沒有生命週期，只是簡單的接受 props 渲染生成 DOM 結構。無狀態組件很是簡單，開銷很低，若是可能的話儘可能使用無狀態組件。

無狀態的函數建立的組件是無狀態組件，它是一種只負責展現的純組件，可使用純函數來實現：

const HelloMessage = (props) => <div> Hello {props.name}</div>;
render(<HelloMessage name="John" />, mountNode);

 無狀態組件內部實際上是可使用ref功能的，雖然不能經過this.refs訪問到，可是能夠經過將ref內容保存到無狀態組件內部的一個本地變量中獲取到。

例以下面這段代碼可使用ref來獲取組件掛載到DOM中後所指向的DOM元素:

function TestComp(props){ 
    let ref;
     return ( <div ref={(node) => ref = node}></div> )
 }

 詳見：https://www.w3cplus.com/react/stateful-vs-stateless-components.html

何時在功能組件( Class Component )上使用類組件( Functional Component )？

若是您的組件具備狀態( state )或生命週期方法，請使用 Class 組件。不然，使用功能組件

能夠選擇性地傳遞給 setState 的第二個參數是什麼，它的目的是什麼？

一個回調函數，當setState結束並 re-rendered 該組件時將被調用。一些沒有說出來的東西是 setState 是 異步 的，這就是爲何它須要一個第二個回調函數。一般最好使用另外一個生命週期方法，而不是依賴這個回調函數，可是很高興知道它存在。

this.setState(
  { username: 'tylermcginnis33' }, () => console.log('setState has finished and the component has re-rendered.') )

 

this.setState的第二個參數的做用？

this.setState((prevState, props) => {
  return { streak: prevState.streak + props.count } })

這個函數格式是固定的，必須第一個參數是state的前一個狀態，第二個參數是屬性對象props，這兩個對象setState會自動傳遞到函數中去，同時，這些函數在setState中的執行是同步的，從而解決了異步問題。可是這種寫法不多被使用，並非衆所周知的，就是你也能夠傳遞一個函數給setState，它接收到先前的狀態和道具並返回一個新的狀態，正如咱們在上面所作的那樣。它不只沒有什麼問題，並且若是您根據之前的狀態（state）設置狀態，推薦使用這種寫法。 

 雙向數據綁定和單向數據的區別？

1．單向數據流中，父組件給子組件傳遞數據，但反過來不能夠傳遞，也就是說單向數據流是從最外層節點傳遞到子節點，他們只需從最外層節點獲取props渲染便可，若是頂層組件的 某個prop改變了，React會遞歸的向下便利整棵組件樹，從新渲染全部使用這個屬性的組件， React組件內部還具備本身的狀態，這些狀態只能在組件內修改；雙向數據綁定是數據與視圖 雙向綁定，數據發生改變時，視圖也改變，視圖發生改變時，數據也會發生改變。

2．雙向數據綁定的各類數據相互依賴相互綁定，致使數據問題的源頭難以被跟蹤到；單向 數據流的數據流動方向能夠跟蹤，流動單一，追查問題的時候能夠更快捷，缺點是寫起來不太方便，要使視圖發生改變就得建立各類action來維護state。

雙向綁定把數據變動的操做隱藏在框架內部，調用者並不會直接感知。而在踐行單向數 據流的flux系的實現中，其實不過是在全局搞了一個單例的事件分發器（dispatcher)，開發者 必須顯式地經過這個統一的事件機制作數據變動通知。

 在 React 當中 Element 和 Component 有何區別？

簡單地說，一個 React element 描述了你想在屏幕上看到什麼。換個說法就是，一個 React element 是一些 UI 的對象表示。

一個 React Component 是一個函數或一個類，它能夠接受輸入並返回一個 React element t（一般是經過 JSX ，它被轉化成一個 createElement 調用）。

有關更多信息，請查看 React Elements vs React Components

 組件是由元素構成的。元素數據結構是普通對象，而組件數據結構是類或純函數。

詳見：https://segmentfault.com/a/1190000008587988

什麼是 React 的 refs ，爲何它們很重要？

refs就像是一個逃生艙口，容許您直接訪問DOM元素或組件實例。爲了使用它們，您能夠向組件添加一個 ref 屬性，該屬性的值是一個回調函數，它將接收底層的 DOM 元素或組件的已掛接實例，做爲其第一個參數。

class UnControlledForm extends Component {
  handleSubmit = () => {
    console.log("Input Value: ", this.input.value)
  }
  render () {
    return (
      <form onSubmit={this.handleSubmit}>
        <input
          type='text'
          ref={(input) => this.input = input} />
        <button type='submit'>Submit</button>
      </form>
    )
  }
}
View Code

以上注意到咱們的輸入字段有一個 ref 屬性，其值是一個函數。該函數接收咱們而後放在實例上的實際的 DOM 元素，以便在 handleSubmit 函數內部訪問它。常常誤解的是，您須要使用類組件才能使用 ref ，但 ref 也能夠經過利用 JavaScript 中的 閉包 與 功能組件( functional components )一塊兒使用。

function CustomForm ({handleSubmit}) {
  let inputElement
  return (
    <form onSubmit={() => handleSubmit(inputElement.value)}>
      <input
        type='text'
        ref={(input) => inputElement = input} />
      <button type='submit'>Submit</button>
    </form>
  )
}
View Code

React 中的keys是什麼，爲何它們很重要？

keys是什麼幫助 React 跟蹤哪些項目已更改、添加或從列表中刪除。

  return (
    <ul>
      {this.state.todoItems.map(({task, uid}) => {
        return <li key={uid}>{task}</li>
      })}
    </ul>
  )
}

每一個 keys 在兄弟元素之間是獨一無二的。咱們已經談過幾回關於和解（reconciliation）的過程，並且這個和解過程（reconciliation）中的一部分正在執行一個新的元素樹與最前一個的差別。keys 使處理列表時更加高效，由於 React 可使用子元素上的 keys 快速知道元素是新的仍是在比較樹時才被移動。

並且 keys 不只使這個過程更有效率，並且沒有 keys ，React 不知道哪一個本地狀態對應於移動中的哪一個項目。因此當你 map 的時候，不要忽略了 keys 。

看下面的代碼: 若是您在 下建立了一個 React 元素， 的組件定義將如何？

<Twitter username='tylermcginnis33'>
  {(user) => user === null
    ? <Loading />
    : <Badge info={user} />}
</Twitter>
import React, { Component, PropTypes } from 'react'
import fetchUser from 'twitter'
// fetchUser接收用戶名返回 promise
// 當獲得 用戶的數據的時候 ，返回resolve 狀態

class Twitter extends Component {
  // 在這裏寫下你的代碼
}
View Code

若是你不熟悉渲染回調模式（render callback pattern），這將看起來有點奇怪。在這種模式中，一個組件接收一個函數做爲它的 child。注意上面包含在 標籤內的內容。 Twitter 組件的 child 是一個函數，而不是你曾經習覺得常的一個組件。 這意味着在實現 Twitter 組件時，咱們須要將 props.children 做爲一個函數來處理。

如下是個人答案。

import React, { Component, PropTypes } from 'react'
import fetchUser from 'twitter'

class Twitter extends Component {
  state = {
    user: null,
  }
  static propTypes = {
    username: PropTypes.string.isRequired,
  }
  componentDidMount () {
    fetchUser(this.props.username)
      .then((user) => this.setState({user}))
  }
  render () {
    return this.props.children(this.state.user)
  }
}
View Code

值得注意的是，正如我上面提到的，我經過調用它並傳遞給 user 來把 props.children 處理爲爲一個函數。

這種模式的好處是咱們已經將咱們的父組件與咱們的子組件分離了。父組件管理狀態，父組件的消費者能夠決定以何種方式將從父級接收的參數應用於他們的 UI。

爲了演示這一點，咱們假設在另外一個文件中，咱們要渲染一個 Profile 而不是一個 Badge, ，由於咱們使用渲染回調模式，因此咱們能夠輕鬆地交換 UI ，而不用改變咱們對父（Twitter）組件的實現。

<Twitter username='tylermcginnis33'>
  {(user) => user === null
    ? <Loading />
    : <Profile info={user} />}
</Twitter>

受控組件( controlled component )與不受控制的組件( uncontrolled component )有什麼區別？

React 的很大一部分是這樣的想法，即組件負責控制和管理本身的狀態。

當咱們將 native HTML 表單元素（ input, select, textarea 等）投入到組合中時會發生什麼？咱們是否應該使用 React 做爲「單一的真理來源」，就像咱們習慣使用React同樣？ 或者咱們是否容許表單數據存在 DOM 中，就像咱們習慣使用HTML表單元素同樣？ 這兩個問題是受控（controlled） VS 不受控制（uncontrolled）組件的核心。

受控組件是React控制的組件，也是表單數據的惟一真理來源。

以下所示， username 不存在於 DOM 中，而是以咱們的組件狀態存在。每當咱們想要更新 username 時，咱們就像之前同樣調用setState。

class ControlledForm extends Component {
  state = {
    username: ''
  }
  updateUsername = (e) => {
    this.setState({
      username: e.target.value,
    })
  }
  handleSubmit = () => {}
  render () {
    return (
      <form onSubmit={this.handleSubmit}>
        <input
          type='text'
          value={this.state.username}
          onChange={this.updateUsername} />
        <button type='submit'>Submit</button>
      </form>
    )
  }
}
View Code

不受控制( uncontrolled component )的組件是您的表單數據由 DOM 處理，而不是您的 React 組件。

咱們使用 refs 來完成這個。

class UnControlledForm extends Component {
  handleSubmit = () => {
    console.log("Input Value: ", this.input.value)
  }
  render () {
    return (
      <form onSubmit={this.handleSubmit}>
        <input
          type='text'
          ref={(input) => this.input = input} />
        <button type='submit'>Submit</button>
      </form>
    )
  }
}
View Code

雖然不受控制的組件一般更容易實現，由於您只需使用引用從DOM獲取值，可是一般建議您經過不受控制的組件來支持受控組件。

主要緣由是受控組件 支持即時字段驗證 ，容許您有條件地禁用/啓用按鈕，強制輸入格式，而且更多的是 『the React way』。

在哪一個生命週期事件中你會發出 AJAX 請求，爲何？

AJAX 請求應該在 componentDidMount 生命週期事件中。 有幾個緣由:

  • Fiber，是下一次實施React的和解算法，將有能力根據須要啓動和中止渲染，以得到性能優點。其中一個取捨之一是 componentWillMount ，而在其餘的生命週期事件中出發 AJAX 請求，將是具備 「非肯定性的」。 這意味着 React 能夠在須要時感受到不一樣的時間開始調用 componentWillMount。這顯然是AJAX請求的很差的方式。

-您不能保證在組件掛載以前，AJAX請求將沒法 resolve。若是這樣作，那意味着你會嘗試在一個未掛載的組件上設置 StState，這不只不會起做用，反而會對你大喊大叫。 在 componentDidMount 中執行 AJAX 將保證至少有一個要更新的組件。

shouldComponentUpdate 應該作什麼，爲何它很重要？

上面咱們討論了 reconciliation ，什麼是 React 在 setState 被調用時所作的。在生命週期方法 shouldComponentUpdate 中，容許咱們選擇退出某些組件（和他們的子組件）的 reconciliation 過程。

咱們爲何要這樣作？

如上所述，「和解（ reconciliation ）的最終目標是以最有效的方式，根據新的狀態更新用戶界面」。若是咱們知道咱們的用戶界面（UI）的某一部分不會改變，那麼沒有理由讓 React 很麻煩地試圖去弄清楚它是否應該渲染。經過從 shouldComponentUpdate 返回 false，React 將假定當前組件及其全部子組件將保持與當前組件相同。

您如何告訴React 構建（build）生產模式，該作什麼？

一般，您將使用Webpack的 DefinePlugin 方法將 NODE_ENV 設置爲 production。這將剝離像 propType 驗證和額外的警告。除此以外，還有一個好主意，能夠減小你的代碼，由於React使用 Uglify 的 dead-code 來消除開發代碼和註釋，這將大大減小你的包的大小。

爲何要使用 React.Children.map（props.children，（）=>） 而不是 props.children.map（（）=>）

由於不能保證props.children將是一個數組。

以此代碼爲例，

<Parent>
  <h1>Welcome.</h1>
</Parent>

在父組件內部，若是咱們嘗試使用 props.children.map 映射孩子，則會拋出錯誤，由於 props.children 是一個對象，而不是一個數組。

若是有多個子元素，React 只會使props.children成爲一個數組。就像下面這樣：

<Parent>
  <h1>Welcome.</h1>
  <h2>props.children will now be an array</h2>
</Parent>

這就是爲何你喜歡 React.Children.map ，由於它的實現考慮到 props.children 多是一個數組或一個對象。

描述事件在React中的處理方式。

爲了解決跨瀏覽器兼容性問題，您的 React 中的事件處理程序將傳遞 SyntheticEvent 的實例，它是 React 的瀏覽器本機事件的跨瀏覽器包裝器。

這些 SyntheticEvent 與您習慣的原生事件具備相同的接口，除了它們在全部瀏覽器中都兼容。有趣的是，React 實際上並無將事件附加到子節點自己。React 將使用單個事件監聽器監聽頂層的全部事件。這對於性能是有好處的，這也意味着在更新DOM時，React 不須要擔憂跟蹤事件監聽器。

createElement 和 cloneElement 有什麼區別？

createElement 是 JSX 被轉載到的，是 React 用來建立 React Elements 的內容(一些 UI 的對象表示)cloneElement用於克隆元素並傳遞新的 props。他們釘住了這兩個��的命名。

es7事件綁定this？

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程