ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್‌ನ ರಹಸ್ಯ ಭೇದನೆ: ಸರ್ವರ್ ಕಾಂಪೊನೆಂಟ್ಸ್‌ಗೆ ಶಕ್ತಿ ನೀಡುವ ಸೀರಿಯಲೈಸ್ ಮಾಡಬಹುದಾದ ಪ್ರೋಟೋಕಾಲ್

ವೆಬ್ ಡೆವಲಪ್‌ಮೆಂಟ್ ಜಗತ್ತು ನಿರಂತರವಾಗಿ ವಿಕಸನಗೊಳ್ಳುತ್ತಿದೆ. ವರ್ಷಗಳ ಕಾಲ, ಸಿಂಗಲ್ ಪೇಜ್ ಅಪ್ಲಿಕೇಶನ್ (SPA) ಪ್ರಚಲಿತ ಮಾದರಿಯಾಗಿತ್ತು, ಇದರಲ್ಲಿ ಕನಿಷ್ಠ HTML ಶೆಲ್ ಅನ್ನು ಕ್ಲೈಂಟ್‌ಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ, ನಂತರ ಅದು ಡೇಟಾವನ್ನು ಪಡೆದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಬಳಸಿ ಸಂಪೂರ್ಣ ಯೂಸರ್ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ರೆಂಡರ್ ಮಾಡುತ್ತದೆ. ಇದು ಶಕ್ತಿಯುತವಾಗಿದ್ದರೂ, ಈ ಮಾದರಿಯು ದೊಡ್ಡ ಬಂಡಲ್ ಗಾತ್ರಗಳು, ಕ್ಲೈಂಟ್-ಸರ್ವರ್ ಡೇಟಾ ವಾಟರ್‌ಫಾಲ್‌ಗಳು, ಮತ್ತು ಸಂಕೀರ್ಣ ಸ್ಟೇಟ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್‌‌ನಂತಹ ಸವಾಲುಗಳನ್ನು ಪರಿಚಯಿಸಿತು. ಇದಕ್ಕೆ ಪ್ರತಿಕ್ರಿಯೆಯಾಗಿ, ಸಮುದಾಯವು ಸರ್ವರ್-ಕೇಂದ್ರಿತ ಆರ್ಕಿಟೆಕ್ಚರ್‌ಗಳತ್ತ ಮತ್ತೆ ಗಮನಾರ್ಹ ಬದಲಾವಣೆಯನ್ನು ಕಾಣುತ್ತಿದೆ, ಆದರೆ ಆಧುನಿಕ ಸ್ಪರ್ಶದೊಂದಿಗೆ. ಈ ವಿಕಾಸದ ಮುಂಚೂಣಿಯಲ್ಲಿ ರಿಯಾಕ್ಟ್ ತಂಡದ ಒಂದು যুগান্তকারী ವೈಶಿಷ್ಟ್ಯವಿದೆ: ರಿಯಾಕ್ಟ್ ಸರ್ವರ್ ಕಾಂಪೊನೆಂಟ್ಸ್ (RSC).

ಆದರೆ, ಸರ್ವರ್‌ನಲ್ಲಿ ಮಾತ್ರ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಈ ಕಾಂಪೊನೆಂಟ್‌ಗಳು, ಮಾಂತ್ರಿಕವಾಗಿ ಕ್ಲೈಂಟ್-ಸೈಡ್ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಹೇಗೆ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತವೆ ಮತ್ತು ಮನಬಂದಂತೆ ಸಂಯೋಜನೆಗೊಳ್ಳುತ್ತವೆ? ಉತ್ತರವು ಕಡಿಮೆ-ಪರಿಚಿತ ಆದರೆ ಅತ್ಯಂತ ನಿರ್ಣಾಯಕ ತಂತ್ರಜ್ಞಾನದಲ್ಲಿದೆ: ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್. ಇದು ನೀವು ಪ್ರತಿದಿನ ನೇರವಾಗಿ ಬಳಸುವ API ಅಲ್ಲ, ಆದರೆ ಇದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಆಧುನಿಕ ರಿಯಾಕ್ಟ್ ಪರಿಸರ ವ್ಯವಸ್ಥೆಯ ಸಂಪೂರ್ಣ ಸಾಮರ್ಥ್ಯವನ್ನು ಅನ್ಲಾಕ್ ಮಾಡುವ ಕೀಲಿಯಾಗಿದೆ. ಈ ಪೋಸ್ಟ್ ನಿಮ್ಮನ್ನು ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್ ಪ್ರೋಟೋಕಾಲ್‌ನ ಆಳವಾದ ವಿಶ್ಲೇಷಣೆಗೆ ಕರೆದೊಯ್ಯುತ್ತದೆ, ಮುಂದಿನ ಪೀಳಿಗೆಯ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಶಕ್ತಿ ನೀಡುವ ಇಂಜಿನ್‌ನ ರಹಸ್ಯವನ್ನು ಭೇದಿಸುತ್ತದೆ.

ರಿಯಾಕ್ಟ್ ಸರ್ವರ್ ಕಾಂಪೊನೆಂಟ್ಸ್ ಎಂದರೇನು? ಒಂದು ತ್ವರಿತ ಪುನರಾವಲೋಕನ

ನಾವು ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ವಿಭಜಿಸುವ ಮೊದಲು, ರಿಯಾಕ್ಟ್ ಸರ್ವರ್ ಕಾಂಪೊನೆಂಟ್ಸ್ ಎಂದರೇನು ಮತ್ತು ಅವು ಏಕೆ ಮುಖ್ಯ ಎಂಬುದನ್ನು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಪುನರಾವಲೋಕಿಸೋಣ. ಬ್ರೌಸರ್‌ನಲ್ಲಿ ರನ್ ಆಗುವ ಸಾಂಪ್ರದಾಯಿಕ ರಿಯಾಕ್ಟ್ ಕಾಂಪೊನೆಂಟ್‌ಗಳಿಗಿಂತ ಭಿನ್ನವಾಗಿ, RSCಗಳು ಸರ್ವರ್‌ನಲ್ಲಿ ಮಾತ್ರ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಹೊಸ ರೀತಿಯ ಕಾಂಪೊನೆಂಟ್‌ಗಳಾಗಿವೆ. ಅವು ತಮ್ಮ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಅನ್ನು ಕ್ಲೈಂಟ್‌ಗೆ ಎಂದಿಗೂ ಕಳುಹಿಸುವುದಿಲ್ಲ.

ಈ ಸರ್ವರ್-ಮಾತ್ರದ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯು ಹಲವಾರು ಗೇಮ್-ಚೇಂಜಿಂಗ್ ಪ್ರಯೋಜನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ:

ಶೂನ್ಯ-ಬಂಡಲ್ ಗಾತ್ರ: ಕಾಂಪೊನೆಂಟ್‌ನ ಕೋಡ್ ಎಂದಿಗೂ ಸರ್ವರ್ ಅನ್ನು ಬಿಟ್ಟು ಹೋಗದ ಕಾರಣ, ಅದು ನಿಮ್ಮ ಕ್ಲೈಂಟ್-ಸೈಡ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಬಂಡಲ್‌ಗೆ ಏನನ್ನೂ ಸೇರಿಸುವುದಿಲ್ಲ. ಇದು ಕಾರ್ಯಕ್ಷಮತೆಗೆ ಒಂದು ದೊಡ್ಡ ಗೆಲುವು, ವಿಶೇಷವಾಗಿ ಸಂಕೀರ್ಣ, ಡೇಟಾ-ಭರಿತ ಕಾಂಪೊನೆಂಟ್‌ಗಳಿಗೆ.
ನೇರ ಡೇಟಾ ಪ್ರವೇಶ: RSCಗಳು ಡೇಟಾಬೇಸ್‌ಗಳು, ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗಳು, ಅಥವಾ ಆಂತರಿಕ ಮೈಕ್ರೋಸರ್ವಿಸ್‌ಗಳಂತಹ ಸರ್ವರ್-ಸೈಡ್ ಸಂಪನ್ಮೂಲಗಳನ್ನು API ಎಂಡ್‌ಪಾಯಿಂಟ್ ಅನ್ನು ಬಹಿರಂಗಪಡಿಸದೆ ನೇರವಾಗಿ ಪ್ರವೇಶಿಸಬಹುದು. ಇದು ಡೇಟಾ ಫೆಚಿಂಗ್ ಅನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಕ್ಲೈಂಟ್-ಸರ್ವರ್ ವಿನಂತಿ ವಾಟರ್‌ಫಾಲ್‌ಗಳನ್ನು ನಿವಾರಿಸುತ್ತದೆ.
ಸ್ವಯಂಚಾಲಿತ ಕೋಡ್ ಸ್ಪ್ಲಿಟ್ಟಿಂಗ್: ಸರ್ವರ್‌ನಲ್ಲಿ ಯಾವ ಕಾಂಪೊನೆಂಟ್‌ಗಳನ್ನು ರೆಂಡರ್ ಮಾಡಬೇಕೆಂದು ನೀವು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಆಯ್ಕೆ ಮಾಡಬಹುದಾದ್ದರಿಂದ, ನೀವು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಸ್ವಯಂಚಾಲಿತ ಕೋಡ್ ಸ್ಪ್ಲಿಟ್ಟಿಂಗ್ ಅನ್ನು ಪಡೆಯುತ್ತೀರಿ. ಕೇವಲ ಸಂವಾದಾತ್ಮಕ ಕ್ಲೈಂಟ್ ಕಾಂಪೊನೆಂಟ್‌ಗಳ ಕೋಡ್ ಮಾತ್ರ ಬ್ರೌಸರ್‌ಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ.

