5 praktik terbaik untuk menggunakan kait Bereaksi dalam produksi

Secara singkat tentang hasil penerapan kait

Kekuatan implementasi pengait

• Meningkatkan keterbacaan kode. Ini dimungkinkan berkat penggunaan pohon komponen yang lebih kecil dari sebelumnya. Pembuatan komponen pohon tersebut difasilitasi oleh keinginan kami untuk meninggalkan properti rendering dan komponen tingkat tinggi.
• Meningkatkan kemampuan debugging kode. Kami sudah memiliki perwakilan visual yang ditingkatkan dari kode dan informasi debug tambahan yang disediakan oleh alat pengembang Bereaksi.
• Meningkatkan modularitas proyek. Karena sifat fungsional kait, proses membuat dan menerapkan logika yang cocok untuk penggunaan berulang telah disederhanakan.
• Pemisahan tanggung jawab. Komponen Bereaksi bertanggung jawab atas penampilan elemen antarmuka, dan kait menyediakan akses ke logika program yang dienkapsulasi.

1. Ambil kait tepat waktu dari komponen dan buat kait kustom

1. Komponen lebih kecil daripada dengan kait biasa.
2. Kait dapat digunakan kembali di berbagai komponen.
3. , React, , . , State<StateName> State. React.useState, .

//  

function Component() {
    const [selected, setSelected] = React.useState()
    const select = React.useCallback(id => setSelected(/** ... */), [
        selected,
        setSelect
    ])

    return <List selectedIds={selected} onSelect={id => select(id)} />
}

//   

const useSelection = () => {
    const [selected, setSelected] = React.useState()
    const select = React.useCallback(id => setSelected(/** ... */), [
        selected,
        setSelect
    ])

    return [selected, select]
}

function Component() {
    const [selected, select] = useSelection()

    return <List selectedIds={selected} onSelect={id => select(id)} />
}

2. Tentang manfaat React.useDebugValue

export default function useFeatureToggle(flagName, flagVariation = true) {
    const flags = React.useContext(FlagsContext)
    const isFeatureEnabled = getIsFeatureEnabled(flagName, flagVariation)(flags)

    React.useDebugValue({
        flagName,
        flagVariation,
        isEnabled: isFeatureEnabled
    })

    return isFeatureEnabled
}

3. Kombinasi dan komposisi kait

function OrderCreate() {
    const {
        orderCreater,
        orderFetcher,
        applicationContext,
        goToNextStep,
        pendingOrder,
        updatePendingChanges,
        revertPendingChanges
    } = useOrderCreate()

    return (/** ...children */)
}

4. Perbandingan React.useReducer dan React.useState

const initialState = 0;
const reducer = (state, action) => {
    switch (action) {
        case 'increment': return state + 1;
        case 'decrement': return state - 1;
        case 'reset': return 0;
        default: throw new Error('Unexpected action');
    }
};

function Component() {
    const [count, dispatch] = React.useReducer(reducer, initialState);

    return (
        <div>
            {count}
            <button onClick={() => dispatch('increment')}>+1</button>
            <button onClick={() => dispatch('decrement')}>-1</button>
            <button onClick={() => dispatch('reset')}>reset</button>
        </div>
    );
};

const CounterActionTypes = {
    Increment: 'increment',
    Decrement: 'decrement',
    Reset: 'reset',
}

const useCounterReducer = (initialState) => {
    const [count, dispatch] = React.useReducer(reducer, initialState);

    const increment = React.useCallback(() => dispatch(CounterActionTypes.Increment));
    const decrement = React.useCallback(() => dispatch(CounterActionTypes.Decrement));
    const reset = React.useCallback(() => dispatch(CounterActionTypes.Reset));

    return {
        count,
        increment,
        decrement
    }
}

function Component() {
    const {count, increment} = useCounterReducer(0);

    return (
        <div>
            {count}
            <button onClick={increment}>+1</button>
        </div>
    );
};

5. Implementasi kait secara bertahap

export const injectTracking = (propName = 'tracking') => WrappedComponent => {
    const WithTracking = props => {
        const tracking = useTracking();

        const trackingProp = {
            [propName]: tracking,
        };

        return <WrappedComponent {...props} {...trackingProp} />;
    };

    WithTracking.displayName = wrapDisplayName(WrappedComponent, 'withTracking');

    return WithTracking;
};

export default injectTracking;

Ringkasan