คำจำกัดความประเภทสำหรับ React Hooks ใน TypeScript คืออะไร

เฮ้! ในฐานะซัพพลายเออร์ hooks เมื่อเร็ว ๆ นี้ฉันได้รับคำถามมากมายเกี่ยวกับคำจำกัดความประเภทสำหรับ React Hooks ใน TypeScript ฉันก็เลยคิดว่าจะนั่งเขียนบล็อกโพสต์เพื่อแบ่งปันสิ่งที่ฉันรู้

ก่อนอื่น เรามาพูดถึงสาเหตุที่คำจำกัดความของประเภทมีความสำคัญมากเมื่อทำงานกับ React Hooks ใน TypeScript TypeScript เป็นชุดการพิมพ์ของ JavaScript ที่เพิ่มการพิมพ์แบบคงที่ให้กับภาษา ซึ่งหมายความว่าคุณสามารถตรวจพบข้อผิดพลาดได้ตั้งแต่เนิ่นๆ ในกระบวนการพัฒนาโดยการกำหนดประเภทของตัวแปร พารามิเตอร์ฟังก์ชัน และค่าที่ส่งคืนอย่างชัดเจน เมื่อใช้ React Hooks ซึ่งเป็นฟีเจอร์ที่ค่อนข้างใหม่และมีประสิทธิภาพใน React การมีคำจำกัดความประเภทที่เหมาะสมจะทำให้โค้ดของคุณมีประสิทธิภาพมากขึ้น เข้าใจง่ายขึ้น และเกิดข้อผิดพลาดน้อยลง

ใช้State Hook

มาเริ่มกันที่ใช้สถานะhook ซึ่งเป็นหนึ่งใน hooks ที่ใช้บ่อยที่สุดใน React ที่ใช้สถานะhook ช่วยให้คุณสามารถเพิ่มสถานะให้กับองค์ประกอบการทำงานได้ ต่อไปนี้คือวิธีที่คุณสามารถกำหนดประเภทได้ใช้สถานะใน TypeScript:

นำเข้าปฏิกิริยา { useState } จาก 'ปฏิกิริยา'; // กำหนดประเภทของสถานะประเภท CounterState = number; const Counter: React.FC = () => { // ใช้ประเภทที่กำหนดไว้สำหรับสถานะ const [count, setCount] = useState<CounterState>(0); const เพิ่มขึ้น = () => { setCount (นับ + 1); - กลับ ( <div> <p>นับ: {count}</p> <ปุ่ม onClick={increat}>เพิ่มขึ้น</button> </div> ); - ส่งออกตัวนับเริ่มต้น;

ในตัวอย่างนี้ ก่อนอื่นเราจะกำหนดประเภทเคาน์เตอร์สเตทซึ่งแสดงถึงประเภทของสถานะที่เราต้องการใช้ จากนั้นเมื่อโทรไปที่ใช้สถานะhook เราระบุพารามิเตอร์ประเภท<เคาน์เตอร์สเตท>- สิ่งนี้จะบอก TypeScript ว่านับตัวแปรจะเป็นประเภทตัวเลขและตั้งค่านับฟังก์ชั่นจะยอมรับตัวเลขเป็นข้อโต้แย้ง

ใช้เอฟเฟกต์ตะขอ

ที่ใช้เอฟเฟกต์hook ใช้เพื่อแสดงผลข้างเคียงในส่วนประกอบการทำงาน เมื่อใช้ใช้เอฟเฟกต์ใน TypeScript คุณไม่จำเป็นต้องระบุคำจำกัดความประเภทใดๆ สำหรับ hook เอง อย่างไรก็ตาม คุณอาจต้องกำหนดประเภทของตัวแปรและฟังก์ชันที่ใช้ภายในใช้เอฟเฟกต์โทรกลับ