RSCಗಳನ್ನು ಸರ್ವರ್-ಸೈಡ್ ರೆಂಡರಿಂಗ್ (SSR) ನಿಂದ ಪ್ರತ್ಯೇಕಿಸುವುದು ನಿರ್ಣಾಯಕ. SSR ನಿಮ್ಮ ಸಂಪೂರ್ಣ ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸರ್ವರ್‌ನಲ್ಲಿ HTML ಸ್ಟ್ರಿಂಗ್ ಆಗಿ ಪೂರ್ವ-ರೆಂಡರ್ ಮಾಡುತ್ತದೆ. ಕ್ಲೈಂಟ್ ಈ HTML ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ, ಅದನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ, ಮತ್ತು ನಂತರ ಪುಟವನ್ನು 'ಹೈಡ್ರೇಟ್' ಮಾಡಲು ಮತ್ತು ಅದನ್ನು ಸಂವಾದಾತ್ಮಕವಾಗಿಸಲು ಸಂಪೂರ್ಣ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಬಂಡಲ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡುತ್ತದೆ. ಇದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ, RSCಗಳು UIನ ವಿಶೇಷ, ಅಮೂರ್ತ ವಿವರಣೆಗೆ ರೆಂಡರ್ ಆಗುತ್ತವೆ - HTMLಗೆ ಅಲ್ಲ - ಇದನ್ನು ನಂತರ ಕ್ಲೈಂಟ್‌ಗೆ ಸ್ಟ್ರೀಮ್ ಮಾಡಲಾಗುತ್ತದೆ ಮತ್ತು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕಾಂಪೊನೆಂಟ್ ಟ್ರೀಯೊಂದಿಗೆ ಸಮನ್ವಯಗೊಳಿಸಲಾಗುತ್ತದೆ. ಇದು ಹೆಚ್ಚು ಸೂಕ್ಷ್ಮ ಮತ್ತು ದಕ್ಷ ಅಪ್‌ಡೇಟ್ ಪ್ರಕ್ರಿಯೆಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್ ಪರಿಚಯ: ಮೂಲ ಪ್ರೋಟೋಕಾಲ್

ಹಾಗಾದರೆ, ಸರ್ವರ್ ಕಾಂಪೊನೆಂಟ್ HTML ಅಥವಾ ತನ್ನದೇ ಆದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಕಳುಹಿಸುತ್ತಿಲ್ಲವಾದರೆ, ಅದು ಏನು ಕಳುಹಿಸುತ್ತಿದೆ? ಇಲ್ಲಿಯೇ ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್ ಬರುತ್ತದೆ. ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್ ಎಂಬುದು ಸರ್ವರ್‌ನಿಂದ ಕ್ಲೈಂಟ್‌ಗೆ ರೆಂಡರ್ ಮಾಡಲಾದ ರಿಯಾಕ್ಟ್ ಕಾಂಪೊನೆಂಟ್ ಟ್ರೀಯನ್ನು ರವಾನಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಒಂದು ಉದ್ದೇಶ-ನಿರ್ಮಿತ ಸೀರಿಯಲೈಸೇಶನ್ ಪ್ರೋಟೋಕಾಲ್ ಆಗಿದೆ.

ಇದನ್ನು ರಿಯಾಕ್ಟ್ ಪ್ರಿಮಿಟಿವ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ, JSONನ ವಿಶೇಷ, ಸ್ಟ್ರೀಮ್ ಮಾಡಬಹುದಾದ ಆವೃತ್ತಿ ಎಂದು ಯೋಚಿಸಿ. ಇದು ನಿಮ್ಮ ಸರ್ವರ್ ಪರಿಸರ ಮತ್ತು ಬಳಕೆದಾರರ ಬ್ರೌಸರ್ ನಡುವಿನ ಅಂತರವನ್ನು ಕಡಿಮೆ ಮಾಡುವ 'ವೈರ್ ಫಾರ್ಮ್ಯಾಟ್' ಆಗಿದೆ. ನೀವು RSC ಅನ್ನು ರೆಂಡರ್ ಮಾಡಿದಾಗ, ರಿಯಾಕ್ಟ್ HTML ಅನ್ನು ಉತ್ಪಾದಿಸುವುದಿಲ್ಲ. ಬದಲಾಗಿ, ಇದು ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್ ಫಾರ್ಮ್ಯಾಟ್‌ನಲ್ಲಿ ಡೇಟಾದ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ.

ಕೇವಲ HTML ಅಥವಾ JSON ಅನ್ನು ಏಕೆ ಬಳಸಬಾರದು?

ಒಂದು ಸಹಜ ಪ್ರಶ್ನೆಯೆಂದರೆ, ಸಂಪೂರ್ಣ ಹೊಸ ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಏಕೆ ಕಂಡುಹಿಡಿಯಬೇಕು? ನಾವು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಮಾನದಂಡಗಳನ್ನು ಏಕೆ ಬಳಸಲಾಗಲಿಲ್ಲ?

ಏಕೆ HTML ಅಲ್ಲ? HTML ಕಳುಹಿಸುವುದು SSRನ ಡೊಮೇನ್. HTMLನೊಂದಿಗಿನ ಸಮಸ್ಯೆ ಎಂದರೆ ಅದು ಅಂತಿಮ ಪ್ರಾತಿನಿಧ್ಯ. ಇದು ಕಾಂಪೊನೆಂಟ್ ರಚನೆ ಮತ್ತು ಸಂದರ್ಭವನ್ನು ಕಳೆದುಕೊಳ್ಳುತ್ತದೆ. ಪೂರ್ಣ ಪುಟ ರೀಲೋಡ್ ಅಥವಾ ಸಂಕೀರ್ಣ DOM ಮ್ಯಾನಿಪ್ಯುಲೇಶನ್ ಇಲ್ಲದೆ, ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ, ಸಂವಾದಾತ್ಮಕ ಕ್ಲೈಂಟ್-ಸೈಡ್ ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಸ್ಟ್ರೀಮ್ ಮಾಡಿದ HTMLನ ಹೊಸ ತುಣುಕುಗಳನ್ನು ಸುಲಭವಾಗಿ ಸಂಯೋಜಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ರಿಯಾಕ್ಟ್‌ಗೆ ಯಾವ ಭಾಗಗಳು ಕಾಂಪೊನೆಂಟ್‌ಗಳು, ಅವುಗಳ ಪ್ರಾಪ್ಸ್‌ಗಳು ಯಾವುವು, ಮತ್ತು ಸಂವಾದಾತ್ಮಕ 'ಐಲ್ಯಾಂಡ್ಸ್' (ಕ್ಲೈಂಟ್ ಕಾಂಪೊನೆಂಟ್ಸ್) ಎಲ್ಲಿವೆ ಎಂದು ತಿಳಿಯಬೇಕಾಗುತ್ತದೆ.
ಏಕೆ ಸ್ಟ್ಯಾಂಡರ್ಡ್ JSON ಅಲ್ಲ? JSON ಡೇಟಾಗೆ ಅತ್ಯುತ್ತಮವಾಗಿದೆ, ಆದರೆ ಇದು UI ಕಾಂಪೊನೆಂಟ್‌ಗಳು, JSX, ಅಥವಾ ಸಸ್ಪೆನ್ಸ್ ಬೌಂಡರಿಗಳಂತಹ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಸ್ಥಳೀಯವಾಗಿ ಪ್ರತಿನಿಧಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ನೀವು ಕಾಂಪೊನೆಂಟ್ ಟ್ರೀಯನ್ನು ಪ್ರತಿನಿಧಿಸಲು JSON ಸ್ಕೀಮಾವನ್ನು ರಚಿಸಲು ಪ್ರಯತ್ನಿಸಬಹುದು, ಆದರೆ ಅದು ವಿವರಣಾತ್ಮಕವಾಗಿರುತ್ತದೆ ಮತ್ತು ಕ್ಲೈಂಟ್‌ನಲ್ಲಿ ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಲೋಡ್ ಮಾಡಿ ರೆಂಡರ್ ಮಾಡಬೇಕಾದ ಕಾಂಪೊನೆಂಟ್ ಅನ್ನು ಹೇಗೆ ಪ್ರತಿನಿಧಿಸುವುದು ಎಂಬ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವುದಿಲ್ಲ.

ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್ ಈ ನಿರ್ದಿಷ್ಟ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ರಚಿಸಲಾಗಿದೆ. ಇದನ್ನು ಹೀಗೆ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ:

