เครดิตรูปภาพ: Tatiana Rodriguez

React Hooks?

Hooks เป็นฟังก์ชันจาวาสคริปต์ที่ช่วยให้เราใช้ state ได้โดยไม่ต้องเขียนคลาส

ดังนั้น Hooks จะถูกใช้ในส่วนประกอบของฟังก์ชันReact เท่านั้นแทนที่จะเป็นReact Component Classes

จำไว้ว่ากฎที่เราจำเป็นต้องทำตามทำและทำไม่ได้ตามที่ระบุไว้ในเอกสารเบ็ด

• อย่าเรียก Hooks ภายในลูปหรือฟังก์ชันที่ซ้อนกันนับประสาอะไรกับตรรกะเงื่อนไข
• Do Call Hooks ที่จุดบนสุดที่ฟังก์ชัน React ของคุณเริ่มทำงาน

ลองนึกภาพทฤษฎีการทำงานของลำดับหรือบางทีคุณอาจคิดว่าอาร์เรย์ทำงานอย่างไรเพื่อให้เข้าใจได้ดีขึ้น

ในกรณีของกระบวนการเรนเดอร์ใน React Hooksจะถูกเรียกในลำดับเดียวกันทุกประการสำหรับ ทุกการเรนเดอร์ หากคุณสับสนกับลำดับที่เรียกภายในการแสดงผลอาจทำให้ข้อมูลไม่สอดคล้องกัน และสถานการณ์นี้ไม่ได้รับอนุญาต

เราอาจจะผ่านหัวข้อ“ การแกะกล่องวิธีการทำงานของ Hooks”ในบทความนี้หากคุณสนใจแน่นอนว่าคุณอาจพบบทความที่เกี่ยวข้องจากที่อื่น

ก่อนอื่น … Hooks use case!

กฎจำได้ไหม?

1. ใช้มันในส่วนประกอบที่ใช้งานได้แทนคลาส …

2. เรียกพวกเขาที่ด้านบนสุดซึ่งฟังก์ชันเริ่มต้น …

...
const ItemList = props => {
const [limit, setLimit] = useState(5);
   const [page, setPage] = useState(1);
   const [clientData, setClientData] = useState([]);
   const [serverData, serverDataLoaded] = useState([]);
   const [pending_process, setPending_process] = useState(true);
   const [loadmore, setLoadmore] = useState(false);
...
}

นี่คือสิ่งที่เราจะใช้เพื่อจำลองการตอบกลับที่ส่งคืนจากการเรียก API

// delay for 1500ms to simulate a API request time.
// we start with page = 1.
// itemList is a constants dataset as show above.
const ApiRequest = async thePage => {
  await setTimeout(() => {}, 1500);
  return itemList.slice((thePage - 1) * limit, thePage * limit);
};
const requestToServer = async thePage => {
   let data = await ApiRequest(thePage); 
   serverDataLoaded(data);
};

ต่อไปเราจะไปที่Hook “useEffect”

Hook “useEffect”ทำหน้าที่ในจุดประสงค์เดียวกันของกระบวนการอายุการใช้งานบางอย่างนั่นคือcomponentDidMount , componentDidUpdateและcomponentWillUnmountและจะทำผลข้างเคียงในองค์ประกอบการทำงานเฉพาะ

มาเรียกใช้“ API” แบบ DIY เป็นครั้งแรกเพื่อดึงข้อมูลด้วยHook“ useEffect” เราต้องการให้ Hook ทำงานเพียงครั้งเดียวเพื่อรับข้อมูลชุดแรกเมื่อแสดงผลครั้งแรก ดังนั้นเราจึงส่งอาร์เรย์ว่างไปยังอาร์กิวเมนต์ที่สอง

useEffect(() => {
  requestToServer(page); // page => 1
}, []);

เราเพิ่มสิ่งนี้เพื่อจัดการผลข้างเคียงของสถานะserverData
ดูตอนนี้อาร์กิวเมนต์ที่สองถูกป้อนด้วย [serverData] และเราคาดว่าจะมีผลข้างเคียงจากการเปลี่ยนแปลงสถานะserverData : เราจะรวมเข้ากับclientDataเพื่อแสดง

useEffect(() => {
   setClientData([...clientData, ...serverData]);
}, [serverData]);

useEffect(() => {
   requestToServer(page);
}, [page]);

const handleLoadMore = () => {
   setPage(page + 1);
};

Basic FlatList มีลักษณะดังนี้:

<FlatList
   data={clientData}
   renderItem={renderRow}
   onEndReached={handleLoadMore}
   onEndReachedThreshold={0.1}
   onRefresh={() => onRefresh()}
/>

สิ่งที่ต้องเน้นเพิ่มเติมเล็กน้อยที่นี่:

• onEndReachedThreshold | จำนวน
• onEndReached | ฟังก์ชัน
• onRefresh | ฟังก์ชัน
• pending_process | สถานะ
• โหลดเพิ่มเติม | สถานะ

