一文帶你了解React中的函數(shù)組件

更新時間：2022年08月12日 12:05:45 作者：『荼』

函數(shù)式組件的基本意義就是,組件實際上是一個函數(shù),不是類,下面這篇文章主要給大家介紹了關(guān)于React中函數(shù)組件的相關(guān)資料,文中通過實例代碼介紹的非常詳細,需要的朋友可以參考下

1. 創(chuàng)建方式

 //  寫法一
const Hello = (props) => {      
    return <div>{props.message}</div>
}

 //  寫法二
const Hello = props => <div>{props.message}</div>  

// 寫法三
function Hello(props) {
    return <div>{props.message}</div>
}

2. 函數(shù)組件代替類組件

面臨的問題

函數(shù)組件沒有state => React v16.8.0推出Hooks API，其中的一個API叫做useState可以解決問題
函數(shù)組件沒有生命周期 => React v16.8.0推出Hooks API，其中的一個API叫做useEffect可以解決問題

我們對比一下兩種組件實現(xiàn) n + 1 的例子

類組件

class App extends React.Component {
    constructor(props) {
        super(props);
        this.state = {
            n: 0
        }
    }

    addNum = () => {
        this.setState({n: this.state.n + 1})
    }

    render() {
        return (
            <div className='App'>
                <span>n:{this.state.n}</span>
                <button onClick={this.addNum}>n+1</button>
            </div>
        )
    }
}

函數(shù)組件

const App = props => {
    const [n,setN] = React.useState(0)
    function addNum(){
        setN(n + 1)
    }
    return (
        <div className='App'>
            {n}
            <button onClick={addNum}>+1</button>
        </div>
    )
}

相比之下函數(shù)組件更為簡潔一些

使用 useEffect 解決生命周期問題

1.模擬 componentDidMount 首次渲染

useEffect(() => {     //  模擬componentDidMount  首次渲染
        console.log('use effect')
    },[])    // 空數(shù)組必須寫

2.模擬 componentDidUpdate

const [n, setN] = React.useState(0)
useEffect(() => {     //  模擬  componentDidUpdate 
        console.log('n 變化了')
    },[n])  // 數(shù)組里面可以寫多個參數(shù)表示監(jiān)聽多個變量

useEffect(() => {     //  模擬  componentDidUpdate 
        console.log('任意屬性變更了')
    })  // 不寫數(shù)組表示監(jiān)聽所有 useState  的變量
//  但是這樣在第一次渲染時也會觸發(fā)函數(shù)的執(zhí)行  
 解決方法使用自定義Hook 見下一標題

3.模擬componentWillUnmount

  useEffect(() => {    
        return () => {
            console.log('Child 銷毀了')
        }
    })    //  返回一個函數(shù) 在銷毀時執(zhí)行

4.constructor

函數(shù)組件執(zhí)行的時候，就相當于constructor

5.shouldComponentUpdate

后面的 React.memo和useMemo可以解決

6.render

函數(shù)組件的返回值就是render的返回值.

//  模擬render里面寫邏輯
const X = (props) => {
    console.log('我是要寫的邏輯')
    return (
        <div>邏輯模擬</div>
    )
}

const App = props => {
    let [childVisible, setChildVisible] = useState(true)

    const changeVisible = () => {
        setChildVisible(!childVisible)
    }

    return (
        <div className='App'>
            {childVisible ? <button onClick={changeVisible}>{childVisible}</button> :
                <button onClick={changeVisible}>hide</button>}
            {/*{childVisible ? <Child/> : null}*/}
            <Child/>
            <X/>     
        </div>
    )
}   // 一個函數(shù)便是一個組件

3. 自定義 Hook 之 useUpdate

解決上面 n 值初次渲染就執(zhí)行的問題

const App = props => {
    const [n, setN] = useState(0)
    const onClick = () => {
        setN(n + 1)
    }
    const [nUpdateCount, setNUpdateCount] = useState(0)
    useEffect(() => {    // 初次渲染就執(zhí)行 + 1
        setNUpdateCount(nUpdateCount + 1)
    }, [n])
    useEffect(() => {    // 初次渲染就執(zhí)行 判斷是否大于1 
        if(nUpdateCount > 1){
            console.log('n變了')
        }
    },[nUpdateCount])
    return (
        <div className='App'>
            n值變成了:{n}
            <button onClick={onClick}>n+1</button>
        </div>
    )
}
//  通過使用兩次 useEffect 第一個觸發(fā)第二個 useEffect 函數(shù)計數(shù)，大于0便是n值變化了

上面的代碼很亂改進一下

const useX = (fn, dep) => {   // 這就是自定義 Hook 這就可以抽離成別的文件
    const [count, setCount] = useState(0)
    useEffect(() => {
        setCount(x => x + 1)
    }, [dep])
    useEffect(() => {
        if (count > 1) {
            fn()
        }
    }, [count,fn])
}

const App = props => {
    const [n, setN] = useState(0)
    const onClick = () => {
        setN(n + 1)
    }
    useX(() => {
        console.log('n 變化了')
    }, n)
    return (
        <div className='App'>
            n值變成了:{n}
            <button onClick={onClick}>n+1</button>
        </div>
    )
}

補充：函數(shù)組件代替 class 組件

為什么要用函數(shù)組件代替 class 組件？別問，簡單！相比類組件來說，函數(shù)組件確實要簡單太多，不妨看一個 +1 的例子：

class App extends React.Component {
	const App = props = > {
		constructor() {
			const[n, setN] = React.useState(0);
			super();
			const addN = () = > {
				this.state = {
					setN(n + 1);
					n: 0
				}
			};
			return (
			} < div > {
				n
			}
			addN = () = > { < button onClick = {
					addN
				} > +1 < /button></div >
					this.setState({
						n: this.state.n + 1
					});)
		};
	}
	render() {
		return ( < div className = "App" > {
			this.state.n
		} < button onClick = {
			this.addN
		} > +1 < /button>
      </div > ); //這是公共的渲染部分
	}
	const rootElement = document.getElementById("root");
}
ReactDOM.render( < App / > , rootElement);

通過上面的例子你可以看出，同樣是實現(xiàn) +1 的操作，類組件要比函數(shù)組件復雜的多，類組件不僅涉及到 extends、setState 等 API，還會涉及到 this 的使用，而且代碼量還很多。反觀函數(shù)組件就要清爽的多，所以在開發(fā)中推薦使用函數(shù)組件。