ಸೀರಿಯಲೈಸ್ ಮಾಡಬಹುದಾದ (Serializable): ಪ್ರಾಪ್ಸ್‌ಗಳು ಮತ್ತು ಸ್ಟೇಟ್ ಸೇರಿದಂತೆ ಸಂಪೂರ್ಣ ಕಾಂಪೊನೆಂಟ್ ಟ್ರೀಯನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಸಾಮರ್ಥ್ಯ.
ಸ್ಟ್ರೀಮ್ ಮಾಡಬಹುದಾದ (Streamable): UI ಅನ್ನು ತುಣುಕುಗಳಲ್ಲಿ ಕಳುಹಿಸಬಹುದು, ಪೂರ್ಣ ಪ್ರತಿಕ್ರಿಯೆ ಲಭ್ಯವಾಗುವ ಮೊದಲು ಕ್ಲೈಂಟ್ ರೆಂಡರಿಂಗ್ ಪ್ರಾರಂಭಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಇದು ಸಸ್ಪೆನ್ಸ್‌ನೊಂದಿಗೆ ಸಂಯೋಜನೆಗೆ ಮೂಲಭೂತವಾಗಿದೆ.
ರಿಯಾಕ್ಟ್-ಅರಿವು (React-Aware): ಇದು ಕಾಂಪೊನೆಂಟ್‌ಗಳು, ಕಾಂಟೆಕ್ಸ್ಟ್, ಮತ್ತು ಕ್ಲೈಂಟ್-ಸೈಡ್ ಕೋಡ್‌ನ ಲೇಜಿ-ಲೋಡಿಂಗ್‌ನಂತಹ ರಿಯಾಕ್ಟ್ ಪರಿಕಲ್ಪನೆಗಳಿಗೆ ಪ್ರಥಮ-ದರ್ಜೆಯ ಬೆಂಬಲವನ್ನು ಹೊಂದಿದೆ.

ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ: ಹಂತ-ಹಂತದ ವಿಶ್ಲೇಷಣೆ

ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್ ಬಳಸುವ ಪ್ರಕ್ರಿಯೆಯು ಸರ್ವರ್ ಮತ್ತು ಕ್ಲೈಂಟ್ ನಡುವಿನ ಸಂಘಟಿತ ನೃತ್ಯವನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. RSCಗಳನ್ನು ಬಳಸುವ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ವಿನಂತಿಯ ಜೀವನಚಕ್ರವನ್ನು ನೋಡೋಣ.

ಸರ್ವರ್‌ನಲ್ಲಿ

ವಿನಂತಿಯ ಪ್ರಾರಂಭ: ಬಳಕೆದಾರರು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಒಂದು ಪುಟಕ್ಕೆ ನ್ಯಾವಿಗೇಟ್ ಮಾಡುತ್ತಾರೆ (ಉದಾ., Next.js ಆಪ್ ರೂಟರ್ ಪುಟ).
ಕಾಂಪೊನೆಂಟ್ ರೆಂಡರಿಂಗ್: ರಿಯಾಕ್ಟ್ ಆ ಪುಟಕ್ಕಾಗಿ ಸರ್ವರ್ ಕಾಂಪೊನೆಂಟ್ ಟ್ರೀಯನ್ನು ರೆಂಡರ್ ಮಾಡಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ.
ಡೇಟಾ ಫೆಚಿಂಗ್: ಇದು ಟ್ರೀಯನ್ನು ದಾಟುವಾಗ, ಡೇಟಾವನ್ನು ಪಡೆಯುವ ಕಾಂಪೊನೆಂಟ್‌ಗಳನ್ನು ಎದುರಿಸುತ್ತದೆ (ಉದಾ., `async function MyServerComponent() { ... }`). ಇದು ಈ ಡೇಟಾ ಫೆಚ್‌ಗಳಿಗಾಗಿ ಕಾಯುತ್ತದೆ.
ಫ್ಲೈಟ್ ಸ್ಟ್ರೀಮ್‌ಗೆ ಸೀರಿಯಲೈಸೇಶನ್: HTML ಅನ್ನು ಉತ್ಪಾದಿಸುವ ಬದಲು, ರಿಯಾಕ್ಟ್ ರೆಂಡರರ್ ಪಠ್ಯದ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ. ಈ ಪಠ್ಯವೇ ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್ ಪೇಲೋಡ್. ಕಾಂಪೊನೆಂಟ್ ಟ್ರೀಯ ಪ್ರತಿಯೊಂದು ಭಾಗ - ಒಂದು `div`, ಒಂದು `p`, ಪಠ್ಯದ ಸ್ಟ್ರಿಂಗ್, ಕ್ಲೈಂಟ್ ಕಾಂಪೊನೆಂಟ್‌ಗೆ ಒಂದು ಉಲ್ಲೇಖ - ಈ ಸ್ಟ್ರೀಮ್‌ನೊಳಗೆ ಒಂದು ನಿರ್ದಿಷ್ಟ ಫಾರ್ಮ್ಯಾಟ್‌ಗೆ ಎನ್‌ಕೋಡ್ ಮಾಡಲಾಗುತ್ತದೆ.
ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಸ್ಟ್ರೀಮಿಂಗ್ ಮಾಡುವುದು: ಸರ್ವರ್ ಸಂಪೂರ್ಣ ಟ್ರೀ ರೆಂಡರ್ ಆಗುವವರೆಗೆ ಕಾಯುವುದಿಲ್ಲ. UIನ ಮೊದಲ ತುಣುಕುಗಳು ಸಿದ್ಧವಾದ ತಕ್ಷಣ, ಅದು HTTP ಮೂಲಕ ಕ್ಲೈಂಟ್‌ಗೆ ಫ್ಲೈಟ್ ಪೇಲೋಡ್ ಅನ್ನು ಸ್ಟ್ರೀಮ್ ಮಾಡಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ. ಅದು ಸಸ್ಪೆನ್ಸ್ ಬೌಂಡರಿಯನ್ನು ಎದುರಿಸಿದರೆ, ಅದು ಪ್ಲೇಸ್‌ಹೋಲ್ಡರ್ ಅನ್ನು ಕಳುಹಿಸುತ್ತದೆ ಮತ್ತು ಹಿನ್ನೆಲೆಯಲ್ಲಿ ಸಸ್ಪೆನ್ಸ್ ಆದ ವಿಷಯವನ್ನು ರೆಂಡರ್ ಮಾಡುವುದನ್ನು ಮುಂದುವರಿಸುತ್ತದೆ, ಅದು ಸಿದ್ಧವಾದಾಗ ಅದೇ ಸ್ಟ್ರೀಮ್‌ನಲ್ಲಿ ನಂತರ ಕಳುಹಿಸುತ್ತದೆ.

ಕ್ಲೈಂಟ್‌ನಲ್ಲಿ