เป็นหน่วยวัดระยะห่างจากขอบด้านล่างของรายการก่อนที่จะonEndReached โทรกลับจะถูกเรียก มีค่าตั้งแต่ 0 – 1 สำหรับค่า 0.1 หมายความว่าเมื่อเนื้อหาถูกเลื่อนถึง90%ของความยาวที่มองเห็นได้onEndReachedจะเริ่มทำงาน!

onRefresh

เป็นการเรียกกลับสำหรับการรีเฟรช การรีเฟรชที่นี่หมายความว่าอย่างไร เป็นพฤติกรรม“ดึงเพื่อรีเฟรช” !

pending_process

เป็นสถานะที่เราใช้เพื่อควบคุมเวลาร้องขอของการเรียก API ทีละรายการเพื่อประโยชน์ในการจัดการข้อมูลและป้องกันสแปม API!

ในขณะที่โหลดเพิ่มเติม

เป็นอีกสถานะหนึ่งที่เราติดตามเพื่อให้สิทธิ์สำหรับการเรียก API ในภายหลังเมื่อมีบันทึกมา!

สังเกตบันทึกด้านล่างเพื่อติดตามได้ดีขึ้น…😉

เอาท์พุต:

FlatList อย่างง่ายพร้อมคำขอ Mock API

ประการที่สาม… API เคลื่อนไหว!

ดูโครงกระดูกสำหรับ Animated.FlatList ด้านล่าง:

import { Animated } from 'react-native';
const ItemList = props => {
  ...
  const [scrollY, setScrollY] = useState(new Animated.Value(0));
  const [op, setOp] = useState(
     scrollY.interpolate({
        inputRange: [0, 50, 100, 150],
        outputRange: [1, 0.5, 0.25, 0]
     }));
   ...
const renderRow = ({item, index, separators}) => {
      return (
        <Animated.View style={{opacity: op}}>
           <ListItem
              style={{ 
                height: ITEM_HEIGHT, 
                backgroundColor: Constants.COLOR.GOLD
              }}>
             <Text style={{color: 'white'}}>{item.name}</Text
           </ListItem>
         </Animated.View>
      )
   }
   ...
return (
      <Animated.FlatList
         ...
         onScroll={Animated.event(
          [
           {
             nativeEvent: {contentOffset: {y: scrollY}},
           },
          ],
          {
            useNativeDriver: true,
            listener: handleScroll
          },
         )}
       />
   );
}

ถูกกำหนดให้ทำหน้าที่เป็นอินสแตนซ์เคลื่อนไหวโดยมีค่าเริ่มต้นเป็น 0

Op : scrollY.interpolate ({inputRange, outputRange})

คือรูปแบบที่เปลี่ยนไปในแง่ของความทึบ[outputRange]เมื่อเทียบกับแกน Y แบบเลื่อน[inputRange] ที่เราคาดไว้

เราจะเพิ่มตรรกะ และการคำนวณบางอย่างสำหรับค่าเคลื่อนไหวใหม่ และเนื้อหาสุดท้ายจะคล้ายกับ …

และผลลัพธ์:

เลื่อนไปที่การเปลี่ยนความทึบด้านบน

ใช่แล้ว! และในที่สุด … เรากำลังมุ่งหน้าไปยังการกำหนดค่าการเพิ่มประสิทธิภาพสำหรับ FlatList!

การปรับแต่งพิเศษ?

1. ใช้ getItemLayout

วิธีนี้เป็นที่ต้องการอย่างมากเนื่องจากจะช่วยลดความต้องการ FlatList ในการรันกระบวนการคำนวณเค้าโครงแบบอะซิงโครนัสบางอย่างหากเราได้กำหนดความสูงสำหรับแต่ละรายการ

2. ใช้อุปกรณ์ประกอบฉาก keyExtractor กับ FlatList

FlatList ใช้อุปกรณ์ประกอบฉากนี้เพื่อทำการแคชและติดตามโดยใช้คีย์ที่ให้มาเป็นหลัก

3. หลีกเลี่ยงการป้อนฟังก์ชันนิรนามให้กับอุปกรณ์ประกอบฉาก “renderItem”

เราเคยย้ายฟังก์ชัน“renderItem”ออกเพื่อป้องกันไม่ให้เกิดการพักผ่อนในแต่ละขั้นตอนการแสดงผล

4. ใช้ useMemo Hooks เพื่อแทนที่ “shouldComponentUpdate”

เราใช้ useMemo Hooks เพื่อสังเกตการเปลี่ยนแปลงของอุปกรณ์ประกอบฉากก่อนแสดงผล ดังที่เคยทำโดย“ shouldComponentUpdate”กับPureComponentของ React

สรุป :