นำเข้า React, { useState, useEffect } จาก 'ปฏิกิริยา'; พิมพ์ข้อมูล = { ชื่อ: สตริง; อายุ: หมายเลข; - const DataFetcher: React.FC = () => { const [data, setData] = useState <ข้อมูล | โมฆะ>(โมฆะ); useEffect(() => { const fetchData = async () => { const response = await fetch('https://example.com/api/data'); const result: Data = await response.json(); setData(result); - fetchData(); }, []); if (!data) { return <p>กำลังโหลด...</p>; } ส่งคืน ( <div> <p>ชื่อ: {data.name}</p> <p>อายุ: {data.age}</p> </div> ); - ส่งออก DataFetcher เริ่มต้น;

ในตัวอย่างนี้ เรากำหนดประเภทข้อมูลซึ่งแสดงถึงรูปร่างของข้อมูลที่เราคาดว่าจะดึงมา เราใช้ประเภทนี้เมื่อกำหนดสถานะข้อมูลโดยใช้ใช้สถานะตะขอ. ภายในใช้เอฟเฟกต์โทรกลับ เราก็ใช้ข้อมูลtype เพื่อระบุประเภทของผลลัพธ์ตัวแปรเมื่อแยกวิเคราะห์การตอบสนอง JSON

ใช้ Context Hook

ที่ใช้บริบทhook ใช้เพื่อเข้าถึงบริบทในองค์ประกอบการทำงาน เมื่อใช้ใช้บริบทใน TypeScript คุณต้องกำหนดประเภทของบริบท

นำเข้า React, { createContext, useContext } จาก 'react'; // กำหนดประเภทของประเภทค่าบริบท ThemeContextType = 'light' | 'มืด'; // สร้างบริบทด้วยประเภทที่กำหนดไว้ const ThemeContext = createContext<ThemeContextType>('light'); const ThemeProvider = ThemeContext.Provider; const ThemeDisplay: React.FC = () => { const theme = useContext (ThemeContext); กลับ <p>ธีมปัจจุบัน: {theme}</p>; - แอป const: React.FC = () => { return ( <ThemeProvider value="dark"> <ThemeDisplay /> </ThemeProvider> ); - ส่งออกแอปเริ่มต้น

ในตัวอย่างนี้ ก่อนอื่นเราจะกำหนดประเภทThemeContextTypeซึ่งแสดงถึงคุณค่าที่เป็นไปได้ของบริบท จากนั้นเมื่อสร้างบริบทโดยใช้สร้างบริบทเราระบุพารามิเตอร์ประเภท<ThemeContextType>- เพื่อให้แน่ใจว่าค่าที่ให้ไว้กับThemeProviderและมูลค่าที่เข้าถึงได้โดยใช้ใช้บริบทเป็นประเภทที่ถูกต้อง

ใช้ตะขอลดขนาด

ที่ใช้ลดhook เป็นทางเลือกแทนใช้สถานะสำหรับการจัดการตรรกะสถานะที่ซับซ้อนมากขึ้น เมื่อใช้ใช้ลดใน TypeScript คุณต้องกำหนดประเภทของสถานะ การดำเนินการ และฟังก์ชันตัวลด

นำเข้าปฏิกิริยา { useReducer } จาก 'ปฏิกิริยา'; // กำหนดประเภทของประเภทสถานะ CounterState = { count: number; - // กำหนดประเภทของประเภทการกระทำ CounterAction = | { ประเภท: 'ส่วนเพิ่ม' } | { ประเภท: 'ลดลง' - // กำหนดฟังก์ชันตัวลดด้วยประเภท const counterReducer = ( state: CounterState, action: CounterAction ): CounterState => { switch (action.type) { case 'increase': return { count: state.count + 1 - กรณี 'ลดลง': กลับ { นับ: state.count - 1 - ค่าเริ่มต้น: สถานะการส่งคืน; } - ตัวนับ const: React.FC = () => { const [สถานะ, การจัดส่ง] = useReducer (counterReducer, { นับ: 0 }); return ( <div> <p>นับ: {state.count}</p> <button onClick={() => จัดส่ง ({ ประเภท: 'เพิ่มขึ้น' })}>เพิ่มขึ้น</button> <ปุ่มonClick={() => จัดส่ง({ ประเภท: 'ลดลง' })}>ลดลง</button> </div> ); - ส่งออกตัวนับเริ่มต้น;

ในตัวอย่างนี้ เรากำหนดประเภทเคาน์เตอร์สเตทซึ่งแสดงถึงรูปร่างของรัฐและประเภทเคาน์เตอร์แอคชั่นซึ่งแสดงถึงการกระทำที่เป็นไปได้ที่สามารถส่งได้ ที่เคาน์เตอร์รีดิวเซอร์ฟังก์ชั่นรับสถานะปัจจุบันและการกระทำเป็นอาร์กิวเมนต์และส่งกลับสถานะใหม่ โดยการกำหนดประเภทเหล่านี้ เรารับรองว่าใช้ลดhook และฟังก์ชันที่โต้ตอบกับมันจะใช้ประเภทที่ถูกต้อง

Hooks แบบกำหนดเองและคำจำกัดความประเภท

เมื่อสร้าง hooks แบบกำหนดเองใน TypeScript การกำหนดคำจำกัดความประเภทที่เหมาะสมก็เป็นสิ่งสำคัญเช่นกัน สมมติว่าเรามี hook แบบกำหนดเองเพื่อจัดการอินพุตแบบฟอร์ม:

นำเข้าปฏิกิริยา { useState } จาก 'ปฏิกิริยา'; // กำหนดประเภทของรูปแบบการป้อนข้อมูลประเภท FormInput = { value: string; ข้อผิดพลาด: สตริง | โมฆะ; - // กำหนด hook แบบกำหนดเองด้วยประเภท const useFormInput = (initialValue: string): FormInput => { const [value, setValue] = useState(initialValue); const [ข้อผิดพลาด setError] = useState<string | โมฆะ>(โมฆะ); const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => { setValue(e.target.value); if (e.target.value.length < 3) { setError('อินพุตต้องมีอย่างน้อย 3 ตัวอักษร'); } อื่น { setError (null); } - กลับ { ค่า, ข้อผิดพลาด - - แบบฟอร์ม const: React.FC = () => { const { ค่า, ข้อผิดพลาด } = useFormInput (''); return ( <form> <input type="text" value={value} onChange={handleChange} /> {error && <p style={{ color: 'red' }}>{error}</p>} <button type="submit">ส่ง</button> </form> ); - แบบฟอร์มการส่งออกเริ่มต้น;

ในตัวอย่างนี้ เรากำหนดประเภทแบบฟอร์มอินพุตซึ่งแสดงถึงรูปร่างของข้อมูลที่ส่งคืนโดย hook แบบกำหนดเอง ตะขอแบบกำหนดเองใช้แบบฟอร์มอินพุตรับค่าเริ่มต้นเป็นอาร์กิวเมนต์และส่งกลับวัตถุประเภทแบบฟอร์มอินพุต- เพื่อให้แน่ใจว่าส่วนประกอบที่ใช้ hook แบบกำหนดเองสามารถจัดการข้อมูลที่ส่งคืนได้อย่างเหมาะสม

บทสรุป

โดยสรุป การใช้คำจำกัดความประเภทที่เหมาะสมสำหรับ React Hooks ใน TypeScript เป็นสิ่งจำเป็นสำหรับการเขียนโค้ดที่สะอาด บำรุงรักษาได้ และปราศจากข้อผิดพลาด ไม่ว่าคุณจะใช้ตะขอในตัวเช่นใช้สถานะ-ใช้เอฟเฟกต์-ใช้บริบท-ใช้ลดหรือสร้าง hooks ที่คุณกำหนดเอง การสละเวลาเพื่อกำหนดประเภทที่ถูกต้องสามารถช่วยให้คุณไม่ต้องปวดหัวได้มากในระยะยาว

ในฐานะซัพพลายเออร์ตะขอ ฉันเข้าใจถึงความสำคัญของการจัดหาผลิตภัณฑ์คุณภาพสูงและเชื่อถือได้ เรามีตะขอหลากหลายประเภทสำหรับความต้องการอุปกรณ์ในซุปเปอร์มาร์เก็ตของคุณ ซึ่งรวมถึงตะขอเพ็กบอร์ดและตะขอ Slatwall- ตะขอเหล่านี้ได้รับการออกแบบให้มีความทนทาน ใช้งานได้จริง และติดตั้งง่าย ทำให้เป็นตัวเลือกที่ยอดเยี่ยมสำหรับซูเปอร์มาร์เก็ตหรือร้านค้าปลีก

หากคุณสนใจที่จะเรียนรู้เพิ่มเติมเกี่ยวกับ hooks ของเรา หรือมีคำถามใดๆ เกี่ยวกับคำจำกัดความประเภทสำหรับ React Hooks ใน TypeScript โปรดติดต่อเราเพื่อพูดคุยอย่างเป็นมิตรและหารือเกี่ยวกับการจัดซื้อจัดจ้าง

อ้างอิง

• โต้ตอบเอกสารอย่างเป็นทางการ
• เอกสารอย่างเป็นทางการของ TypeScript