ಸ್ಟ್ರೀಮ್ ಸ್ವೀಕರಿಸುವುದು: ಬ್ರೌಸರ್‌ನಲ್ಲಿರುವ ರಿಯಾಕ್ಟ್ ರನ್‌ಟೈಮ್ ಫ್ಲೈಟ್ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ. ಇದು ಒಂದೇ ಡಾಕ್ಯುಮೆಂಟ್ ಅಲ್ಲ, ಆದರೆ ಸೂಚನೆಗಳ ನಿರಂತರ ಹರಿವು.
ಪಾರ್ಸಿಂಗ್ ಮತ್ತು ಸಮನ್ವಯ (Reconciliation): ಕ್ಲೈಂಟ್-ಸೈಡ್ ರಿಯಾಕ್ಟ್ ಕೋಡ್ ಫ್ಲೈಟ್ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ತುಣುಕಿನಿಂದ ತುಣುಕಿಗೆ ಪಾರ್ಸ್ ಮಾಡುತ್ತದೆ. ಇದು UI ಅನ್ನು ನಿರ್ಮಿಸಲು ಅಥವಾ ನವೀಕರಿಸಲು ಬ್ಲೂಪ್ರಿಂಟ್‌ಗಳ ಸೆಟ್ ಅನ್ನು ಸ್ವೀಕರಿಸಿದಂತೆ.
ಟ್ರೀಯನ್ನು ಪುನರ್ನಿರ್ಮಿಸುವುದು: ಪ್ರತಿ ಸೂಚನೆಗಾಗಿ, ರಿಯಾಕ್ಟ್ ತನ್ನ ವರ್ಚುವಲ್ DOM ಅನ್ನು ನವೀಕರಿಸುತ್ತದೆ. ಇದು ಹೊಸ `div` ಅನ್ನು ರಚಿಸಬಹುದು, ಕೆಲವು ಪಠ್ಯವನ್ನು ಸೇರಿಸಬಹುದು, ಅಥವಾ - ಅತ್ಯಂತ ಮುಖ್ಯವಾಗಿ - ಕ್ಲೈಂಟ್ ಕಾಂಪೊನೆಂಟ್‌ಗಾಗಿ ಪ್ಲೇಸ್‌ಹೋಲ್ಡರ್ ಅನ್ನು ಗುರುತಿಸಬಹುದು.
ಕ್ಲೈಂಟ್ ಕಾಂಪೊನೆಂಟ್‌ಗಳನ್ನು ಲೋಡ್ ಮಾಡುವುದು: ಸ್ಟ್ರೀಮ್ ಕ್ಲೈಂಟ್ ಕಾಂಪೊನೆಂಟ್‌ಗೆ ("use client" ಡೈರೆಕ್ಟಿವ್‌ನೊಂದಿಗೆ ಗುರುತಿಸಲಾದ) ಉಲ್ಲೇಖವನ್ನು ಹೊಂದಿರುವಾಗ, ಫ್ಲೈಟ್ ಪೇಲೋಡ್ ಯಾವ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಬಂಡಲ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಬೇಕೆಂಬುದರ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ರಿಯಾಕ್ಟ್ ನಂತರ ಆ ಬಂಡಲ್ ಅನ್ನು ಈಗಾಗಲೇ ಕ್ಯಾಶ್ ಮಾಡದಿದ್ದರೆ ಅದನ್ನು ಫೆಚ್ ಮಾಡುತ್ತದೆ.
ಹೈಡ್ರೇಶನ್ ಮತ್ತು ಸಂವಾದಾತ್ಮಕತೆ: ಕ್ಲೈಂಟ್ ಕಾಂಪೊನೆಂಟ್‌ನ ಕೋಡ್ ಲೋಡ್ ಆದ ನಂತರ, ರಿಯಾಕ್ಟ್ ಅದನ್ನು ಗೊತ್ತುಪಡಿಸಿದ ಸ್ಥಳದಲ್ಲಿ ರೆಂಡರ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಹೈಡ್ರೇಟ್ ಮಾಡುತ್ತದೆ, ಈವೆಂಟ್ ಲಿಸನರ್‌ಗಳನ್ನು ಲಗತ್ತಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಸಂವಾದಾತ್ಮಕವಾಗಿಸುತ್ತದೆ. ಈ ಪ್ರಕ್ರಿಯೆಯು ಹೆಚ್ಚು ಗುರಿಯಾಗಿದ್ದು, ಪುಟದ ಸಂವಾದಾತ್ಮಕ ಭಾಗಗಳಿಗೆ ಮಾತ್ರ ಸಂಭವಿಸುತ್ತದೆ.

ಈ ಸ್ಟ್ರೀಮಿಂಗ್ ಮತ್ತು ಆಯ್ದ ಹೈಡ್ರೇಶನ್ ಮಾದರಿಯು ಸಾಂಪ್ರದಾಯಿಕ SSR ಮಾದರಿಗಿಂತ ಗಣನೀಯವಾಗಿ ಹೆಚ್ಚು ದಕ್ಷವಾಗಿದೆ, ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಇಡೀ ಪುಟದ "ಎಲ್ಲಾ-ಅಥವಾ-ಏನೂ ಇಲ್ಲ" ಹೈಡ್ರೇಶನ್ ಅನ್ನು ಬಯಸುತ್ತದೆ.

ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್ ಪೇಲೋಡ್‌ನ ರಚನೆ

ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್ ಅನ್ನು ನಿಜವಾಗಿಯೂ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಅದು ಉತ್ಪಾದಿಸುವ ಡೇಟಾದ ಫಾರ್ಮ್ಯಾಟ್ ಅನ್ನು ನೋಡುವುದು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಈ ಕಚ್ಚಾ ಔಟ್‌ಪುಟ್‌ನೊಂದಿಗೆ ನೇರವಾಗಿ ಸಂವಹನ ನಡೆಸದಿದ್ದರೂ, ಅದರ ರಚನೆಯನ್ನು ನೋಡುವುದರಿಂದ ಅದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದು ತಿಳಿಯುತ್ತದೆ. ಪೇಲೋಡ್ ಎಂಬುದು ಹೊಸ ಸಾಲಿನಿಂದ ಬೇರ್ಪಡಿಸಿದ JSON-ರೀತಿಯ ಸ್ಟ್ರಿಂಗ್‌ಗಳ ಸ್ಟ್ರೀಮ್ ಆಗಿದೆ. ಪ್ರತಿ ಸಾಲು, ಅಥವಾ ತುಣುಕು, ಮಾಹಿತಿಯ ಒಂದು ಭಾಗವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

ಒಂದು ಸರಳ ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸೋಣ. ನಮ್ಮಲ್ಲಿ ಈ ರೀತಿಯ ಸರ್ವರ್ ಕಾಂಪೊನೆಂಟ್ ಇದೆ ಎಂದು ಊಹಿಸಿಕೊಳ್ಳಿ:

app/page.js (ಸರ್ವರ್ ಕಾಂಪೊನೆಂಟ್)


<!-- ಇದು ನಿಜವಾದ ಬ್ಲಾಗ್‌ನಲ್ಲಿರುವ ಕೋಡ್ ಬ್ಲಾಕ್ ಎಂದು ಭಾವಿಸಿ -->
async function Page() {
  const userData = await fetchUser(); // Fetches { name: 'Alice' }
  return (
    <div>
      <h1>Welcome, {userData.name}</h1>
      <p>Here is your dashboard.</p>
      <InteractiveButton text="Click Me" />
    </div>
  );
}

ಮತ್ತು ಒಂದು ಕ್ಲೈಂಟ್ ಕಾಂಪೊನೆಂಟ್:

components/InteractiveButton.js (ಕ್ಲೈಂಟ್ ಕಾಂಪೊನೆಂಟ್)


<!-- ಇದು ನಿಜವಾದ ಬ್ಲಾಗ್‌ನಲ್ಲಿರುವ ಕೋಡ್ ಬ್ಲಾಕ್ ಎಂದು ಭಾವಿಸಿ -->
'use client';

import { useState } from 'react';

export default function InteractiveButton({ text }) {
  const [count, setCount] = useState(0);
  return (
    <button onClick={() => setCount(count + 1)}>
      {text} ({count})
    </button>
  );
}

ಈ UIಗಾಗಿ ಸರ್ವರ್‌ನಿಂದ ಕ್ಲೈಂಟ್‌ಗೆ ಕಳುಹಿಸಲಾದ ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್ ಸ್ಟ್ರೀಮ್ ಈ ರೀತಿ ಕಾಣಿಸಬಹುದು (ಸ್ಪಷ್ಟತೆಗಾಗಿ ಸರಳೀಕರಿಸಲಾಗಿದೆ):


<!-- ಫ್ಲೈಟ್ ಸ್ಟ್ರೀಮ್‌ನ ಸರಳೀಕೃತ ಉದಾಹರಣೆ -->
M1:{"id":"./components/InteractiveButton.js","chunks":["chunk-abcde.js"],"name":"default"}
J0:["$","div",null,{"children":[["$","h1",null,{"children":["Welcome, ","Alice"]}],["$","p",null,{"children":"Here is your dashboard."}],["$","@1",null,{"text":"Click Me"}]]}]

ಈ ರಹಸ್ಯಮಯ ಔಟ್‌ಪುಟ್ ಅನ್ನು ವಿಭಜಿಸೋಣ:

`M` ಸಾಲುಗಳು (ಮಾಡ್ಯೂಲ್ ಮೆಟಾಡೇಟಾ): `M1:` ನಿಂದ ಪ್ರಾರಂಭವಾಗುವ ಸಾಲು ಒಂದು ಮಾಡ್ಯೂಲ್ ರೆಫರೆನ್ಸ್. ಇದು ಕ್ಲೈಂಟ್‌ಗೆ ಹೇಳುತ್ತದೆ: "`@1` ID ಯಿಂದ ಉಲ್ಲೇಖಿಸಲಾದ ಕಾಂಪೊನೆಂಟ್ `./components/InteractiveButton.js` ಫೈಲ್‌ನಿಂದ ಡೀಫಾಲ್ಟ್ ಎಕ್ಸ್‌ಪೋರ್ಟ್ ಆಗಿದೆ. ಅದನ್ನು ಲೋಡ್ ಮಾಡಲು, ನೀವು `chunk-abcde.js` ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಫೈಲ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ." ಡೈನಾಮಿಕ್ ಇಂಪೋರ್ಟ್‌ಗಳು ಮತ್ತು ಕೋಡ್ ಸ್ಪ್ಲಿಟ್ಟಿಂಗ್ ಅನ್ನು ಈ ರೀತಿ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ.
`J` ಸಾಲುಗಳು (JSON ಡೇಟಾ): `J0:` ನಿಂದ ಪ್ರಾರಂಭವಾಗುವ ಸಾಲು ಸೀರಿಯಲೈಸ್ ಮಾಡಿದ ಕಾಂಪೊನೆಂಟ್ ಟ್ರೀಯನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಅದರ ರಚನೆಯನ್ನು ನೋಡೋಣ: `["$","div",null,{...}]`.
`$` ಚಿಹ್ನೆ: ಇದು ರಿಯಾಕ್ಟ್ ಎಲಿಮೆಂಟ್ (ಮೂಲಭೂತವಾಗಿ, JSX) ಅನ್ನು ಸೂಚಿಸುವ ವಿಶೇಷ ಐಡೆಂಟಿಫೈಯರ್. ಫಾರ್ಮ್ಯಾಟ್ ಸಾಮಾನ್ಯವಾಗಿ `["$", type, key, props]` ಆಗಿರುತ್ತದೆ.
ಕಾಂಪೊನೆಂಟ್ ಟ್ರೀ ರಚನೆ: ನೀವು HTMLನ ನೆಸ್ಟೆಡ್ ರಚನೆಯನ್ನು ನೋಡಬಹುದು. `div` ಗೆ `children` ಪ್ರಾಪ್ ಇದೆ, ಇದು `h1`, `p`, ಮತ್ತು ಇನ್ನೊಂದು ರಿಯಾಕ್ಟ್ ಎಲಿಮೆಂಟ್ ಅನ್ನು ಒಳಗೊಂಡಿರುವ ಒಂದು ಅರೇ ಆಗಿದೆ.
ಡೇಟಾ ಸಂಯೋಜನೆ: `"Alice"` ಎಂಬ ಹೆಸರು ನೇರವಾಗಿ ಸ್ಟ್ರೀಮ್‌ನಲ್ಲಿ ಎಂಬೆಡ್ ಆಗಿರುವುದನ್ನು ಗಮನಿಸಿ. ಸರ್ವರ್‌ನ ಡೇಟಾ ಫೆಚ್ ಫಲಿತಾಂಶವು ನೇರವಾಗಿ UI ವಿವರಣೆಯಲ್ಲಿ ಸೀರಿಯಲೈಸ್ ಆಗಿದೆ. ಈ ಡೇಟಾವನ್ನು ಹೇಗೆ ಪಡೆಯಲಾಯಿತು ಎಂದು ಕ್ಲೈಂಟ್‌ಗೆ ತಿಳಿಯಬೇಕಾಗಿಲ್ಲ.
`@` ಚಿಹ್ನೆ (ಕ್ಲೈಂಟ್ ಕಾಂಪೊನೆಂಟ್ ರೆಫರೆನ್ಸ್): ಅತ್ಯಂತ ಆಸಕ್ತಿದಾಯಕ ಭಾಗವೆಂದರೆ `["$","@1",null,{"text":"Click Me"}]`. `@1` ಒಂದು ರೆಫರೆನ್ಸ್. ಇದು ಕ್ಲೈಂಟ್‌ಗೆ ಹೇಳುತ್ತದೆ: "ಟ್ರೀಯ ಈ ಸ್ಥಳದಲ್ಲಿ, ನೀವು `M1` ಮಾಡ್ಯೂಲ್ ಮೆಟಾಡೇಟಾದಿಂದ ವಿವರಿಸಲಾದ ಕ್ಲೈಂಟ್ ಕಾಂಪೊನೆಂಟ್ ಅನ್ನು ರೆಂಡರ್ ಮಾಡಬೇಕು. ಮತ್ತು ನೀವು ಅದನ್ನು ರೆಂಡರ್ ಮಾಡಿದಾಗ, ಅದಕ್ಕೆ ಈ ಪ್ರಾಪ್ಸ್‌ಗಳನ್ನು ಪಾಸ್ ಮಾಡಿ: `{ text: 'Click Me' }`."

ಈ ಪೇಲೋಡ್ ಸೂಚನೆಗಳ ಸಂಪೂರ್ಣ ಸೆಟ್ ಆಗಿದೆ. ಇದು ಕ್ಲೈಂಟ್‌ಗೆ UI ಅನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸಬೇಕು, ಯಾವ ಸ್ಥಿರ ವಿಷಯವನ್ನು ಪ್ರದರ್ಶಿಸಬೇಕು, ಸಂವಾದಾತ್ಮಕ ಕಾಂಪೊನೆಂಟ್‌ಗಳನ್ನು ಎಲ್ಲಿ ಇರಿಸಬೇಕು, ಅವುಗಳ ಕೋಡ್ ಅನ್ನು ಹೇಗೆ ಲೋಡ್ ಮಾಡಬೇಕು, ಮತ್ತು ಅವುಗಳಿಗೆ ಯಾವ ಪ್ರಾಪ್ಸ್‌ಗಳನ್ನು ಪಾಸ್ ಮಾಡಬೇಕು ಎಂಬುದನ್ನು ನಿಖರವಾಗಿ ಹೇಳುತ್ತದೆ. ಇದೆಲ್ಲವೂ ಕಾಂಪ್ಯಾಕ್ಟ್, ಸ್ಟ್ರೀಮ್ ಮಾಡಬಹುದಾದ ಫಾರ್ಮ್ಯಾಟ್‌ನಲ್ಲಿ ಮಾಡಲಾಗುತ್ತದೆ.

ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್ ಪ್ರೋಟೋಕಾಲ್‌ನ ಪ್ರಮುಖ ಪ್ರಯೋಜನಗಳು

ಫ್ಲೈಟ್ ಪ್ರೋಟೋಕಾಲ್‌ನ ವಿನ್ಯಾಸವು RSC ಮಾದರಿಯ ಮೂಲ ಪ್ರಯೋಜನಗಳನ್ನು ನೇರವಾಗಿ ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಈ ಪ್ರಯೋಜನಗಳು ಏಕೆ ಸಾಧ್ಯ ಎಂಬುದನ್ನು ಸ್ಪಷ್ಟಪಡಿಸುತ್ತದೆ.

ಸ್ಟ್ರೀಮಿಂಗ್ ಮತ್ತು ನೇಟಿವ್ ಸಸ್ಪೆನ್ಸ್

ಪ್ರೋಟೋಕಾಲ್ ಹೊಸ ಸಾಲಿನಿಂದ-ಬೇರ್ಪಡಿಸಿದ ಸ್ಟ್ರೀಮ್ ಆಗಿರುವುದರಿಂದ, ಸರ್ವರ್ UI ಅನ್ನು ರೆಂಡರ್ ಮಾಡುವಾಗ ಅದನ್ನು ಕಳುಹಿಸಬಹುದು. ಒಂದು ಕಾಂಪೊನೆಂಟ್ ಸಸ್ಪೆಂಡ್ ಆಗಿದ್ದರೆ (ಉದಾ., ಡೇಟಾಗಾಗಿ ಕಾಯುತ್ತಿದ್ದರೆ), ಸರ್ವರ್ ಸ್ಟ್ರೀಮ್‌ನಲ್ಲಿ ಪ್ಲೇಸ್‌ಹೋಲ್ಡರ್ ಸೂಚನೆಯನ್ನು ಕಳುಹಿಸಬಹುದು, ಪುಟದ ಉಳಿದ UI ಅನ್ನು ಕಳುಹಿಸಬಹುದು, ಮತ್ತು ನಂತರ, ಡೇಟಾ ಸಿದ್ಧವಾದಾಗ, ಪ್ಲೇಸ್‌ಹೋಲ್ಡರ್ ಅನ್ನು ನಿಜವಾದ ವಿಷಯದೊಂದಿಗೆ ಬದಲಾಯಿಸಲು ಅದೇ ಸ್ಟ್ರೀಮ್‌ನಲ್ಲಿ ಹೊಸ ಸೂಚನೆಯನ್ನು ಕಳುಹಿಸಬಹುದು. ಇದು ಸಂಕೀರ್ಣ ಕ್ಲೈಂಟ್-ಸೈಡ್ ಲಾಜಿಕ್ ಇಲ್ಲದೆ ಪ್ರಥಮ-ದರ್ಜೆಯ ಸ್ಟ್ರೀಮಿಂಗ್ ಅನುಭವವನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಸರ್ವರ್ ಲಾಜಿಕ್‌ಗಾಗಿ ಶೂನ್ಯ-ಬಂಡಲ್ ಗಾತ್ರ

ಪೇಲೋಡ್ ಅನ್ನು ನೋಡಿದಾಗ, `Page` ಕಾಂಪೊನೆಂಟ್‌ನಿಂದ ಯಾವುದೇ ಕೋಡ್ ಇಲ್ಲದಿರುವುದನ್ನು ನೀವು ನೋಡಬಹುದು. ಡೇಟಾ ಫೆಚಿಂಗ್ ಲಾಜಿಕ್, ಯಾವುದೇ ಸಂಕೀರ್ಣ ವ್ಯವಹಾರ ಲೆಕ್ಕಾಚಾರಗಳು, ಅಥವಾ ಸರ್ವರ್‌ನಲ್ಲಿ ಮಾತ್ರ ಬಳಸಲಾಗುವ ದೊಡ್ಡ ಲೈಬ್ರರಿಗಳಂತಹ ಅವಲಂಬನೆಗಳು ಸಂಪೂರ್ಣವಾಗಿ ಇರುವುದಿಲ್ಲ. ಸ್ಟ್ರೀಮ್ ಆ ಲಾಜಿಕ್‌ನ *ಔಟ್‌ಪುಟ್* ಅನ್ನು ಮಾತ್ರ ಹೊಂದಿರುತ್ತದೆ. RSCಗಳ "ಶೂನ್ಯ-ಬಂಡಲ್ ಗಾತ್ರ" ವಾಗ್ದಾನದ ಹಿಂದಿನ ಮೂಲಭೂತ ಕಾರ್ಯವಿಧಾನ ಇದಾಗಿದೆ.