import React, {useState, useEffect, useMemo} from 'react';
import { Dimensions } from 'react-native';
...
...
const {height} = Dimensions.get('window');
const ITEM_HEIGHT = height * 0.25;
const ItemListDemo = props => {
   ...
   ...
const keyExtractor = (item, index) => item.id;
   const getItemLayout = (data, index) => ({
      length: ITEM_HEIGHT,
      offset: ITEM_HEIGHT * index,
      index
   });
return useMemo(() => {
       return (
           <FlatList
             ...
             keyExtractor={keyExtractor}
             data={clientData}
             renderItem={renderRow}
             getItemLayout={getItemLayout}
           />
       );
     }, [clientData, fadingIndex]);
   };
}

เราได้เรียนรู้พื้นฐานสำหรับReact Hooksจากส่วนแรกของบทความและเราได้พบกับประสบการณ์การเขียนโปรแกรมโดยใช้useStateและuseEffect Hooks ในส่วนต่อ ๆ ไป

ประการที่สองเราได้ดำเนินการผ่านFlatList ตั้งแต่เริ่มต้นด้วยตรรกะการดึงข้อมูลตามความต้องการตามด้วยAnimated APIเพื่อควบคุมรูปแบบความทึบของรายการ

ในที่สุดเราก็ได้ผ่านการกำหนดค่าประสิทธิภาพบางอย่างสำหรับFlatListในReact Native !

มันช่วย? มีความสุขในการเขียนโค้ด

หากสิ่งนี้นำทางคุณได้ดี คุณอาจจะแสดงความชื่นชม!

มาถึงท่อนฮุกของเพลงกันค่ะ 

“Cause, baby, you‘re a firework”

“Come on, show ’em what you‘re worth”

      คำว่า “Firework” ในเพลงนี้ สื่อถึงว่าทุกๆ คนก็เหมือนกับดอกไม้ไฟ เหมือนกับพลุ ที่มีความพิเศษ ทุกคนสามารถที่จะทำสิ่งต่างๆ ออกมาให้ดีได้ จงออกไปแสดงความสามารถของเธอให้ทุกคนเห็นซะ

ว่าในตัวทุกคนมีดีอยู่ แค่ขอให้เชื่อมั่นในตัวเอง กล้าเอาไว้ แล้วก็แสดงมันออกมา

      ในส่วนของการเปรียบเทียบเป็นดอกไม้ไฟนั้น ศิลปินอาจจะต้องการสื่อว่า ตอนแรกมันก็แค่ของธรรมดาที่ไม่มีอะไร เหมือนดอกไม้ไฟที่ยังไม่จุด เเต่ถ้าจุดติดเมื่อไหร่ 

(จุด=สร้างความเชื่อมั่นให้ตัวเอง) ก็จะกลายเป็นแสงสว่างที่งดงาม

เพลงต่อไปคือเพลง

“Red” ของ Taylor Swift 

ยกตัวอย่าง

อุปลักษณ์ในเนื้อเพลง

ที่ Taylor เปรียบความรู้สึกของเธอกับคนรักเป็นสีต่างๆ 

 
– “Losing him was blue like I’d never known”

 ความหมายของคำว่า Blue ที่เรารู้ๆ กัน คือ สีฟ้าและความเศร้า ซึ่งในความหมายนี้หมายถึงว่า สูญเสียเขาไปนั้นเหมือนกับสีฟ้า
 

– “Missing him was dark grey all alone”

คำว่า Grey ในที่นี้หมายถึงสีเทาที่แสถงถึงความเหงา เปล่าเปลี่ยวเพียงลำพัง ความหมายก็คือ การคิดถึงเขามันก็เหมือนกับสีเทาเข้มๆ เหงาๆ อยู่เพียงลำพัง 

– “Loving him was red”

สีแดงที่อยู่ในเนื้อเพลงนี้แสดงถึงหลากหลายทางอารมณ์ ทั้งความรัก ความโกรธ ความสับสน ที่ตัว Taylor มีความรู้สึกกับคนรักของเธอ โดยที่อารมณ์เหล่านั้นเหมือนกับสีแดงนั่นเองค่ะ 
 

ยกตัวอย่างอุปมาในเพลง โดยมีคำว่า ‘Like’ เปรียบเทียบอยู่ในเพลง 

– “Forgetting him was like trying to know somebody you never met”

การลืมเขาก็เหมือนกับการพยายามจะทำความรู้จักกับคนที่ไม่เคยพบ 

– “Fighting with him was like trying to solve a crossword and realizing there’s no right answer” 

การทะเลาะกับเขานั้นเหมือนกับการพยายามจะแก้ปริศนาครอสเวิร์ดและเราก็ได้รู้ว่าไม่มีคำตอบที่ถูกเลย

จากทั้งสองเนื้อเพลงจะเห็นได้ว่า มีการใช้คำว่า ‘Like’ เพื่อเปรียบเทียบความรู้สึกของเธอต่อคนรักเป็นสิ่งอื่น