SolidJS 2.0 ನೇಟಿವ್ async-data ಮಾಡೆಲ್ನೊಂದಿಗೆ ಬಿಡುಗಡೆಯಾಗುತ್ತಿದೆ, ಇದು ಒಂದು ಕಾಂಪೊನೆಂಟ್ ಪ್ರಾಮಿಸ್ ಅನ್ನು (promise) ಇತರ ಯಾವುದೇ ರಿಯಾಕ್ಟಿವ್ ವ್ಯಾಲ್ಯೂ (reactive value) ರೀತಿ ಪರಿಗಣಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. React ಡೆವಲಪರ್ಗಳು Suspense ಮತ್ತು hooks ಬಳಸುವಾಗ ಎದುರಿಸುವ ಸತತ ರೀ-ರೆಂಡರ್ಗಳ (re-renders) ಸಮಸ್ಯೆ ಇಲ್ಲದೆ ಇದು ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಈ ಬದಲಾವಣೆ ಮುಖ್ಯವಾಗಿದೆ ಏಕೆಂದರೆ ಇದು ಡೇಟಾ ರಿಫ್ರೆಶ್ ಆಗುವಾಗ UI ಅನ್ನು ಪರದೆಯ ಮೇಲೆ ಇರಿಸುತ್ತದೆ, ಬಾಯ್ಲರ್ಪ್ಲೇಟ್ (boilerplate) ಕೋಡ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು React ತಂಡಗಳು ತಮ್ಮ ಡೇಟಾ-ಫೆಚಿಂಗ್ ಕೋಡ್ ಅನ್ನು Solid ಗೆ ವರ್ಗಾಯಿಸಲು ಒಂದು ಸ್ಪಷ್ಟ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ.
Solid ನ async ಮಾಡೆಲ್ ಏಕೆ ವಿಭಿನ್ನವಾಗಿ ಕಾಣುತ್ತದೆ
React ನಲ್ಲಿ, ಡೇಟಾ ಬೇಕಾದ ಕಾಂಪೊನೆಂಟ್ ಸಾಮಾನ್ಯವಾಗಿ ಒಂದು hook ಅನ್ನು (ಅದು ಹೆಚ್ಚಾಗಿ ಕಸ್ಟಮ್ ಆಗಿರುತ್ತದೆ) ಕರೆಯುತ್ತದೆ, ಇದು ಪ್ರಾಮಿಸ್ನಂತಹ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ನಂತರ ಪ್ರಾಮಿಸ್ ಪರಿಹರಿಸಲ್ಪಡುವವರೆಗೆ (resolves) ಫಾಲ್ಬ್ಯಾಕ್ (fallback) ತೋರಿಸಲು UI ಅನ್ನು <Suspense> ನಲ್ಲಿ ಸುತ್ತುವರಿಯುತ್ತದೆ. ಪ್ರಾಮಿಸ್ ಪ್ರತಿ ಬಾರಿಯೂ ಸೆಟಲ್ ಆದಾಗ, React ರೀ-ರೆಂಡರ್ ಅನ್ನು ಶೆಡ್ಯೂಲ್ ಮಾಡುತ್ತದೆ; ಅದೇ ಕಾಂಪೊನೆಂಟ್ ನಂತರ ಡೇಟಾವನ್ನು ಮರು-ಪಡೆಯಲು (refetch) ಪ್ರಯತ್ನಿಸಿದರೆ, ಈಗಾಗಲೇ ಕಾಣಿಸುತ್ತಿರುವ ಕಂಟೆಂಟ್ ಮೇಲೆ ಫಾಲ್ಬ್ಯಾಕ್ ಕ್ಷಣಿಕವಾಗಿ ಕಾಣಿಸಿಕೊಳ್ಳಬಹುದು.
Solid ಇದನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಬದಲಾಯಿಸುತ್ತದೆ. ಪ್ರಾಮಿಸ್ ಎಂಬುದು ಕೇವಲ ರಿಯಾಕ್ಟಿವ್ ಗ್ರಾಫ್ (reactive graph) ಗಮನಿಸುವ ಒಂದು ವ್ಯಾಲ್ಯೂ ಆಗಿದೆ. ಒಂದು ಕಂಪ್ಯೂಟೇಶನ್ ಆ ವ್ಯಾಲ್ಯೂ ಅನ್ನು ಓದಿದಾಗ, ಪ್ರಾಮಿಸ್ ಪರಿಹರಿಸಲ್ಪಡುವವರೆಗೆ ಗ್ರಾಫ್ ಆ ಓದನ್ನು ನಿಲ್ಲಿಸುತ್ತದೆ, ಆದರೆ ಉಳಿದ UI ರೆಂಡರ್ ಆಗಿಯೇ ಇರುತ್ತದೆ. ಕಾಂಪೊನೆಂಟ್ ಮೊದಲ ಬಾರಿಗೆ ಮೌಂಟ್ ಆದಾಗ, <Loading> ಬೌಂಡರಿ ಫಾಲ್ಬ್ಯಾಕ್ ಅನ್ನು ತೋರಿಸಬಹುದು; ಅದರ ನಂತರ, ಹೊಸ ಡೇಟಾ ಬರುವವರೆಗೆ ರೀಫೆಚ್ ಮಾಡುವುದರಿಂದ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ DOM ನಲ್ಲಿ ಯಾವುದೇ ಬದಲಾವಣೆ ಆಗುವುದಿಲ್ಲ. ಕಾಂಪೊನೆಂಟ್ ಒಳಗೆ ಯಾವುದೇ ಸ್ಪಷ್ಟವಾದ “await”, createResource ಅಥವಾ ಮ್ಯಾನುಯಲ್ ಸ್ಟೇಟ್ ಟೋಗಲ್ಸ್ಗಳ ಅಗತ್ಯವಿಲ್ಲ.
ಮೂಲ ಪ್ರಿಮಿಟಿವ್ಸ್ (The core primitives)
<Loading>boundary – React ನ<Suspense>ಅನ್ನು ಇದು ಬದಲಾಯಿಸುತ್ತದೆ. ಇದು ಕೇವಲ ಆರಂಭಿಕ ಲೋಡ್ ಸಮಯದಲ್ಲಿ ಮಾತ್ರ ಫಾಲ್ಬ್ಯಾಕ್ ಅನ್ನು ತೋರಿಸುತ್ತದೆ. ಮೊದಲ ಪೇಂಟ್ ನಂತರ, ಪೆಂಡಿಂಗ್ ರೀಡ್ UI ಅನ್ನು ಬದಲಾಯಿಸುವುದಿಲ್ಲ; ಹೊಸ ವ್ಯಾಲ್ಯೂ ಪರಿಹರಿಸಲ್ಪಡುವವರೆಗೆ ಹಳೆಯ ಕಂಟೆಂಟ್ ಹಾಗೆಯೇ ಇರುತ್ತದೆ. ನಿರ್ದಿಷ್ಟ ರೀಫೆಚ್ ಸಮಯದಲ್ಲಿ ಸ್ಪಿನರ್ (spinner) ತೋರಿಸಲುonಪ್ರಾಪನ್ನು (prop) ಬಳಸಿ.<Reveal>component – ಹಲವಾರು<Loading>ಬೌಂಡರಿಗಳು ಒಟ್ಟಿಗೆ ಹೇಗೆ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತವೆ ಎಂಬುದನ್ನು ಇದು ನಿಯಂತ್ರಿಸುತ್ತದೆ. ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಆರಿಸಿ:- Sequential: ಬೌಂಡರಿಗಳು DOM ಕ್ರಮದಲ್ಲಿ ಒಂದರ ನಂತರ ಒಂದರಂತೆ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತವೆ.
- Together: ಎಲ್ಲಾ ಡೇಟಾ ಸಿದ್ಧವಾದಾಗ ಎಲ್ಲವೂ ಒಟ್ಟಿಗೆ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತವೆ.
- Natural: ಪ್ರತಿಯೊಂದು ಡೇಟಾ ಬಂದ ತಕ್ಷಣ ಅದು ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ.
isPendingsignal – ಒಂದು ನಿರ್ದಿಷ್ಟ ರೀಡ್ ನಡೆಯುತ್ತಿರುವಾಗtrueಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಮುಖ್ಯ ಕಂಟೆಂಟ್ ಕಾಣಿಸುತ್ತಿರುವಾಗಲೇ ಒಂದು ಸಣ್ಣ ಲೋಡಿಂಗ್ ಬಾರ್ ಅಥವಾ ಸೂಕ್ಷ್ಮ ಅನಿಮೇಷನ್ ತೋರಿಸಲು ಇದನ್ನು ಬಳಸಿ, ಇದು ನಿಮಗೆ ಉಚಿತವಾಗಿ “stale-while-revalidate” ಅನುಭವ ನೀಡುತ್ತದೆ.actiongenerator – React ನ ಮ್ಯುಟೇಬಲ್-ಸ್ಟೇಟ್ ಅಪ್ಡೇಟ್ಗಳನ್ನು ಇದು ಬದಲಾಯಿಸುತ್ತದೆ. ಒಂದುaction(function*…)UI ಅನ್ನು ಆಪ್ಟಿಮಿಸ್ಟಿಕ್ ಆಗಿ (optimistically) ಅಪ್ಡೇಟ್ ಮಾಡಬಹುದು, ಸರ್ವರ್ ಪ್ರತಿಕ್ರಿಯೆಗಾಗಿyieldಮಾಡಬಹುದು, ನಂತರ ಪ್ರಾಮಿಸ್ ಪರಿಹರಿಸಲ್ಪಟ್ಟಾಗ ಫಲಿತಾಂಶವನ್ನು ಹೊಂದಾಣಿಕೆ (reconcile) ಮಾಡಬಹುದು. UI ತಕ್ಷಣವೇ ಕೆಲಸ ಮಾಡಿದಂತೆ ಭಾಸವಾಗುತ್ತದೆ ಮತ್ತು ಈ ಹೊಂದಾಣಿಕೆಯ ಹಂತವು ಪ್ರಿಮಿಟಿವ್ನಲ್ಲೇ ಅಳವಡಿಸಲಾಗಿದೆ.
ಈ ಭಾಗಗಳು React ಪರಿಕಲ್ಪನೆಗಳಿಗೆ ಹೇಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತವೆ
| ವೈಶಿಷ್ಟ್ಯ (Feature) | React ವಿಧಾನ (React approach) | Solid 2.0 ವಿಧಾನ (Solid 2.0 approach) |
|---|---|---|
| ಡೇಟಾ ಫೆಚಿಂಗ್ (Data fetching) | use() (experimental) ಅಥವಾ ಥರ್ಡ್-ಪಾರ್ಟಿ hooks; ಫಲಿತಾಂಶವು <Suspense> ನಲ್ಲಿ ಸುತ್ತುವರಿಯಲ್ಪಟ್ಟಿರುತ್ತದೆ |
ಪ್ರಾಮಿಸ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುವ createMemo (ಅಥವಾ ಅಂತಹದ್ದೇ); ನೇರವಾಗಿ JSX ನಲ್ಲಿ ಓದಬಹುದು |
| ಲೋಡಿಂಗ್ UI (Loading UI) | ಪ್ರತಿ ರೀಫೆಚ್ನಲ್ಲಿ <Suspense> ಫಾಲ್ಬ್ಯಾಕ್ ಅನ್ನು ಮತ್ತೆ ಪ್ರಚೋದಿಸಬಹುದು |
<Loading> ಕೇವಲ ಮೊದಲ ಲೋಡ್ನಲ್ಲಿ ಮಾತ್ರ; ರೀಫೆಚ್ ಹಳೆಯ UI ಅನ್ನು ಉಳಿಸಿಕೊಳ್ಳುತ್ತದೆ |
| ರಿಫ್ರೆಶ್ ಮಾಡುವುದು (Refreshing) | UI ಅಪ್ಡೇಟ್ಗಳನ್ನು ವಿಳಂಬಗೊಳಿಸಲು useTransition |
UI ಬದಲಾಯಿಸದೆ ಪೆಂಡಿಂಗ್ ರೀಡ್ಗಳನ್ನು isPending ಸೂಚಿಸುತ್ತದೆ |
| ಮ್ಯುಟೇಶನ್ಗಳು (Mutations) | useState/useReducer + async ಕರೆಗಳು, ಹೆಚ್ಚಾಗಿ ಕಸ್ಟಮ್ ಆಕ್ಷನ್ಗಳಲ್ಲಿ ಸುತ್ತುವರಿಯಲ್ಪಟ್ಟಿರುತ್ತವೆ |
ಬಿಲ್ಟ್-ಇನ್ ಆಪ್ಟಿಮಿಸ್ಟಿಕ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್ನೊಂದಿಗೆ action(function*…) |
ಇದರ ಪ್ರಾಯೋಗಿಕ ಸಾರಾಂಶವೆಂದರೆ, React ಪ್ರತ್ಯೇಕ hooks ಎಂದು ಪರಿಗಣಿಸುವ ವಿಷಯಗಳನ್ನು Solid ತನ್ನ ಕೋರ್ ರಿಯಾಕ್ಟಿವಿಟಿ ಇಂಜಿನ್ನಲ್ಲೇ ನಿರ್ಮಿಸಿದೆ.
ಹಂತ-ಹಂತದ ಮೈಗ್ರೇಶನ್ ಮಾರ್ಗದರ್ಶಿ (A step-by-step migration guide)
- ದತ್ತಾಂಶದ ಮೂಲವನ್ನು ಗುರುತಿಸಿ – React ನಲ್ಲಿ ನೀವು ಬಹುಶಃ
const data = useMyFetch(url)ಅನ್ನು ಹೊಂದಿರುತ್ತೀರಿ. Solid ನಲ್ಲಿ ಅದನ್ನು ಪ್ರಾಮಿಸ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುವ ಮೆಮೋ (memo) ಮೂಲಕ ಬದಲಾಯಿಸಿ:const data = createMemo(() => fetch(url).then(r => r.json())). - ಟಾಪ್-ಲೆವೆಲ್ ಘಟಕವನ್ನು (component) ಸುತ್ತುವರಿಯಿರಿ – ಪ್ರಾಮಿಸ್ ಪರಿಹರಿಸುವ (resolve) ಮೊದಲು ಘಟಕವು ರೆಂಡರ್ ಆಗುತ್ತಿದ್ದರೆ, ಅದನ್ನು
<Loading fallback={<Spinner/>}>…</Loading>ಮೂಲಕ ಸುತ್ತುವರಿಯಿರಿ. ಫಾಲ್ಬ್ಯಾಕ್ (fallback) ಮೊದಲ ಮೌಂಟ್ನಲ್ಲಿ ಮಾತ್ರ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ. - ಪ್ರತಿ ರಿಫೆಚ್ (refetch) ಸ್ಪಿನ್ನರ್ಗಳನ್ನು ಬದಲಾಯಿಸಿ – ನೀವು ಈ ಮೊದಲು ಲೋಡಿಂಗ್ ಫ್ಲಾಗ್ ಅನ್ನು ಟೋಗಲ್ ಮಾಡುತ್ತಿದ್ದಲ್ಲಿ, ಈಗ
isPending(data)ಅನ್ನು ಓದಿ. ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ UI ಪರದೆಯ ಮೇಲೆ ಇರುವಾಗ, ಸೂಕ್ಷ್ಮ ಸೂಚಕವನ್ನು (subtle indicator) ರೆಂಡರ್ ಮಾಡಲು ಆ ಬೂಲಿಯನ್ ಅನ್ನು ಬಳಸಿ. - ಆಪ್ಟಿಮಿಸ್ಟಿಕ್ ಅಪ್ಡೇಟ್ಗಳನ್ನು (optimistic updates) ಪರಿವರ್ತಿಸಿ – ನೀವು
setState(prev => ({...prev, optimisticValue}))ನಂತರ ಅಸಿಂಕ್ ಕರೆಯನ್ನು ಬಳಸಿದ್ದರೆ, ಅದನ್ನುconst update = action(function* (newValue) { state = newValue; const server = yield fetch(...); state = reconcile(server); });ಎಂದು ಮರುಬರೆಯಿರಿ. ಸರ್ವರ್ ಪ್ರತಿಕ್ರಿಯಿಸುವವರೆಗೆ ಜನರೇಟರ್ ನಿಯಂತ್ರಣವನ್ನು ನೀಡುತ್ತದೆ (yields control), ನಂತರ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ರಿಯಾಕ್ಟಿವ್ ಗ್ರಾಫ್ ಅನ್ನು ಅಪ್ಡೇಟ್ ಮಾಡುತ್ತದೆ. - ಹಲವು ಅಸಿಂಕ್ ಭಾಗಗಳನ್ನು ನಿರ್ವಹಿಸಿ – ಅಗತ್ಯವಿರುವಂತೆ
<Loading>ಬೌಂಡರಿಗಳನ್ನು ನೆಸ್ಟ್ ಮಾಡಿ, ನಂತರ ಅವು ಒಟ್ಟಿಗೆ ಕಾಣಿಸಬೇಕೆ ಅಥವಾ ಒಂದಾದ ನಂತರ ಒಂದರಂತೆ ಕಾಣಿಸಬೇಕೆ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸಲು<Reveal>ವ್ರಾಪರ್ ಅನ್ನು ಸೇರಿಸಿ. ಇದು React ಡೆವಲಪರ್ಗಳು ಸಂಕೀರ್ಣ ಸ್ಟೇಟ್ ಚೆಕ್ಗಳೊಂದಿಗೆ ಹಲವಾರು<Suspense>ಘಟಕಗಳನ್ನು ಬಳಸುತ್ತಿದ್ದ ಮಾದರಿಯನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ. - ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪರೀಕ್ಷಿಸಿ – Solid ಪ್ರಾಮಿಸ್ ಪರಿಹಾರದ ಮೇಲೆ ಮರು-ರೆಂಡರ್ (re-render) ಆಗುವುದಿಲ್ಲದ ಕಾರಣ, UI ಅಪ್ಡೇಟ್ಗಳು ನೀವು ನಿರೀಕ್ಷಿಸಿದಂತೆ ನಡೆಯುತ್ತಿವೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ರಿಯಾಕ್ಟಿವ್ ಗ್ರಾಫ್ ಬದಲಾವಣೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪ್ರಸಾರ ಮಾಡುತ್ತದೆ; ಹೆಚ್ಚುವರಿ
useEffectಕರಲ್ಗಳ ಅಗತ್ಯವಿಲ್ಲ.
ಇನ್ನೂ ಬದಲಾಗುತ್ತಿರುವ ಅಂಶಗಳು
Solid 2.0 ರ ಅಸಿಂಕ್ API ಪ್ರಸ್ತುತ ಬೀಟಾ ಹಂತದಲ್ಲಿದೆ. ಸ್ಥಿರ ಬಿಡುಗಡೆಯ ಮೊದಲು <Loading> ಮತ್ತು action ನಂತಹ ಹೆಸರುಗಳು ಬದಲಾಗಬಹುದು ಮತ್ತು ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಇನ್ನೂ ವಿಕಸನಗೊಳ್ಳುತ್ತಿದೆ. ಪ್ರಾಮಿಸಸ್ಗಳನ್ನು ರಿಯಾಕ್ಟಿವ್ ಮೌಲ್ಯಗಳಾಗಿ ಪರಿಗಣಿಸುವ ಮೂಲ ಕಲ್ಪನೆಯು ಬದಲಾಗದೆ ಉಳಿದಿದೆ, ಆದರೆ ಲೈಬ್ರರಿಯು ಸ್ಥಿರವಾಗುತ್ತಿದ್ದಂತೆ ಆರಂಭಿಕ ಬಳಕೆದಾರರು ಸಣ್ಣ ಮಟ್ಟದ ಬ್ರೇಕಿಂಗ್ ಚೇಂಜ್ಗಳನ್ನು ನಿರೀಕ್ಷಿಸಬಹುದು.
ಯಾರಿಗೆ ಪ್ರಯೋಜನವಾಗಲಿದೆ
- ಹೆಚ್ಚಿನ ದತ್ತಾಂಶವನ್ನು ಪಡೆಯುವ (data fetching) React ತಂಡಗಳು – ಬಾಹ್ಯ ಸ್ಟೇಟ್ ಲೈಬ್ರರಿಗಳ ಅಗತ್ಯತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುವುದು ಮತ್ತು ಅಂತರ್ಗತ stale-while-revalidate ಮಾದರಿಯು ಬಂಡಲ್ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡಬಹುದು ಮತ್ತು ಕೋಡ್ ಬೇಸ್ಗಳನ್ನು ಸರಳಗೊಳಿಸಬಹುದು.
- ಕಾರ್ಯಕ್ಷಮತೆ ಆಧಾರಿತ ಅಪ್ಲಿಕೇಶನ್ಗಳು – ಪ್ರತಿ ಫೆಚ್ ಮಾಡುವಾಗ ಪೂರ್ಣ ಘಟಕದ ಮರು-ರೆಂಡರ್ಗಳನ್ನು ತಪ್ಪಿಸುವ ಮೂಲಕ, Solid ಸುಗಮ ದೃಶ್ಯ ಅಪ್ಡೇಟ್ಗಳನ್ನು ನೀಡುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಕಡಿಮೆ ಸಾಮರ್ಥ್ಯದ ಸಾಧನಗಳಲ್ಲಿ.
- “ಫ್ಲ್ಯಾಶ್ ಆಫ್ ಸ್ಪಿನ್ನರ್” (flash of spinner) ಸಮಸ್ಯೆಯಿಂದ ಬೇಸತ್ತಿರುವ ಡೆವಲಪರ್ಗಳು –
<Loading>ಬೌಂಡರಿಯ “first-load-only” ನಡವಳಿಕೆಯು ಈಗಾಗಲೇ ಕಾಣಿಸುತ್ತಿರುವ ಕಂಟೆಂಟ್ ಮೇಲೆ ಸ್ಪಿನ್ನರ್ ಮಿಂಚುವ ಸಾಮಾನ್ಯ ಕಿರಿಕಿರಿ ತಪ್ಪಿಸುತ್ತದೆ.
ಸಂಭವನೀಯ ಅನಾನುಕೂಲಗಳು
- ಬೀಟಾ ಸ್ಥಿತಿ – API ಸ್ಥಿರವಾಗುವವರೆಗೆ, ದೀರ್ಘಾವಧಿಯ ಯೋಜನೆಗಳು ನಂತರದ ಮೈಗ್ರೇಶನ್ ಪ್ರಯತ್ನಕ್ಕಾಗಿ ಬಜೆಟ್ ಹೊಂದಿರಬಹುದು.
ಮುಂದೆ ಗಮನಿಸಬೇಕಾದವುಗಳು
<Loading> ಅಥವಾ action ನ ಯಾವುದೇ ಮರುನಾಮಕರಣಕ್ಕಾಗಿ ಅಧಿಕೃತ ಚೇಂಜ್ಲಾಗ್ (changelog) ಅನ್ನು ಗಮನಿಸುತ್ತಿರಿ.
ಸಾರಾಂಶ: SolidJS 2.0 ಪ್ರಾಮಿಸಸ್ಗಳನ್ನು ಪ್ರಥಮ ದರ್ಜೆಯ ರಿಯಾಕ್ಟಿವ್ ಮೌಲ್ಯಗಳಾಗಿ ಪರಿಗಣಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಇದು ದತ್ತಾಂಶ ರಿಫ್ರೆಶ್ ಆಗುವಾಗ UI ಅನ್ನು ಸ್ಥಿರವಾಗಿಡುತ್ತದೆ ಮತ್ತು React-ಶೈಲಿಯ ಹುಕ್ಗಳ ಅಗತ್ಯವನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ. ಮರು-ರೆಂಡರ್-ಕೇಂದ್ರಿತ ಮಾದರಿಯನ್ನು ಮೀರಿ ಸಾಗಲು ಸಿದ್ಧರಿರುವ ತಂಡಗಳಿಗೆ, ಮೈಗ್ರೇಶನ್ ಮಾರ್ಗವು ಸ್ಪಷ್ಟವಾಗಿದೆ, ಕಾರ್ಯಕ್ಷಮತೆಯ ಲಾಭವು ಸ್ಪಷ್ಟವಾಗಿದೆ ಮತ್ತು ಏಕೈಕ ನೈಜ ಅಪಾಯವು ಸಾಮಾನ್ಯ ಬೀಟಾ-ಹಂತದ ಅನಿಶ್ಚಿತತೆಯಾಗಿದೆ.