最近在团队中落地Flutter vs React Native 2021 对比， and accumulated quite a bit of experience. Here's a summary for reference, hoping it helps those doing similar work.

Core Concepts

Here is a complete example:

import React, { useState, useCallback } from 'react'
import { View, Text, FlatList, TouchableOpacity, StyleSheet } from 'react-native'

const ItemList = ({ data, onRefresh }) => {
  const [refreshing, setRefreshing] = useState(false)
  const handleRefresh = useCallback(async () => {
    setRefreshing(true)
    await onRefresh()
    setRefreshing(false)
  }, [onRefresh])

  const renderItem = useCallback(({ item }) => (
    <TouchableOpacity style={styles.item}>
      <Text style={styles.title}>{item.title}</Text>
    </TouchableOpacity>
  ), [])

  return (
    <FlatList data={data} renderItem={renderItem}
      keyExtractor={item => item.id}
      refreshing={refreshing} onRefresh={handleRefresh} />
  )
}

Pay attention to boundary condition handling, which is critical in production.

In-Depth Analysis

The key lies in understanding the core logic:

import { useRef, useEffect, useState } from 'react'

function useIntersectionObserver(options = {}) {
  const [isVisible, setIsVisible] = useState(false)
  const ref = useRef(null)

  useEffect(() => {
    const observer = new IntersectionObserver(([entry]) => {
      setIsVisible(entry.isIntersecting)
    }, { threshold: 0.1, ...options })
    const el = ref.current
    if (el) observer.observe(el)
    return () => { if (el) observer.unobserve(el) }
  }, [])

  return [ref, isVisible]
}

Performance optimization should be tailored to specific scenarios; not all cases require over-optimization.

Implementation Experience

We can improve it in the following ways:

import { useReducer, useCallback } from 'react'

const initialState = { items: [], filter: '', sort: 'date' }

function reducer(state, action) {
  switch (action.type) {
    case 'SET_ITEMS': return { ...state, items: action.payload }
    case 'SET_FILTER': return { ...state, filter: action.payload }
    case 'ADD_ITEM': return { ...state, items: [...state.items, action.payload] }
    case 'REMOVE_ITEM': return { ...state, items: state.items.filter(i => i.id !== action.payload) }
    default: throw new Error(`Unknown: ${action.type}`)
  }
}

This approach has been running stably in production for over six months and has been practically validated.

Optimization Strategies

Let's start with the basic implementation:

import { useState, useEffect, useCallback } from 'react'

function DataList({ endpoint, pageSize = 20 }) {
  const [data, setData] = useState([])
  const [page, setPage] = useState(1)
  const [loading, setLoading] = useState(false)

  const fetchData = useCallback(async () => {
    setLoading(true)
    try {
      const res = await fetch(`${endpoint}?page=${page}&size=${pageSize}`)
      setData(await res.json())
    } finally { setLoading(false) }
  }, [endpoint, page, pageSize])

  useEffect(() => { fetchData() }, [fetchData])

  return <div>{loading ? <Spinner /> : <List items={data} />}</div>
}

This code demonstrates the basic usage. In real projects, you also need to consider error handling and edge cases.

Important Notes

Building on this foundation, we can further optimize:

import React, { useState, useCallback } from 'react'
import { View, Text, FlatList, TouchableOpacity, StyleSheet } from 'react-native'

const ItemList = ({ data, onRefresh }) => {
  const [refreshing, setRefreshing] = useState(false)
  const handleRefresh = useCallback(async () => {
    setRefreshing(true)
    await onRefresh()
    setRefreshing(false)
  }, [onRefresh])

  const renderItem = useCallback(({ item }) => (
    <TouchableOpacity style={styles.item}>
      <Text style={styles.title}>{item.title}</Text>
    </TouchableOpacity>
  ), [])

  return (
    <FlatList data={data} renderItem={renderItem}
      keyExtractor={item => item.id}
      refreshing={refreshing} onRefresh={handleRefresh} />
  )
}

This pattern is very practical in large projects and can significantly reduce maintenance costs.

Summary

• In team collaboration, conventions and documentation are more important than the technology itself
• Stay updated with the community; technical solutions need continuous iteration
• Don't adopt new technology just for the sake of it