ಡೇಟಾ ಫೆಚಿಂಗ್‌ನ ಕೋಲೊಕೇಶನ್

`userData` ಫೆಚ್ ಸರ್ವರ್‌ನಲ್ಲಿ ನಡೆಯುತ್ತದೆ, ಮತ್ತು ಅದರ ಫಲಿತಾಂಶ (`'Alice'`) ಮಾತ್ರ ಸ್ಟ್ರೀಮ್‌ಗೆ ಸೀರಿಯಲೈಸ್ ಆಗುತ್ತದೆ. ಇದು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಡೇಟಾ-ಫೆಚಿಂಗ್ ಕೋಡ್ ಅನ್ನು ಅದಕ್ಕೆ ಅಗತ್ಯವಿರುವ ಕಾಂಪೊನೆಂಟ್‌ನೊಳಗೆ ಬರೆಯಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ಈ ಪರಿಕಲ್ಪನೆಯನ್ನು ಕೋಲೊಕೇಶನ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಈ ಮಾದರಿಯು ಕೋಡ್ ಅನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ, ನಿರ್ವಹಣೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ, ಮತ್ತು ಅನೇಕ SPAಗಳನ್ನು ಪೀಡಿಸುವ ಕ್ಲೈಂಟ್-ಸರ್ವರ್ ವಾಟರ್‌ಫಾಲ್‌ಗಳನ್ನು ನಿವಾರಿಸುತ್ತದೆ.

ಆಯ್ದ ಹೈಡ್ರೇಶನ್

ರೆಂಡರ್ ಮಾಡಲಾದ HTML ಎಲಿಮೆಂಟ್‌ಗಳು ಮತ್ತು ಕ್ಲೈಂಟ್ ಕಾಂಪೊನೆಂಟ್ ರೆಫರೆನ್ಸ್‌ಗಳ (`@`) ನಡುವಿನ ಪ್ರೋಟೋಕಾಲ್‌ನ ಸ್ಪಷ್ಟ ವ್ಯತ್ಯಾಸವೇ ಆಯ್ದ ಹೈಡ್ರೇಶನ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ಕ್ಲೈಂಟ್-ಸೈಡ್ ರಿಯಾಕ್ಟ್ ರನ್‌ಟೈಮ್‌ಗೆ ತಿಳಿದಿದೆ যে ಕೇವಲ `@` ಕಾಂಪೊನೆಂಟ್‌ಗಳಿಗೆ ಮಾತ್ರ ಸಂವಾದಾತ್ಮಕವಾಗಲು ಅವುಗಳ ಅನುಗುಣವಾದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಗತ್ಯವಿದೆ. ಇದು ಟ್ರೀಯ ಸ್ಥಿರ ಭಾಗಗಳನ್ನು ನಿರ್ಲಕ್ಷಿಸಬಹುದು, ಆರಂಭಿಕ ಪುಟ ಲೋಡ್‌ನಲ್ಲಿ ಗಮನಾರ್ಹ ಕಂಪ್ಯೂಟೇಶನಲ್ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಉಳಿಸುತ್ತದೆ.

ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್ vs. ಪರ್ಯಾಯಗಳು: ಒಂದು ಜಾಗತಿಕ ದೃಷ್ಟಿಕೋನ

ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್‌ನ ಆವಿಷ್ಕಾರವನ್ನು ಶ್ಲಾಘಿಸಲು, ಜಾಗತಿಕ ವೆಬ್ ಡೆವಲಪ್‌ಮೆಂಟ್ ಸಮುದಾಯದಲ್ಲಿ ಬಳಸಲಾಗುವ ಇತರ ವಿಧಾನಗಳೊಂದಿಗೆ ಅದನ್ನು ಹೋಲಿಸುವುದು ಸಹಾಯಕವಾಗಿದೆ.

vs. ಸಾಂಪ್ರದಾಯಿಕ SSR + ಹೈಡ್ರೇಶನ್

ಹೇಳಿದಂತೆ, ಸಾಂಪ್ರದಾಯಿಕ SSR ಪೂರ್ಣ HTML ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು ಕಳುಹಿಸುತ್ತದೆ. ಕ್ಲೈಂಟ್ ನಂತರ ದೊಡ್ಡ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಬಂಡಲ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಇಡೀ ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು "ಹೈಡ್ರೇಟ್" ಮಾಡುತ್ತದೆ, ಸ್ಥಿರ HTMLಗೆ ಈವೆಂಟ್ ಲಿಸನರ್‌ಗಳನ್ನು ಲಗತ್ತಿಸುತ್ತದೆ. ಇದು ನಿಧಾನ ಮತ್ತು ಸುಲಭವಾಗಿ ಮುರಿಯುವಂತಿರಬಹುದು. ಒಂದೇ ದೋಷವು ಇಡೀ ಪುಟವು ಸಂವಾದಾತ್ಮಕವಾಗುವುದನ್ನು ತಡೆಯಬಹುದು. ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್‌ನ ಸ್ಟ್ರೀಮ್ ಮಾಡಬಹುದಾದ ಮತ್ತು ಆಯ್ದ ಸ್ವಭಾವವು ಈ ಪರಿಕಲ್ಪನೆಯ ಹೆಚ್ಚು ಸ್ಥಿತಿಸ್ಥಾಪಕ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯ ವಿಕಾಸವಾಗಿದೆ.

vs. GraphQL/REST APIಗಳು

ಒಂದು ಸಾಮಾನ್ಯ ಗೊಂದಲವೆಂದರೆ RSCಗಳು GraphQL ಅಥವಾ REST ನಂತಹ ಡೇಟಾ APIಗಳನ್ನು ಬದಲಾಯಿಸುತ್ತವೆಯೇ ಎಂಬುದು. ಉತ್ತರ ಇಲ್ಲ; ಅವು ಪೂರಕವಾಗಿವೆ. ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್ UI ಟ್ರೀಯನ್ನು ಸೀರಿಯಲೈಸ್ ಮಾಡಲು ಒಂದು ಪ್ರೋಟೋಕಾಲ್, ಸಾಮಾನ್ಯ-ಉದ್ದೇಶದ ಡೇಟಾ ಕ್ವೆರಿ ಭಾಷೆಯಲ್ಲ. ವಾಸ್ತವವಾಗಿ, ಸರ್ವರ್ ಕಾಂಪೊನೆಂಟ್ ತನ್ನ ಡೇಟಾವನ್ನು ರೆಂಡರ್ ಮಾಡುವ ಮೊದಲು ಸರ್ವರ್‌ನಲ್ಲಿ GraphQL ಅಥವಾ REST API ಅನ್ನು ಬಳಸುತ್ತದೆ. ಪ್ರಮುಖ ವ್ಯತ್ಯಾಸವೆಂದರೆ ಈ API ಕರೆ ಸರ್ವರ್-ಟು-ಸರ್ವರ್ ನಡೆಯುತ್ತದೆ, ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಕ್ಲೈಂಟ್-ಟು-ಸರ್ವರ್ ಕರೆಗಿಂತ ಹೆಚ್ಚು ವೇಗ ಮತ್ತು ಸುರಕ್ಷಿತವಾಗಿರುತ್ತದೆ. ಕ್ಲೈಂಟ್ ಕಚ್ಚಾ ಡೇಟಾವನ್ನು ಅಲ್ಲ, ಅಂತಿಮ UI ಅನ್ನು ಫ್ಲೈಟ್ ಸ್ಟ್ರೀಮ್ ಮೂಲಕ ಸ್ವೀಕರಿಸುತ್ತದೆ.

vs. ಇತರೆ ಆಧುನಿಕ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು

ಜಾಗತಿಕ ಪರಿಸರ ವ್ಯವಸ್ಥೆಯಲ್ಲಿನ ಇತರ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ಸಹ ಸರ್ವರ್-ಕ್ಲೈಂಟ್ ವಿಭಜನೆಯನ್ನು ನಿಭಾಯಿಸುತ್ತಿವೆ. ಉದಾಹರಣೆಗೆ:

ಆಸ್ಟ್ರೋ ಐಲ್ಯಾಂಡ್ಸ್: ಆಸ್ಟ್ರೋ ಇದೇ ರೀತಿಯ 'ಐಲ್ಯಾಂಡ್' ಆರ್ಕಿಟೆಕ್ಚರ್ ಅನ್ನು ಬಳಸುತ್ತದೆ, ಅಲ್ಲಿ ಸೈಟ್‌ನ ಹೆಚ್ಚಿನ ಭಾಗವು ಸ್ಥಿರ HTML ಆಗಿರುತ್ತದೆ ಮತ್ತು ಸಂವಾದಾತ್ಮಕ ಕಾಂಪೊನೆಂಟ್‌ಗಳನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಲೋಡ್ ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಪರಿಕಲ್ಪನೆಯು RSC ಜಗತ್ತಿನಲ್ಲಿ ಕ್ಲೈಂಟ್ ಕಾಂಪೊನೆಂಟ್‌ಗಳಿಗೆ ಸಮಾನವಾಗಿದೆ. ಆದಾಗ್ಯೂ, ಆಸ್ಟ್ರೋ ಪ್ರಾಥಮಿಕವಾಗಿ HTML ಅನ್ನು ಕಳುಹಿಸುತ್ತದೆ, ಆದರೆ ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್ ಮೂಲಕ UIನ ರಚನಾತ್ಮಕ ವಿವರಣೆಯನ್ನು ಕಳುಹಿಸುತ್ತದೆ, ಇದು ಕ್ಲೈಂಟ್-ಸೈಡ್ ರಿಯಾಕ್ಟ್ ಸ್ಟೇಟ್‌ನೊಂದಿಗೆ ಹೆಚ್ಚು ತಡೆರಹಿತ ಸಂಯೋಜನೆಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
ಕ್ವಿಕ್ ಮತ್ತು ರೆಸ್ಯೂಮಬಿಲಿಟಿ: ಕ್ವಿಕ್ ರೆಸ್ಯೂಮಬಿಲಿಟಿ ಎಂಬ ವಿಭಿನ್ನ ವಿಧಾನವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಇದು ಅಪ್ಲಿಕೇಶನ್‌ನ ಸಂಪೂರ್ಣ ಸ್ಥಿತಿಯನ್ನು HTML ನಲ್ಲಿ ಸೀರಿಯಲೈಸ್ ಮಾಡುತ್ತದೆ, ಆದ್ದರಿಂದ ಕ್ಲೈಂಟ್‌ಗೆ ಸ್ಟಾರ್ಟ್‌ಅಪ್‌ನಲ್ಲಿ ಕೋಡ್ ಅನ್ನು ಮರು-ಕಾರ್ಯಗತಗೊಳಿಸುವ ಅಗತ್ಯವಿಲ್ಲ (ಹೈಡ್ರೇಶನ್). ಸರ್ವರ್ ಎಲ್ಲಿ ಬಿಟ್ಟಿತ್ತೋ ಅಲ್ಲಿಂದ ಅದು 'ಪುನರಾರಂಭಿಸಬಹುದು'. ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್ ಮತ್ತು ಆಯ್ದ ಹೈಡ್ರೇಶನ್ ಇದೇ ರೀತಿಯ ವೇಗದ-ಸಮಯ-ಕ್ಕೆ-ಸಂವಾದಾತ್ಮಕ ಗುರಿಯನ್ನು ಸಾಧಿಸಲು ಉದ್ದೇಶಿಸಿದೆ, ಆದರೆ ಕೇವಲ ಅಗತ್ಯ ಸಂವಾದಾತ್ಮಕ ಕೋಡ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುವ ಮತ್ತು ಚಲಾಯಿಸುವ ವಿಭಿನ್ನ ಕಾರ್ಯವಿಧಾನದ ಮೂಲಕ.

ಡೆವಲಪರ್‌ಗಳಿಗಾಗಿ ಪ್ರಾಯೋಗಿಕ ಪರಿಣಾಮಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ನೀವು ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್ ಪೇಲೋಡ್‌ಗಳನ್ನು ಕೈಯಿಂದ ಬರೆಯದಿದ್ದರೂ, ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ನೀವು ಆಧುನಿಕ ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸಬೇಕು ಎಂಬುದನ್ನು ತಿಳಿಸುತ್ತದೆ.

`"use server"` ಮತ್ತು `"use client"` ಅನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಿ

Next.js ನಂತಹ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳಲ್ಲಿ, `"use client"` ಡೈರೆಕ್ಟಿವ್ ಸರ್ವರ್ ಮತ್ತು ಕ್ಲೈಂಟ್ ನಡುವಿನ ಗಡಿಯನ್ನು ನಿಯಂತ್ರಿಸಲು ನಿಮ್ಮ ಪ್ರಾಥಮಿಕ ಸಾಧನವಾಗಿದೆ. ಇದು ಒಂದು ಕಾಂಪೊನೆಂಟ್ ಮತ್ತು ಅದರ ಮಕ್ಕಳು ಸಂವಾದಾತ್ಮಕ ಐಲ್ಯಾಂಡ್ ಆಗಿ ಪರಿಗಣಿಸಲ್ಪಡಬೇಕು ಎಂಬುದಕ್ಕೆ ಬಿಲ್ಡ್ ಸಿಸ್ಟಮ್‌ಗೆ ಸಂಕೇತವಾಗಿದೆ. ಅದರ ಕೋಡ್ ಅನ್ನು ಬಂಡಲ್ ಮಾಡಿ ಬ್ರೌಸರ್‌ಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ, ಮತ್ತು ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್ ಅದಕ್ಕೆ ಒಂದು ರೆಫರೆನ್ಸ್ ಅನ್ನು ಸೀರಿಯಲೈಸ್ ಮಾಡುತ್ತದೆ. ಇದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ, ಈ ಡೈರೆಕ್ಟಿವ್‌ನ ಅನುಪಸ್ಥಿತಿಯು (ಅಥವಾ ಸರ್ವರ್ ಆಕ್ಷನ್‌ಗಳಿಗಾಗಿ `"use server"` ಬಳಕೆ) ಕಾಂಪೊನೆಂಟ್‌ಗಳನ್ನು ಸರ್ವರ್‌ನಲ್ಲಿ ಇರಿಸುತ್ತದೆ. ದಕ್ಷ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಈ ಗಡಿಯನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳಿ.

ಕಾಂಪೊನೆಂಟ್‌ಗಳಲ್ಲಿ ಯೋಚಿಸಿ, ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗಳಲ್ಲಿ ಅಲ್ಲ

RSCಗಳೊಂದಿಗೆ, ಕಾಂಪೊನೆಂಟ್ ಸ್ವತಃ ಡೇಟಾ ಕಂಟೇನರ್ ಆಗಿರಬಹುದು. `/api/user` ಎಂಬ API ಎಂಡ್‌ಪಾಯಿಂಟ್ ಅನ್ನು ರಚಿಸಿ ಅದರಿಂದ ಫೆಚ್ ಮಾಡುವ ಕ್ಲೈಂಟ್-ಸೈಡ್ ಕಾಂಪೊನೆಂಟ್ ರಚಿಸುವ ಬದಲು, ನೀವು ಡೇಟಾವನ್ನು ಆಂತರಿಕವಾಗಿ ಫೆಚ್ ಮಾಡುವ ಒಂದೇ ಸರ್ವರ್ ಕಾಂಪೊನೆಂಟ್ `` ಅನ್ನು ರಚಿಸಬಹುದು. ಇದು ಆರ್ಕಿಟೆಕ್ಚರ್ ಅನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಡೆವಲಪರ್‌ಗಳನ್ನು UI ಮತ್ತು ಅದರ ಡೇಟಾವನ್ನು ಒಂದೇ, ಸುಸಂಬದ್ಧ ಘಟಕವಾಗಿ ಯೋಚಿಸಲು ಪ್ರೋತ್ಸಾಹಿಸುತ್ತದೆ.

ಭದ್ರತೆಯು ಸರ್ವರ್-ಸೈಡ್ ಕಾಳಜಿಯಾಗಿದೆ

RSCಗಳು ಸರ್ವರ್ ಕೋಡ್ ಆಗಿರುವುದರಿಂದ, ಅವುಗಳಿಗೆ ಸರ್ವರ್ ಸವಲತ್ತುಗಳಿವೆ. ಇದು ಶಕ್ತಿಯುತ ಆದರೆ ಭದ್ರತೆಗೆ ಶಿಸ್ತಿನ ವಿಧಾನದ ಅಗತ್ಯವಿದೆ. ಎಲ್ಲಾ ಡೇಟಾ ಪ್ರವೇಶ, ಪರಿಸರ ವೇರಿಯಬಲ್ ಬಳಕೆ, ಮತ್ತು ಆಂತರಿಕ ಸೇವೆಗಳೊಂದಿಗಿನ ಸಂವಹನಗಳು ಇಲ್ಲಿ ನಡೆಯುತ್ತವೆ. ಯಾವುದೇ ಬ್ಯಾಕೆಂಡ್ API ಯಂತೆ ಈ ಕೋಡ್ ಅನ್ನು ಅದೇ ಕಠಿಣತೆಯಿಂದ ಪರಿಗಣಿಸಿ: ಎಲ್ಲಾ ಇನ್‌ಪುಟ್‌ಗಳನ್ನು ಸ್ಯಾನಿಟೈಸ್ ಮಾಡಿ, ಡೇಟಾಬೇಸ್ ಪ್ರಶ್ನೆಗಳಿಗಾಗಿ ಸಿದ್ಧಪಡಿಸಿದ ಸ್ಟೇಟ್‌ಮೆಂಟ್‌ಗಳನ್ನು ಬಳಸಿ, ಮತ್ತು ಫ್ಲೈಟ್ ಪೇಲೋಡ್‌ಗೆ ಸೀರಿಯಲೈಸ್ ಆಗಬಹುದಾದ ಸೂಕ್ಷ್ಮ ಕೀಗಳು ಅಥವಾ ರಹಸ್ಯಗಳನ್ನು ಎಂದಿಗೂ ಬಹಿರಂಗಪಡಿಸಬೇಡಿ.

ಹೊಸ ಸ್ಟಾಕ್ ಅನ್ನು ಡೀಬಗ್ ಮಾಡುವುದು

RSC ಜಗತ್ತಿನಲ್ಲಿ ಡೀಬಗ್ ಮಾಡುವುದು ಬದಲಾಗುತ್ತದೆ. UI ದೋಷವು ಸರ್ವರ್-ಸೈಡ್ ರೆಂಡರಿಂಗ್ ಲಾಜಿಕ್‌ನಿಂದ ಅಥವಾ ಕ್ಲೈಂಟ್-ಸೈಡ್ ಹೈಡ್ರೇಶನ್‌ನಿಂದ ಹುಟ್ಟಿಕೊಂಡಿರಬಹುದು. ನಿಮ್ಮ ಸರ್ವರ್ ಲಾಗ್‌ಗಳು (RSCಗಳಿಗಾಗಿ) ಮತ್ತು ಬ್ರೌಸರ್‌ನ ಡೆವಲಪರ್ ಕನ್ಸೋಲ್ (ಕ್ಲೈಂಟ್ ಕಾಂಪೊನೆಂಟ್‌ಗಳಿಗಾಗಿ) ಎರಡನ್ನೂ ಪರೀಕ್ಷಿಸಲು ನೀವು ಆರಾಮದಾಯಕವಾಗಿರಬೇಕು. ನೆಟ್‌ವರ್ಕ್ ಟ್ಯಾಬ್ ಸಹ ಎಂದಿಗಿಂತಲೂ ಹೆಚ್ಚು ಮುಖ್ಯವಾಗಿದೆ. ಸರ್ವರ್ ಕ್ಲೈಂಟ್‌ಗೆ ನಿಖರವಾಗಿ ಏನು ಕಳುಹಿಸುತ್ತಿದೆ ಎಂಬುದನ್ನು ನೋಡಲು ನೀವು ಕಚ್ಚಾ ಫ್ಲೈಟ್ ಪ್ರತಿಕ್ರಿಯೆ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಪರಿಶೀಲಿಸಬಹುದು, ಇದು ದೋಷನಿವಾರಣೆಗೆ ಅಮೂಲ್ಯವಾಗಿರುತ್ತದೆ.

ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್‌ನೊಂದಿಗೆ ವೆಬ್ ಡೆವಲಪ್‌ಮೆಂಟ್‌ನ ಭವಿಷ್ಯ

ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್ ಮತ್ತು ಅದು ಸಕ್ರಿಯಗೊಳಿಸುವ ಸರ್ವರ್ ಕಾಂಪೊನೆಂಟ್ಸ್ ಆರ್ಕಿಟೆಕ್ಚರ್, ನಾವು ವೆಬ್‌ಗಾಗಿ ಹೇಗೆ ನಿರ್ಮಿಸುತ್ತೇವೆ ಎಂಬುದರ ಬಗ್ಗೆ ಮೂಲಭೂತ ಪುನರ್ವಿಮರ್ಶೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಈ ಮಾದರಿಯು ಎರಡೂ ಪ್ರಪಂಚಗಳ ಅತ್ಯುತ್ತಮ ಅಂಶಗಳನ್ನು ಸಂಯೋಜಿಸುತ್ತದೆ: ಕಾಂಪೊನೆಂಟ್-ಆಧಾರಿತ UI ಡೆವಲಪ್‌ಮೆಂಟ್‌ನ ಸರಳ, ಶಕ್ತಿಯುತ ಡೆವಲಪರ್ ಅನುಭವ ಮತ್ತು ಸಾಂಪ್ರದಾಯಿಕ ಸರ್ವರ್-ರೆಂಡರ್ಡ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಕಾರ್ಯಕ್ಷಮತೆ ಮತ್ತು ಭದ್ರತೆ.

ಈ ತಂತ್ರಜ್ಞಾನವು ಪ್ರಬುದ್ಧವಾಗುತ್ತಿದ್ದಂತೆ, ಇನ್ನೂ ಹೆಚ್ಚು ಶಕ್ತಿಶಾಲಿ ಮಾದರಿಗಳು ಹೊರಹೊಮ್ಮುವುದನ್ನು ನಾವು ನಿರೀಕ್ಷಿಸಬಹುದು. ಸರ್ವರ್ ಆಕ್ಷನ್‌ಗಳು, ಕ್ಲೈಂಟ್ ಕಾಂಪೊನೆಂಟ್‌ಗಳಿಗೆ ಸರ್ವರ್‌ನಲ್ಲಿ ಸುರಕ್ಷಿತ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಆಹ್ವಾನಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತವೆ, ಈ ಸರ್ವರ್-ಕ್ಲೈಂಟ್ ಸಂವಹನ ಚಾನಲ್‌ನ ಮೇಲೆ ನಿರ್ಮಿಸಲಾದ ವೈಶಿಷ್ಟ್ಯದ ಪ್ರಮುಖ ಉದಾಹರಣೆಯಾಗಿದೆ. ಪ್ರೋಟೋಕಾಲ್ ವಿಸ್ತರಿಸಬಲ್ಲದು, ಅಂದರೆ ರಿಯಾಕ್ಟ್ ತಂಡವು ಭವಿಷ್ಯದಲ್ಲಿ ಮೂಲ ಮಾದರಿಯನ್ನು ಮುರಿಯದೆ ಹೊಸ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಸೇರಿಸಬಹುದು.

ತೀರ್ಮಾನ

ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್ ರಿಯಾಕ್ಟ್ ಸರ್ವರ್ ಕಾಂಪೊನೆಂಟ್ಸ್ ಮಾದರಿಯ ಅದೃಶ್ಯ ಆದರೆ ಅನಿವಾರ್ಯ ಬೆನ್ನೆಲುಬು. ಇದು ಅತ್ಯಂತ ವಿಶೇಷ, ದಕ್ಷ, ಮತ್ತು ಸ್ಟ್ರೀಮ್ ಮಾಡಬಹುದಾದ ಪ್ರೋಟೋಕಾಲ್ ಆಗಿದ್ದು, ಇದು ಸರ್ವರ್-ರೆಂಡರ್ ಮಾಡಿದ ಕಾಂಪೊನೆಂಟ್ ಟ್ರೀಯನ್ನು ಕ್ಲೈಂಟ್-ಸೈಡ್ ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬಹುದಾದ ಮತ್ತು ಶ್ರೀಮಂತ, ಸಂವಾದಾತ್ಮಕ ಯೂಸರ್ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ಬಳಸಬಹುದಾದ ಸೂಚನೆಗಳ ಸೆಟ್ ಆಗಿ ಭಾಷಾಂತರಿಸುತ್ತದೆ. ಕಾಂಪೊನೆಂಟ್‌ಗಳನ್ನು ಮತ್ತು ಅವುಗಳ ದುಬಾರಿ ಅವಲಂಬನೆಗಳನ್ನು ಕ್ಲೈಂಟ್‌ನಿಂದ ಸರ್ವರ್‌ಗೆ ಸರಿಸುವ ಮೂಲಕ, ಇದು ವೇಗವಾದ, ಹಗುರವಾದ ಮತ್ತು ಹೆಚ್ಚು ಶಕ್ತಿಶಾಲಿ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ.

ವಿಶ್ವದಾದ್ಯಂತದ ಡೆವಲಪರ್‌ಗಳಿಗೆ, ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್ ಎಂದರೇನು ಮತ್ತು ಅದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಕೇವಲ ಶೈಕ್ಷಣಿಕ ವ್ಯಾಯಾಮವಲ್ಲ. ಇದು ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಆರ್ಕಿಟೆಕ್ಟ್ ಮಾಡಲು, ಕಾರ್ಯಕ್ಷಮತೆಯ ವ್ಯಾಪಾರ-ವಹಿವಾಟುಗಳನ್ನು ಮಾಡಲು, ಮತ್ತು ಸರ್ವರ್-ಚಾಲಿತ UIಗಳ ಈ ಹೊಸ ಯುಗದಲ್ಲಿ ಸಮಸ್ಯೆಗಳನ್ನು ಡೀಬಗ್ ಮಾಡಲು ನಿರ್ಣಾಯಕ ಮಾನಸಿಕ ಮಾದರಿಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ಬದಲಾವಣೆ ನಡೆಯುತ್ತಿದೆ, ಮತ್ತು ರಿಯಾಕ್ಟ್ ಫ್ಲೈಟ್ ಮುಂದಿನ ದಾರಿಯನ್ನು ಸುಗಮಗೊಳಿಸುವ ಪ್ರೋಟೋಕಾಲ್ ಆಗಿದೆ.