ರಸ್ಟ್ ಟ್ಯುಟೋರಿಯಲ್: ಮೆಮೊರಿ ಸುರಕ್ಷತೆ ಮತ್ತು ಏಕಕಾಲಿಕತೆ

ತುಕ್ಕು ಆ ಭಾಷೆಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ ಪ್ರತಿಯೊಬ್ಬ ಸಿಸ್ಟಮ್ ಡೆವಲಪರ್ ಕೂಡ ಅದನ್ನು ಪದೇ ಪದೇ ಕೇಳುತ್ತಾರೆ.ಇದು C ಮತ್ತು C++ ನಷ್ಟು ವೇಗವಾಗಿದೆ, ಆದರೆ ಮೆಮೊರಿ ಸುರಕ್ಷತೆ ಮತ್ತು ಉತ್ತಮವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಿದ ಏಕಕಾಲಿಕತೆಯ ಮೇಲೆ ಬಹುತೇಕ ಗೀಳಿನ ಗಮನವನ್ನು ಹೊಂದಿದೆ. ಇದು ಕೇವಲ ಖಾಲಿ ಮಾರ್ಕೆಟಿಂಗ್ ಅಲ್ಲ: ಇದರ ವಿನ್ಯಾಸವು ಕಂಪೈಲ್ ಸಮಯದಲ್ಲಿ ದೋಷಗಳನ್ನು ಪತ್ತೆಹಚ್ಚುವ ಕಂಪೈಲರ್ ಸುತ್ತ ಸುತ್ತುತ್ತದೆ - ಇತರ ಭಾಷೆಗಳಲ್ಲಿ ಸಿಸ್ಟಮ್ ಈಗಾಗಲೇ ಉತ್ಪಾದನೆಯಲ್ಲಿದ್ದಾಗ ಅಥವಾ ಅದು ಕ್ರ್ಯಾಶ್ ಆದಾಗ ಮಾತ್ರ ನೀವು ನೋಡುವ ದೋಷಗಳು.

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

ತುಕ್ಕು ಟ್ಯುಟೋರಿಯಲ್: ಕಾರ್ಯಕ್ಷಮತೆ, ಮೆಮೊರಿ ಸುರಕ್ಷತೆ ಮತ್ತು ಏಕಕಾಲಿಕತೆ

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

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

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

ಈ ಎಲ್ಲಾ ಕಾರಣಗಳಿಗಾಗಿ, ದೊಡ್ಡ ಕಂಪನಿಗಳು ಇಷ್ಟಪಡುತ್ತವೆ ಡ್ರಾಪ್‌ಬಾಕ್ಸ್, ಮೈಕ್ರೋಸಾಫ್ಟ್, ಅಮೆಜಾನ್ ಅಥವಾ ಗೂಗಲ್ ಅವರು ತಮ್ಮ ಮೂಲಸೌಕರ್ಯದ ನಿರ್ಣಾಯಕ ಭಾಗಗಳಲ್ಲಿ ರಸ್ಟ್ ಅನ್ನು ಅಳವಡಿಸಿಕೊಂಡಿದ್ದಾರೆ. ಮತ್ತು ಡೆವಲಪರ್‌ಗಳಿಂದ "ಅತ್ಯಂತ ಪ್ರಿಯವಾದ" ಭಾಷೆಗಳಲ್ಲಿ ಒಂದಾಗಿ ವರ್ಷಗಳಿಂದ ಸ್ಟಾಕ್ ಓವರ್‌ಫ್ಲೋ ಸಮೀಕ್ಷೆಗಳಲ್ಲಿ ಇದು ಅಗ್ರಸ್ಥಾನದಲ್ಲಿದೆ ಎಂಬುದು ಕಾಕತಾಳೀಯವಲ್ಲ: ಇದು C++-ಶೈಲಿಯ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಆಧುನಿಕ ಟೂಲ್‌ಸೆಟ್ (ಕಾರ್ಗೋ, crates.io) ಮತ್ತು ಅತ್ಯಂತ ಸಕ್ರಿಯ ಸಮುದಾಯವಾದ ರಸ್ಟೇಶಿಯನ್ಸ್‌ನೊಂದಿಗೆ ಸಂಯೋಜಿಸುತ್ತದೆ.

ಮೂಲ ಪರಿಕಲ್ಪನೆಗಳು: ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ, ಪ್ರಕಾರಗಳು ಮತ್ತು ಮೆಮೊರಿ

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

ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ ಎಂದರೆ, ಅಂತಿಮವಾಗಿ, ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ವಿವರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ನಿಯಮಗಳು ಮತ್ತು ರಚನೆಗಳ ಒಂದು ಸೆಟ್ ಮತ್ತು ಅವುಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಪ್ರೋಗ್ರಾಂಗಳಾಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ. ರಸ್ಟ್ ತನ್ನ ಕಂಪೈಲರ್ ಬಳಸಿ ಸ್ಥಳೀಯ ಯಂತ್ರ ಕೋಡ್‌ಗೆ ಕಂಪೈಲ್ ಮಾಡುತ್ತದೆ. rustcಆದ್ದರಿಂದ, ನೀವು ಪಡೆಯುವ ಕಾರ್ಯಕ್ಷಮತೆ ಸಾಮಾನ್ಯವಾಗಿ C ಮತ್ತು C++ ಗೆ ಸಮನಾಗಿರುತ್ತದೆ.

ಮೆಮೊರಿ ನಿರ್ವಹಣೆ ಎನ್ನುವುದು ಒಂದು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಬಳಸುವ ಪ್ರಕ್ರಿಯೆಯಾಗಿದೆ ಚಾಲನೆಯಲ್ಲಿರುವಾಗ ಮೆಮೊರಿಯ ಬ್ಲಾಕ್‌ಗಳನ್ನು ಕಾಯ್ದಿರಿಸುತ್ತದೆ ಮತ್ತು ಬಿಡುಗಡೆ ಮಾಡುತ್ತದೆಈ ಪ್ರದೇಶದಲ್ಲಿನ ದೋಷಗಳು ಹೆಚ್ಚಾಗಿ ಮಾರಕವಾಗಿವೆ: ಮೆಮೊರಿ ಸೋರಿಕೆ (ಬಳಕೆಯಾಗದ ಮೆಮೊರಿಯನ್ನು ಬಿಡುಗಡೆ ಮಾಡಲು ವಿಫಲವಾಗುವುದು), ಮಿತಿ ಮೀರಿ ಬರೆಯುವುದರಿಂದ ಡೇಟಾ ಭ್ರಷ್ಟಾಚಾರ ಅಥವಾ ಮೆಮೊರಿಯನ್ನು ಮುಕ್ತಗೊಳಿಸಿದ ನಂತರ ಅದನ್ನು ಬಳಸುವುದರಿಂದ. ರಸ್ಟ್ ಇದನ್ನು ಬಲವಾದ ಪ್ರಕಾರದ ವ್ಯವಸ್ಥೆ ಮತ್ತು ಮಾಲೀಕತ್ವ, ಸಾಲ ಮತ್ತು ಜೀವಿತಾವಧಿಗೆ ಔಪಚಾರಿಕ ನಿಯಮಗಳೊಂದಿಗೆ ಪರಿಹರಿಸುತ್ತದೆ.

ರಸ್ಟ್ ಎಂಬ ಪದವು ಸ್ಮಾರ್ಟ್ ಪ್ರಕಾರಗಳು ಮತ್ತು ಪಾಯಿಂಟರ್‌ಗಳುಒಂದು ವಿಧವು ಒಂದು ವೇರಿಯೇಬಲ್ ಯಾವ ರೀತಿಯ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ (ಪೂರ್ಣಾಂಕಗಳು, ಫ್ಲೋಟ್‌ಗಳು, ಸ್ಟ್ರಿಂಗ್‌ಗಳು, ರಚನೆಗಳು, ಇತ್ಯಾದಿ) ಮತ್ತು ಅದನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸಬಹುದು ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ. ಸ್ಮಾರ್ಟ್ ಪಾಯಿಂಟರ್‌ಗಳು (ಉದಾಹರಣೆಗೆ, Box, Rc y Arc) ಮೆಮೊರಿ ವಿಳಾಸಗಳನ್ನು ಕ್ಯಾಪ್ಸುಲೇಟ್ ಮಾಡುವ ರಚನೆಗಳಾಗಿವೆ ಮತ್ತು ಹಂಚಿಕೆಯ ಉಲ್ಲೇಖಗಳನ್ನು ಎಣಿಸುವುದು ಅಥವಾ ರಾಶಿಗೆ ಮೌಲ್ಯಗಳನ್ನು ಸರಿಸುವುದು ಮುಂತಾದ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ನಿರ್ವಹಿಸಲು ಹೆಚ್ಚುವರಿ ತರ್ಕವನ್ನು ಸೇರಿಸುತ್ತವೆ.

ಸ್ಪರ್ಧೆಯ ಕ್ಷೇತ್ರದಲ್ಲಿ, ಅಂತಹ ಪರಿಕಲ್ಪನೆಗಳು ಓಟದ ಪರಿಸ್ಥಿತಿಗಳು, ಮ್ಯೂಟೆಕ್ಸ್‌ಗಳು ಮತ್ತು ಚಾನಲ್‌ಗಳು ಅವು ಅನಿವಾರ್ಯವಾಗುತ್ತವೆ: ಸರಿಯಾದ ಸಮನ್ವಯವಿಲ್ಲದೆ ಬಹು ಥ್ರೆಡ್‌ಗಳು ಏಕಕಾಲದಲ್ಲಿ ಹಂಚಿಕೆಯ ಸಂಪನ್ಮೂಲವನ್ನು ಪ್ರವೇಶಿಸಿದಾಗ ಮತ್ತು ಮಾರ್ಪಡಿಸಿದಾಗ ರೇಸ್ ಸ್ಥಿತಿ ಉಂಟಾಗುತ್ತದೆ; ಮ್ಯೂಟೆಕ್ಸ್ (ಪರಸ್ಪರ ಹೊರಗಿಡುವಿಕೆ) ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಥ್ರೆಡ್ ಮಾತ್ರ ನಿರ್ಣಾಯಕ ವಿಭಾಗವನ್ನು ಪ್ರವೇಶಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ; ಮತ್ತು ಚಾನಲ್‌ಗಳು ನೇರವಾಗಿ ಮೆಮೊರಿಯನ್ನು ಹಂಚಿಕೊಳ್ಳದೆ ಥ್ರೆಡ್‌ಗಳ ನಡುವೆ ಸಂದೇಶಗಳನ್ನು ಕಳುಹಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ತುಕ್ಕು ಹಿಡಿಯುವುದನ್ನು ಏಕೆ ಕಲಿಯಬೇಕು: ಸ್ಮರಣಶಕ್ತಿ ಸುರಕ್ಷತೆ ಮತ್ತು ನಿರ್ಭೀತ ಸಹವರ್ತಿತ್ವ

ರಸ್ಟ್ ತನ್ನ ಖ್ಯಾತಿಯನ್ನು ಗಳಿಸಿದೆ ಏಕೆಂದರೆ ಅದು ನೀಡುತ್ತದೆ ಆಧುನಿಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ಗೆ ಮೂರು ಅಮೂಲ್ಯ ಸ್ತಂಭಗಳುಕಾರ್ಯಕ್ಷಮತೆ, ಭದ್ರತೆ ಮತ್ತು ಪ್ರಸ್ತುತ ಪರಿಕರಗಳು. ಈ ಅಂಶಗಳು ಏಕೆ ಪ್ರಸ್ತುತವಾಗಿವೆ ಎಂದು ನೋಡೋಣ.

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

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

ಸ್ಪರ್ಧೆಯ ಕ್ಷೇತ್ರದಲ್ಲಿ, ರಸ್ಟ್ ಸಾಮಾನ್ಯವಾಗಿ ಕರೆಯಲ್ಪಡುವದನ್ನು ಅನುಸರಿಸುತ್ತದೆ "ಭಯವಿಲ್ಲದೆ ಏಕಕಾಲಿಕತೆ"ಸುರಕ್ಷಿತ ಕೋಡ್‌ನಲ್ಲಿ ಡೇಟಾ ರೂಟ್‌ಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವುದನ್ನು ಟೈಪ್ ಸಿಸ್ಟಮ್ ಸ್ವತಃ ತಡೆಯುತ್ತದೆ. ಥ್ರೆಡ್‌ಗಳ ನಡುವೆ ರೂಪಾಂತರಿತ ಡೇಟಾವನ್ನು ಹಂಚಿಕೊಳ್ಳಲು ನೀವು ಬಯಸಿದರೆ, ನೀವು ಸೂಕ್ತವಾದ ಮೂಲಪದಗಳನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ, ಉದಾಹರಣೆಗೆ Mutex, RwLock o Arc, ಮತ್ತು ಕಂಪೈಲರ್ ಅಲಿಯಾಸಿಂಗ್ ಮತ್ತು ರೂಪಾಂತರ ನಿಯಮಗಳನ್ನು ಗೌರವಿಸಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

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

ಅನುಸ್ಥಾಪನೆ ಮತ್ತು ಅಗತ್ಯ ಉಪಕರಣಗಳು: ತುಕ್ಕು ಹಿಡಿಯುವುದು, ತುಕ್ಕು ಹಿಡಿಯುವುದು ಮತ್ತು ಸರಕು ಸಾಗಣೆ

ನಿಮ್ಮ ಮೊದಲ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ರಸ್ಟ್‌ನಲ್ಲಿ ಬರೆಯಲು ಮತ್ತು ಚಲಾಯಿಸಲು, ಪ್ರಾರಂಭಿಸಲು ಸಾಮಾನ್ಯ ಮಾರ್ಗವೆಂದರೆ ಅಧಿಕೃತ ಟೂಲ್‌ಚೈನ್ ಅನ್ನು ಸ್ಥಾಪಿಸುವುದು ಬಳಸಿ ರಸ್ಟಪ್ (ನೋಡಿ ರಸ್ಟ್ ಬಗ್ಗೆ ಸಂಪೂರ್ಣ ಪರಿಚಯ), ಎಲ್ಲಾ ಪ್ರಮುಖ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ಗಳಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಸರಳ ಸ್ಥಾಪಕ ಮತ್ತು ಆವೃತ್ತಿ ವ್ಯವಸ್ಥಾಪಕ.

ಕಾನ್ ರಸ್ಟಪ್ ನೀವು ಯಾವುದನ್ನೂ ಮುರಿಯದೆ ರಸ್ಟ್‌ನ ವಿವಿಧ ಆವೃತ್ತಿಗಳನ್ನು (ಸ್ಥಿರ, ಬೀಟಾ, ನೈಟ್ಲಿ) ಸ್ಥಾಪಿಸಬಹುದು, ನವೀಕರಿಸಬಹುದು ಮತ್ತು ಬದಲಾಯಿಸಬಹುದು. ಅಧಿಕೃತ ರಸ್ಟ್ ಪರಿಕರಗಳ ಪುಟಕ್ಕೆ ಹೋಗಿ ಮತ್ತು ನಿಮ್ಮ ಸಿಸ್ಟಮ್‌ಗಾಗಿ ಹಂತಗಳನ್ನು ಅನುಸರಿಸಿ. ಸ್ಥಾಪಿಸಿದ ನಂತರ, ಕಂಪೈಲರ್ ಲಭ್ಯವಿರುತ್ತದೆ. rustc, ಯೋಜನಾ ವ್ಯವಸ್ಥಾಪಕ cargo ಮತ್ತು ಅವನದೇ rustup ನಿಮ್ಮಲ್ಲಿ ಟರ್ಮಿನಲ್.

ಕಂಪೈಲರ್ rustc ಇದು ನಿಮ್ಮ ಮೂಲ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಬೈನರಿಗಳು ಅಥವಾ ಲೈಬ್ರರಿಗಳಾಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ. ನೀವು ಅದನ್ನು ನೇರವಾಗಿ ಆಹ್ವಾನಿಸಬಹುದಾದರೂ ಕೋಮಾಂಡೋಸ್ ಕೊಮೊ rustc main.rsಪ್ರಾಯೋಗಿಕವಾಗಿ, ನೀವು ಯಾವಾಗಲೂ ಕರೆಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಕಾರ್ಗೋ ಮೂಲಕ ಕೆಲಸ ಮಾಡುತ್ತೀರಿ rustc ಸರಿಯಾದ ಆಯ್ಕೆಗಳೊಂದಿಗೆ.

ಕೆಲಸದ ಹರಿವಿನ ಕೇಂದ್ರ ಸಾಧನವೆಂದರೆ ಕಾರ್ಗೋಕೆಲವೇ ಆಜ್ಞೆಗಳೊಂದಿಗೆ, ನೀವು crates.io ನಲ್ಲಿ ಹೊಸ ಯೋಜನೆಗಳನ್ನು ರಚಿಸಬಹುದು, ಅವಲಂಬನೆಗಳನ್ನು ನಿರ್ವಹಿಸಬಹುದು, ಕಂಪೈಲ್ ಮಾಡಬಹುದು, ಚಲಾಯಿಸಬಹುದು, ಪರೀಕ್ಷಿಸಬಹುದು ಮತ್ತು ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಪ್ರಕಟಿಸಬಹುದು. ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸುವ ಕೆಲವು ಮೂಲ ಆಜ್ಞೆಗಳು: cargo new, cargo build, cargo run, cargo test y cargo check, ಇದು ಅಂತಿಮ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಫೈಲ್ ಅನ್ನು ಉತ್ಪಾದಿಸದೆ ಕೋಡ್ ಅನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ, ದೋಷಗಳನ್ನು ತ್ವರಿತವಾಗಿ ಪತ್ತೆಹಚ್ಚಲು ಸೂಕ್ತವಾಗಿದೆ.

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

ನಿಮ್ಮ ಮೊದಲ ಕಾರ್ಯಕ್ರಮ: ಹಲೋ, ರಸ್ಟ್, ಮತ್ತು ಮೂಲ ಹರಿವು

ಯಾವುದೇ ಭಾಷೆಯಲ್ಲಿ ಸಂಭಾಷಣೆಯನ್ನು ಪ್ರಾರಂಭಿಸಲು ಶ್ರೇಷ್ಠ ಮಾರ್ಗವೆಂದರೆ ಪ್ರಸಿದ್ಧ "ಹಲೋ, ವರ್ಲ್ಡ್". ರಸ್ಟ್‌ನಲ್ಲಿ, ಒಂದು ಫೈಲ್ main.rs ಕನಿಷ್ಠ ಪಕ್ಷ ಒಂದು ಕಾರ್ಯದಂತಹ ಸರಳವಾದದ್ದನ್ನು ಒಳಗೊಂಡಿರಬಹುದು. main ಅದು ಪರದೆಯ ಮೇಲೆ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.

ಪ್ರಮುಖ ಪದ fn ನಾವು ಒಂದು ಫಂಕ್ಷನ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತಿದ್ದೇವೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆ, ಮತ್ತು main ಇದು ಪ್ರೋಗ್ರಾಂನ ಪ್ರವೇಶ ಬಿಂದು. ಕಾರ್ಯದ ಕೋಡ್ ಬ್ಲಾಕ್ ಕರ್ಲಿ ಬ್ರೇಸ್‌ಗಳ ಒಳಗೆ ಹೋಗುತ್ತದೆ. ಕನ್ಸೋಲ್‌ಗೆ ಬರೆಯಲು, ಮ್ಯಾಕ್ರೊ println!, ಇದು ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಅಕ್ಷರಶಃ (ಅಥವಾ ಬುಕ್‌ಮಾರ್ಕ್‌ಗಳೊಂದಿಗೆ ಟೆಂಪ್ಲೇಟ್) ಸ್ವೀಕರಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಹೊಸ ಸಾಲಿನ ಅಕ್ಷರದಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುವ ಪ್ರಮಾಣಿತ ಔಟ್‌ಪುಟ್‌ಗೆ ಕಳುಹಿಸುತ್ತದೆ.

ನೀವು ನೇರವಾಗಿ ಕಂಪೈಲ್ ಮಾಡಿದರೆ rustc main.rs, ನೀವು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಬೈನರಿಯನ್ನು ಪಡೆಯುತ್ತೀರಿ (ಉದಾಹರಣೆಗೆ, main o main.exe (ಸಿಸ್ಟಮ್ ಅನ್ನು ಅವಲಂಬಿಸಿ). ನೀವು ಅದನ್ನು ಚಲಾಯಿಸಿದಾಗ, ನೀವು ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ ಸಂದೇಶವನ್ನು ನೋಡುತ್ತೀರಿ. ಆದರೆ ರಸ್ಟ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಭಾಷಾವೈಶಿಷ್ಟ್ಯವೆಂದರೆ ಕಾರ್ಗೋ ಯೋಜನೆಯಲ್ಲಿ ಮುಂದಾಳತ್ವ ವಹಿಸಲು ಬಿಡುವುದು.

ಕಾನ್ cargo new nombre_proyecto ಫೋಲ್ಡರ್ ರಚನೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ರಚಿಸಲಾಗುತ್ತದೆ a src/main.rs "ಹಲೋ, ವರ್ಲ್ಡ್" ಮತ್ತು ಫೈಲ್‌ನೊಂದಿಗೆ ಈಗಾಗಲೇ ಸಿದ್ಧಪಡಿಸಲಾಗಿದೆ. Cargo.toml ಇದು ಮೆಟಾಡೇಟಾ ಮತ್ತು ಭವಿಷ್ಯದ ಅವಲಂಬನೆಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಅಲ್ಲಿಂದ, cargo run ಬೈನರಿಯನ್ನು ಕಂಪೈಲ್ ಮಾಡಿ ಮತ್ತು ರನ್ ಮಾಡಿಮತ್ತು ಅದು ಬದಲಾವಣೆಗಳನ್ನು ಪತ್ತೆ ಮಾಡಿದಾಗ ಮಾತ್ರ ಮರುಸಂಕಲಿಸುತ್ತದೆ.

ಈ ರೀತಿಯ ಕೆಲಸವು ಅನುಕೂಲಕರವಾಗಿರುವುದಲ್ಲದೆ, ಆರಂಭದಿಂದಲೂ ಪ್ರಮಾಣಿತ ರಸ್ಟ್ ಪರಿಸರ ವ್ಯವಸ್ಥೆಯನ್ನು ಬಳಸಲು ನಿಮ್ಮನ್ನು ಒಗ್ಗಿಸಿಕೊಳ್ಳುತ್ತದೆ. ಇದು ನೀವು ಏಕಕಾಲಿಕತೆ, ನೆಟ್‌ವರ್ಕಿಂಗ್, ಪರೀಕ್ಷೆ ಅಥವಾ ನಿಮಗೆ ಬೇಕಾದುದಕ್ಕಾಗಿ ಕ್ರೇಟ್‌ಗಳನ್ನು ಸೇರಿಸಲು ಪ್ರಾರಂಭಿಸಿದಾಗ ತುಂಬಾ ಉಪಯುಕ್ತವಾಗಿದೆ.

// ನಾವು ಮುಖ್ಯ ಕಾರ್ಯವನ್ನು ಘೋಷಿಸುತ್ತೇವೆ: ಪ್ರೋಗ್ರಾಂ ಎಂಟ್ರಿ ಪಾಯಿಂಟ್ fn main() { // ಕನ್ಸೋಲ್‌ಗೆ ಪಠ್ಯವನ್ನು ಮುದ್ರಿಸಲು ನಾವು println! ಮ್ಯಾಕ್ರೋವನ್ನು ಬಳಸುತ್ತೇವೆ println!("ಹಲೋ, ವರ್ಲ್ಡ್!"); }

ಅಸ್ಥಿರಗಳು, ರೂಪಾಂತರ ಮತ್ತು ಮೂಲ ದತ್ತಾಂಶ ಪ್ರಕಾರಗಳು

ರಸ್ಟ್ ನಲ್ಲಿ, ವೇರಿಯೇಬಲ್ ಗಳನ್ನು ಕೀವರ್ಡ್ ನೊಂದಿಗೆ ಘೋಷಿಸಲಾಗುತ್ತದೆ. let, ಮತ್ತು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಬದಲಾಗುವುದಿಲ್ಲಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ನೀವು ಅವರಿಗೆ ಒಂದು ಮೌಲ್ಯವನ್ನು ನಿಗದಿಪಡಿಸಿದ ನಂತರ, ನೀವು ಅದನ್ನು ರೂಪಾಂತರಿಸಬಹುದಾದ ಎಂದು ಸ್ಪಷ್ಟವಾಗಿ ಘೋಷಿಸದ ಹೊರತು ಅದನ್ನು ಮಾರ್ಪಡಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ mut.

ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಬದಲಾಗದಿರುವುದು ಸೂಕ್ಷ್ಮ ತರ್ಕ ದೋಷಗಳನ್ನು ತಪ್ಪಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಬಹು ಥ್ರೆಡ್‌ಗಳು ಒಂದೇ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಲು ಬಯಸಬಹುದಾದ ಸಮಕಾಲೀನ ಕಾರ್ಯಕ್ರಮಗಳಲ್ಲಿ. ನೀವು ಅದನ್ನು ಬದಲಾಯಿಸಬೇಕಾದರೆ, ನೀವು ಹೀಗೆ ಬರೆಯುತ್ತೀರಿ let mut contador = 0;ಅಲ್ಲಿಂದ ನೀವು ಹೊಸ ಮೌಲ್ಯಗಳನ್ನು ಮರು ನಿಯೋಜಿಸಬಹುದು contador.

ತುಕ್ಕು ಕೂಡ ಕರೆಯಲ್ಪಡುವದನ್ನು ಅನುಮತಿಸುತ್ತದೆ ನೆರಳುನೀವು ಅದೇ ಹೆಸರಿನ ಹೊಸ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಅದೇ ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಘೋಷಿಸಬಹುದು, ಹಿಂದಿನದನ್ನು ಮರೆಮಾಡಬಹುದು. ಇದು ರೂಪಾಂತರಕ್ಕೆ ಸಮನಾಗಿರುವುದಿಲ್ಲ, ಏಕೆಂದರೆ ನೀವು ಹೊಸ ಮೌಲ್ಯವನ್ನು ರಚಿಸುತ್ತಿದ್ದೀರಿ (ಅದು ಬೇರೆ ಪ್ರಕಾರದ್ದಾಗಿರಬಹುದು). ಉದಾಹರಣೆಗೆ, ನೀವು ಸ್ಟ್ರಿಂಗ್‌ನಿಂದ ಪೂರ್ಣಾಂಕಕ್ಕೆ ಅದೇ ಹೆಸರನ್ನು ಬಳಸಿಕೊಂಡು ಪರಿವರ್ತಿಸಬಹುದು, ಅದು ಹೊಸ ಘೋಷಣೆಯಾಗಿದ್ದರೆ let.

ರಸ್ಟ್ ನ ವಿಧದ ವ್ಯವಸ್ಥೆಯು ಸ್ಥಿರವಾಗಿದೆ, ಅಂದರೆ ಪ್ರತಿಯೊಂದು ವೇರಿಯೇಬಲ್‌ನ ಪ್ರಕಾರವನ್ನು ಸಂಕಲನದಲ್ಲಿ ತಿಳಿಯಲಾಗುತ್ತದೆ.ಆದಾಗ್ಯೂ, ಪ್ರಕಾರದ ನಿರ್ಣಯವು ಸಾಕಷ್ಟು ಪ್ರಭಾವಶಾಲಿಯಾಗಿದೆ: ನೀವು ಬರೆದರೆ let x = 5;ಕಂಪೈಲರ್ ಅದನ್ನು ಒಂದು ಎಂದು ಊಹಿಸುತ್ತದೆ i32 ನೀವು ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳದ ಹೊರತು. ನೀವು ಟಿಪ್ಪಣಿಗಳನ್ನು ಸೇರಿಸಬಹುದು ಉದಾಹರಣೆಗೆ let x: i64 = 5; ನೀವು ಸ್ಪಷ್ಟವಾಗಿ ಹೇಳಲು ಬಯಸಿದಾಗ.

ಲಭ್ಯವಿರುವ ಸ್ಕೇಲಾರ್ ಪ್ರಕಾರಗಳಲ್ಲಿ ಸಹಿ ಮಾಡಲಾದ ಮತ್ತು ಸಹಿ ಮಾಡದ ಪೂರ್ಣಾಂಕಗಳು (i8, u8, i32, ಇತ್ಯಾದಿ), ತೇಲುವವುಗಳು (f32, f64), ಬೂಲಿಯನ್‌ಗಳು (bool) ಮತ್ತು ಯೂನಿಕೋಡ್ ಅಕ್ಷರಗಳು (char). ಈ ಸರಳ ಪ್ರಕಾರಗಳು ಸಾಮಾನ್ಯವಾಗಿ ನಕಲಿಸಲು ಅಗ್ಗವಾಗಿದ್ದು, ಅನೇಕವು ಈ ಗುಣಲಕ್ಷಣವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತವೆ. Copyಅಂದರೆ ನೀವು ಅವುಗಳನ್ನು ನಿಯೋಜಿಸಿದಾಗ ಅಥವಾ ಒಂದು ಕಾರ್ಯಕ್ಕೆ ರವಾನಿಸಿದಾಗ, ಅವುಗಳನ್ನು ಸರಿಸುವ ಬದಲು ನಕಲಿಸಲಾಗುತ್ತದೆ.

ರಸ್ಟ್‌ನಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್‌ಗಳು: &str ಮತ್ತು ಸ್ಟ್ರಿಂಗ್

ರಸ್ಟ್‌ನಲ್ಲಿ ಪಠ್ಯ ನಿರ್ವಹಣೆ ಮೊದಲಿಗೆ ಸ್ವಲ್ಪ ಗೊಂದಲಮಯವಾಗಿರಬಹುದು ಏಕೆಂದರೆ ಅದು ಸ್ಪಷ್ಟವಾಗಿ ವ್ಯತ್ಯಾಸವನ್ನು ತೋರಿಸುತ್ತದೆ ಸರಪಳಿ "ಸ್ಲೈಸ್‌ಗಳು" ಮತ್ತು ಸ್ವಾಮ್ಯದ ಸರಪಳಿಗಳುಎರಡು ಪ್ರಮುಖ ತುಣುಕುಗಳು &str y String.

Un &str ಇದು ಒಂದು ಬದಲಾಗದ ಸರಪಳಿಯ ತುಂಡುಎಲ್ಲೋ ಸಂಗ್ರಹವಾಗಿರುವ UTF-8 ಬೈಟ್ ಅನುಕ್ರಮದ ನೋಟ. ವಿಶಿಷ್ಟ ಉದಾಹರಣೆಗಳಲ್ಲಿ ಲಿಟರಲ್‌ಗಳು ಸೇರಿವೆ "Hola"ಯಾವ ರೀತಿಯವು &'static str (ಅವು ಪ್ರೋಗ್ರಾಂನ ಸಂಪೂರ್ಣ ಜೀವಿತಾವಧಿಯಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿರುತ್ತವೆ ಮತ್ತು ಬೈನರಿಯಲ್ಲಿ ಎಂಬೆಡ್ ಆಗಿರುತ್ತವೆ.) ಸ್ಲೈಸ್‌ಗಳು ಡೇಟಾವನ್ನು ಹೊಂದಿರುವುದಿಲ್ಲ; ಅವು ಅದನ್ನು ಮಾತ್ರ ಸೂಚಿಸುತ್ತವೆ.

Stringಮತ್ತೊಂದೆಡೆ, ಒಂದು ಸ್ವಂತ ಸ್ಟ್ರಿಂಗ್, ರೂಪಾಂತರಿಸಬಹುದಾದ ಮತ್ತು ರಾಶಿಯಲ್ಲಿ ಹೋಸ್ಟ್ ಮಾಡಲಾಗಿದೆಇದನ್ನು ಮರುಗಾತ್ರಗೊಳಿಸಬಹುದು, ಜೋಡಿಸಬಹುದು, ಅದರ ಆಸ್ತಿಯನ್ನು ಚಲಿಸುವ ಮೂಲಕ ಕಾರ್ಯಗಳ ನಡುವೆ ರವಾನಿಸಬಹುದು, ಇತ್ಯಾದಿ. ನೀವು ಡೈನಾಮಿಕ್ ಪಠ್ಯವನ್ನು ನಿರ್ಮಿಸಲು ಅಥವಾ ರಚನೆಗಳ ಒಳಗೆ ದೀರ್ಘಕಾಲ ಸಂಗ್ರಹಿಸಲು ಬಯಸಿದಾಗ ಇದನ್ನು ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ.

ಹಲವು ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ನೀವು ಒಂದು ಮತ್ತು ಇನ್ನೊಂದರ ನಡುವೆ ರೂಪಾಂತರಗೊಳ್ಳುತ್ತೀರಿ: ಉದಾಹರಣೆಗೆ, ನೀವು ಒಂದು ರಚಿಸುತ್ತೀರಿ String::from("hola") ಒಂದು ತುಂಡಿನಿಂದಅಥವಾ ನೀವು ಎರವಲು ಪಡೆಯುತ್ತೀರಿ &str ಎ String ಓದಲು ಮಾತ್ರ ಅಗತ್ಯವಿರುವ ಕಾರ್ಯಗಳಿಗೆ ಉಲ್ಲೇಖಗಳನ್ನು ರವಾನಿಸುವ ಮೂಲಕ.

ಸ್ವಾಮ್ಯದ ಮತ್ತು ಎರವಲು ಪಡೆದ ದತ್ತಾಂಶಗಳ ನಡುವಿನ ಈ ಪ್ರತ್ಯೇಕತೆಯು ಮೆಮೊರಿ ನಿರ್ವಹಣೆಗೆ ಪ್ರಮುಖವಾಗಿದೆ ಮತ್ತು ಉಳಿದ ಭಾಷೆಗೂ ವಿಸ್ತರಿಸುತ್ತದೆ: ಸಂಗ್ರಹಣೆಗಳು, ರಚನೆಗಳು ಮತ್ತು ಎನುಮ್‌ಗಳು ಯಾರು ಮಾಲೀಕತ್ವ ಹೊಂದಿದ್ದಾರೆ ಮತ್ತು ಯಾರು ಮಾತ್ರ ನೋಡುತ್ತಾರೆ ಎಂಬ ಒಂದೇ ರೀತಿಯ ವಿಚಾರಗಳನ್ನು ಅನುಸರಿಸುತ್ತವೆ.

ಕಾರ್ಯಗಳು, ನಿಯಂತ್ರಣ ಹರಿವು ಮತ್ತು ಕಾಮೆಂಟ್‌ಗಳು

ರಸ್ಟ್‌ನಲ್ಲಿನ ಕಾರ್ಯಗಳನ್ನು ಇದರೊಂದಿಗೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ fn ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ತಾರ್ಕಿಕ ಘಟಕಗಳಾಗಿ ಸಂಘಟಿಸಲು ಅನುಮತಿಸಿ. ಪ್ರತಿಯೊಂದು ಕಾರ್ಯವು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ ಅದರ ನಿಯತಾಂಕಗಳ ಪ್ರಕಾರ ಮತ್ತು ಅದರ ರಿಟರ್ನ್ ಪ್ರಕಾರ ಬಾಣವನ್ನು ಅನುಸರಿಸುವುದು ->ಅದು ಅರ್ಥಪೂರ್ಣವಾದ ಏನನ್ನೂ ಹಿಂತಿರುಗಿಸದಿದ್ದರೆ, ಏಕೀಕೃತ ಪ್ರಕಾರವನ್ನು ಊಹಿಸಲಾಗುತ್ತದೆ. ().

ಒಂದು ಪ್ರಮುಖ ವಿವರವೆಂದರೆ, ಅರ್ಧವಿರಾಮ ಚಿಹ್ನೆ ಇಲ್ಲದ ಕಾರ್ಯದಲ್ಲಿ (ಅಥವಾ ಯಾವುದೇ ಬ್ಲಾಕ್) ಕೊನೆಯ ಅಭಿವ್ಯಕ್ತಿಯನ್ನು ಸೂಚ್ಯ ರಿಟರ್ನ್ ಮೌಲ್ಯವಾಗಿ ತೆಗೆದುಕೊಳ್ಳಲಾಗುತ್ತದೆ. ನೀವು ಇದನ್ನು ಬಳಸಬಹುದು return ಆರಂಭಿಕ ರಿಟರ್ನ್‌ಗಳಿಗಾಗಿಆದರೆ ಭಾಷಾವೈಶಿಷ್ಟ್ಯ ಸಂಕೇತದಲ್ಲಿ, ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಅಂತಿಮ ಅಭಿವ್ಯಕ್ತಿಯನ್ನು ಇಲ್ಲದೆ ಬಿಡುತ್ತೀರಿ. ;.

ನಿಯಂತ್ರಣ ಹರಿವನ್ನು ಕ್ಲಾಸಿಕ್‌ಗಳೊಂದಿಗೆ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ. if/elseಕುಣಿಕೆಗಳು loop, while y forರಸ್ಟ್‌ನಲ್ಲಿ, if ಇದು ಮೌಲ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸುವ ಅಭಿವ್ಯಕ್ತಿಯಾಗಿದೆ.ಆದ್ದರಿಂದ ನೀವು ಅದನ್ನು ನೇರವಾಗಿ a ನಲ್ಲಿ ಬಳಸಬಹುದು letಶಾಖೆಗಳು ಒಂದೇ ಪ್ರಕಾರವನ್ನು ಹಿಂತಿರುಗಿಸಿದರೆ. for ಅವು ಸಾಮಾನ್ಯವಾಗಿ ಶ್ರೇಣಿಗಳು ಅಥವಾ ಸಂಗ್ರಹ ಪುನರಾವರ್ತಕಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುತ್ತವೆ ಮತ್ತು ಹಸ್ತಚಾಲಿತ ಸೂಚ್ಯಂಕಗಳ ಬದಲಿಗೆ ಶಿಫಾರಸು ಮಾಡಲಾದ ಆಯ್ಕೆಯಾಗಿದೆ.

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

ಮಾಲೀಕತ್ವ, ಸಾಲ ನೀಡುವಿಕೆ ಮತ್ತು ಜೀವಿತಾವಧಿ: ಸ್ಮರಣಶಕ್ತಿಯ ಭದ್ರತೆಯ ಅಡಿಪಾಯ.

ಇಲ್ಲಿ ನಾವು ರಸ್ಟ್‌ನ ಮೆಮೊರಿ ಮಾದರಿಯ ಹೃದಯಭಾಗವನ್ನು ತಲುಪುತ್ತೇವೆ: ವ್ಯವಸ್ಥೆ ಮಾಲೀಕತ್ವ, ಸಾಲ ಮತ್ತು ಜೀವಿತಾವಧಿಈ ನಿಯಮಗಳು ಉಲ್ಲೇಖಗಳು ಯಾವಾಗಲೂ ಮಾನ್ಯವಾಗಿರುತ್ತವೆ ಮತ್ತು ಸಂಗ್ರಹವಾದ ಕಸವಿಲ್ಲದೆ ಮೆಮೊರಿಯನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಬಿಡುಗಡೆ ಮಾಡಲಾಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಮಾಲೀಕತ್ವದ ಮೂಲ ನಿಯಮಗಳನ್ನು ಹೇಳುವುದು ಸರಳವಾಗಿದೆ, ಆದರೆ ಮೊದಲಿಗೆ ಅವುಗಳನ್ನು ಆಂತರಿಕಗೊಳಿಸುವುದು ಕಷ್ಟಕರವಾಗಬಹುದು: ಪ್ರತಿಯೊಂದು ಮೌಲ್ಯವು ಒಬ್ಬನೇ ಮಾಲೀಕರನ್ನು ಹೊಂದಿರುತ್ತದೆ.ಒಂದು ಸಮಯದಲ್ಲಿ ಒಬ್ಬ ಮಾಲೀಕರು ಮಾತ್ರ ಇರಲು ಸಾಧ್ಯ; ಮತ್ತು ಮಾಲೀಕರು ಅದರ ವ್ಯಾಪ್ತಿಯನ್ನು ತೊರೆದಾಗ, ಮೌಲ್ಯವು ನಾಶವಾಗುತ್ತದೆ ಮತ್ತು ಅದರ ಮೆಮೊರಿ ಬಿಡುಗಡೆಯಾಗುತ್ತದೆ. ಇದು ಅನ್ವಯಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ, a String: ಅದನ್ನು ಘೋಷಿಸಿದ ಬ್ಲಾಕ್ ಪೂರ್ಣಗೊಂಡ ನಂತರ, ಅದನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಆಹ್ವಾನಿಸಲಾಗುತ್ತದೆ drop ಇದು ರಾಶಿ ಮೆಮೊರಿಯನ್ನು ಮುಕ್ತಗೊಳಿಸುತ್ತದೆ.

ನೀವು ಇನ್ನೊಂದು ವೇರಿಯೇಬಲ್‌ಗೆ ಸರಿಯಾದ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸಿದಾಗ ಅಥವಾ ಅದನ್ನು ಒಂದು ಕಾರ್ಯಕ್ಕೆ ಮೌಲ್ಯದಿಂದ ರವಾನಿಸಿದಾಗ, ಆಸ್ತಿಯನ್ನು ಸ್ಥಳಾಂತರಿಸಲಾಗುತ್ತದೆ. ಇದರರ್ಥ ಸ್ಥಳಾಂತರದ ನಂತರ ಮೂಲ ವೇರಿಯೇಬಲ್ ಮಾನ್ಯವಾಗಿರುವುದನ್ನು ನಿಲ್ಲಿಸುತ್ತದೆ.ಈ ಚಲನೆಯ ಶಬ್ದಾರ್ಥವು ಡಬಲ್ ಬಿಡುಗಡೆಗಳನ್ನು ತಪ್ಪಿಸುತ್ತದೆ, ಏಕೆಂದರೆ ಒಂದೇ ಸಂಪನ್ಮೂಲವನ್ನು ಬಿಡುಗಡೆ ಮಾಡಲು ಇಬ್ಬರು ಮಾಲೀಕರು ಎಂದಿಗೂ ಪ್ರಯತ್ನಿಸುವುದಿಲ್ಲ.

ಮಾಲೀಕತ್ವವನ್ನು ಬದಲಾಯಿಸದೆಯೇ ಪ್ರೋಗ್ರಾಂನ ಬಹು ಭಾಗಗಳು ಒಂದೇ ಮೌಲ್ಯವನ್ನು ಪ್ರವೇಶಿಸಲು ಅನುಮತಿಸಲು, ರಸ್ಟ್ ಉಲ್ಲೇಖಗಳು ಮತ್ತು ಸಾಲವನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ. ನೀವು ಎರವಲು ಪಡೆದಾಗ, ನೀವು ಉಲ್ಲೇಖವನ್ನು ರಚಿಸುತ್ತೀರಿ &T (ಬದಲಾಗದ) ಅಥವಾ &mut T (ಪರಿವರ್ತಿಸಬಹುದಾದ) ಮೌಲ್ಯಕ್ಕೆ ಮಾಲೀಕತ್ವವನ್ನು ವರ್ಗಾಯಿಸದೆ. ಸಾಲ ಪರಿಶೀಲಕರ ನಿಯಮಗಳಿಂದ ಸಾಲವು ಸೀಮಿತವಾಗಿದೆ., ಇದು ಉಲ್ಲೇಖಗಳು ಅವರು ಸೂಚಿಸುವ ಡೇಟಾವನ್ನು ಮೀರಿಸುವುದಿಲ್ಲ ಮತ್ತು ರೂಪಾಂತರಿಸಬಹುದಾದ ಮತ್ತು ಹಂಚಿಕೆಯ ಪ್ರವೇಶಗಳು ಅಪಾಯಕಾರಿಯಾಗಿ ಮಿಶ್ರಣವಾಗಿಲ್ಲ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ.

ಸಾಲದ ನಿಯಮಗಳನ್ನು ಈ ಕೆಳಗಿನಂತೆ ಸಂಕ್ಷೇಪಿಸಬಹುದು: ಯಾವುದೇ ಸಮಯದಲ್ಲಿ, ನೀವು ಬಹು ಬದಲಾಯಿಸಲಾಗದ ಉಲ್ಲೇಖಗಳು ಒಂದು ಮೌಲ್ಯಕ್ಕೆ, ಅಥವಾ ಒಂದೇ ರೂಪಾಂತರಿತ ಉಲ್ಲೇಖಆದರೆ ಎರಡೂ ಒಂದೇ ಸಮಯದಲ್ಲಿ ಅಲ್ಲ. ಇದು ಹಂಚಿಕೆಯ ಸ್ಮರಣೆಯಲ್ಲಿ ಜನಾಂಗೀಯ ಪರಿಸ್ಥಿತಿಗಳನ್ನು ನಿವಾರಿಸುತ್ತದೆ: ಒಂದೋ ಅನೇಕ ಓದುಗರಿದ್ದಾರೆ, ಅಥವಾ ಒಬ್ಬ ಪ್ರತ್ಯೇಕ ಬರಹಗಾರರಿದ್ದಾರೆ; ಒಂದೇ ಸಮಯದಲ್ಲಿ ಒಂದೇ ದತ್ತಾಂಶದ ಮೇಲೆ ಏಕಕಾಲದಲ್ಲಿ ಓದುಗರು ಮತ್ತು ಬರಹಗಾರರು ಎಂದಿಗೂ ಇರಬಾರದು.

ಸಂಯೋಜಿತ ಪ್ರಕಾರಗಳು: ರಚನೆಗಳು, ಎನಮ್‌ಗಳು ಮತ್ತು ಸ್ಮಾರ್ಟ್ ಪಾಯಿಂಟರ್‌ಗಳು

ಸಂಬಂಧಿತ ಡೇಟಾವನ್ನು ಉತ್ಕೃಷ್ಟ ರಚನೆಗಳಾಗಿ ಗುಂಪು ಮಾಡಲು ರಸ್ಟ್ ಹಲವಾರು ಮಾರ್ಗಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ, ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ರಚನೆಗಳುಒಂದು ರಚನೆಯು ನಿಮಗೆ ಹೆಸರಿಸಲಾದ ಕ್ಷೇತ್ರಗಳೊಂದಿಗೆ ಕಸ್ಟಮ್ ಪ್ರಕಾರವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಅನುಮತಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ ಇಮೇಲ್, ಹೆಸರು, ಚಟುವಟಿಕೆ ಸ್ಥಿತಿ ಮತ್ತು ಲಾಗಿನ್ ಕೌಂಟರ್ ಹೊಂದಿರುವ ಬಳಕೆದಾರ.

ರಚನೆಯ ನಿದರ್ಶನವನ್ನು ರಚಿಸಲು, ನೀವು ಅದರ ಎಲ್ಲಾ ಕ್ಷೇತ್ರಗಳನ್ನು ಭರ್ತಿ ಮಾಡಿ, ಮತ್ತು ನಂತರ ಅದರ ಮೌಲ್ಯಗಳನ್ನು ಮಾರ್ಪಡಿಸಲು ಅದನ್ನು ಹೊಂದಿರುವ ವೇರಿಯೇಬಲ್ ಅನ್ನು ರೂಪಾಂತರಿಸಬಹುದಾದಂತೆ ಗುರುತಿಸಬಹುದು. ರಚನೆ ನವೀಕರಣ ಸಿಂಟ್ಯಾಕ್ಸ್ ಸಹ ಇದೆ, ಇದು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಒಂದರಿಂದ ಕೆಲವು ಕ್ಷೇತ್ರಗಳನ್ನು ಮರುಬಳಕೆ ಮಾಡುವ ಮೂಲಕ ಹೊಸ ನಿದರ್ಶನವನ್ನು ನಿರ್ಮಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ..otro_struct.

ದಿ ಎನುಮ್ಸ್ ಅವು ಮತ್ತೊಂದು ಅಗತ್ಯ ಆಧಾರಸ್ತಂಭ: ಅವು ಹಲವಾರು ಸಂಭಾವ್ಯ ರೂಪಾಂತರಗಳಲ್ಲಿ ಒಂದಾಗಬಹುದಾದ ಪ್ರಕಾರವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ನಿಮಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಡುತ್ತವೆ, ಪ್ರತಿಯೊಂದೂ ತನ್ನದೇ ಆದ ಸಂಬಂಧಿತ ಡೇಟಾವನ್ನು ಹೊಂದಿರುವ ಅಥವಾ ಇಲ್ಲದೆ. ಒಂದು ಶ್ರೇಷ್ಠ ಉದಾಹರಣೆಯೆಂದರೆ ಒಂದು ರೂಪಾಂತರದೊಂದಿಗೆ IP ವಿಳಾಸಗಳಿಗೆ ಎನಮ್. V4 ಇದು ನಾಲ್ಕು ಆಕ್ಟೆಟ್‌ಗಳನ್ನು ಮತ್ತು ಇನ್ನೊಂದನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ V6 ಅದು IPv6 ಸಂಕೇತದೊಂದಿಗೆ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ.

ರಸ್ಟ್‌ನ ಪ್ರಮಾಣಿತ ಗ್ರಂಥಾಲಯವು ಎರಡು ಪ್ರಮುಖ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿದೆ: Option<T> y Result<T, E>ಮೊದಲನೆಯದು ಒಂದು ಮೌಲ್ಯದ (ಏನಾದರೂ ಅಥವಾ ಏನೂ ಇಲ್ಲ) ಉಪಸ್ಥಿತಿ ಅಥವಾ ಅನುಪಸ್ಥಿತಿಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ಮತ್ತು ಶೂನ್ಯ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ತಪ್ಪಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ; ಎರಡನೆಯದು ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಮಾಡೆಲ್ ಮಾಡುತ್ತದೆ, ಅದು ಸರಿಯಾದ ಫಲಿತಾಂಶ ಅಥವಾ ದೋಷವನ್ನು ಹಿಂತಿರುಗಿಸಿ., ದೋಷ ನಿರ್ವಹಣೆ ಸ್ಪಷ್ಟ ಮತ್ತು ಸುರಕ್ಷಿತವಾಗಿರಬೇಕು ಎಂದು ಒತ್ತಾಯಿಸುತ್ತದೆ.

ಡೈನಾಮಿಕ್ ಮೆಮೊರಿಯನ್ನು ನಿರ್ವಹಿಸಲು ಮತ್ತು ಡೇಟಾವನ್ನು ಹಂಚಿಕೊಳ್ಳಲು, ರಸ್ಟ್ ಸ್ಮಾರ್ಟ್ ಪಾಯಿಂಟರ್‌ಗಳು ಕೊಮೊ Box<T>, ಇದು ಮೌಲ್ಯವನ್ನು ರಾಶಿಗೆ ಸರಿಸುತ್ತದೆ ಮತ್ತು ಅನನ್ಯ ಮಾಲೀಕತ್ವವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ; Rc<T>, ಏಕ-ಥ್ರೆಡ್ ಪರಿಸರಗಳಿಗೆ ಹಂಚಿಕೆಯಾದ ಉಲ್ಲೇಖ ಎಣಿಕೆ; ಮತ್ತು Arc<T>, ಹೋಲುತ್ತದೆ Rc ಆದರೆ ಬಹು ಥ್ರೆಡ್‌ಗಳಿಗೆ ಸುರಕ್ಷಿತವಾಗಿದೆ. ಡೈನಾಮಿಕ್ ಮೆಮೊರಿಯನ್ನು ಏಕಕಾಲಿಕತೆಯೊಂದಿಗೆ ಸಂಯೋಜಿಸುವಾಗ ಅವುಗಳನ್ನು ಸರಿಯಾಗಿ ಬಳಸುವುದು ನಿರ್ಣಾಯಕವಾಗಿದೆ.

ಸರಕು ಮತ್ತು ಕ್ರೇಟ್ಸ್ ಪರಿಸರ ವ್ಯವಸ್ಥೆ

ಕಾರ್ಗೋ ಎಂಬುದು ರಸ್ಟ್ ಪರಿಸರ ವ್ಯವಸ್ಥೆಯನ್ನು ಒಟ್ಟಿಗೆ ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವ ಅಂಟು: ಸಂಕಲನ, ಅವಲಂಬನೆಗಳು ಮತ್ತು ಯೋಜನೆಯ ಜೀವನಚಕ್ರವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆಪ್ರತಿಯೊಂದು ಯೋಜನೆಯು ಒಂದು ಫೈಲ್ ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ. Cargo.toml ಇದು ಹೆಸರು, ಆವೃತ್ತಿ, ಭಾಷಾ ಆವೃತ್ತಿ ಮತ್ತು ಬಾಹ್ಯ ಅವಲಂಬನೆಗಳನ್ನು ಘೋಷಿಸುವ ಮ್ಯಾನಿಫೆಸ್ಟ್ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

ವಿಭಾಗ ಈ ಫೈಲ್ ನಿಮಗೆ ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಕ್ರೇಟ್‌ಗಳನ್ನು ಅವುಗಳ ಆವೃತ್ತಿಗಳೊಂದಿಗೆ ಪಟ್ಟಿ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ. ನೀವು ಚಲಾಯಿಸಿದಾಗ cargo build o cargo runಕಾರ್ಗೋ ಈ ಕ್ರೇಟ್‌ಗಳನ್ನು crates.io ನಿಂದ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಡೌನ್‌ಲೋಡ್ ಮಾಡುತ್ತದೆ, ಅವುಗಳನ್ನು ಕಂಪೈಲ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ನಿಮ್ಮ ಯೋಜನೆಗೆ ಲಿಂಕ್ ಮಾಡುತ್ತದೆ. ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆ ಜನರೇಟರ್‌ಗಳು, ವೆಬ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ಅಥವಾ ಕ್ರಿಪ್ಟೋಗ್ರಾಫಿಕ್ ಲೈಬ್ರರಿಗಳನ್ನು ಸೇರಿಸುವುದು ತುಂಬಾ ಸುಲಭ.

ಅತ್ಯಂತ ಸಾಮಾನ್ಯವಾದ ಆಜ್ಞೆಗಳಲ್ಲಿ ಇವು ಸೇರಿವೆ: cargo new ಬೈನರಿ ಯೋಜನೆಗಳನ್ನು ಪ್ರಾರಂಭಿಸಲು o cargo new --lib ಗ್ರಂಥಾಲಯಗಳಿಗೆ; cargo build ಡೀಬಗ್ ಮೋಡ್‌ನಲ್ಲಿ ಕಂಪೈಲ್ ಮಾಡಲು; cargo build --release ಅತ್ಯುತ್ತಮವಾದ, ಉತ್ಪಾದನಾ-ಆಧಾರಿತ ಆವೃತ್ತಿಯನ್ನು ಪಡೆಯಲು; ಮತ್ತು cargo test ಪರೀಕ್ಷೆಗಳ ಬ್ಯಾಟರಿಯನ್ನು ಚಲಾಯಿಸಲು.

cargo check ಇದು ವಿಶೇಷ ಉಲ್ಲೇಖಕ್ಕೆ ಅರ್ಹವಾಗಿದೆ: ಇದು ಬೈನರಿಯನ್ನು ಉತ್ಪಾದಿಸದೆಯೇ ಕೋಡ್ ಅನ್ನು ಮಧ್ಯಂತರ ಬಿಂದುವಿಗೆ ಕಂಪೈಲ್ ಮಾಡುತ್ತದೆ, ಅದು ಅದನ್ನು ಮಾಡುತ್ತದೆ ಸಂಕಲನ ದೋಷಗಳನ್ನು ಬಹಳ ವೇಗವಾಗಿ ಪತ್ತೆಹಚ್ಚಿ.ಸಾಲ ಪರೀಕ್ಷಕನು ಗುಣಲಕ್ಷಣಗಳು, ಉಲ್ಲೇಖಗಳು ಮತ್ತು ಜೀವಿತಾವಧಿಯ ಸಮಸ್ಯೆಗಳನ್ನು ಎತ್ತಿ ತೋರಿಸುವಾಗ ತ್ವರಿತವಾಗಿ ಪುನರಾವರ್ತಿಸಲು ಇದು ಪರಿಪೂರ್ಣವಾಗಿದೆ.

ಈ ಪರಿಸರ ವ್ಯವಸ್ಥೆಯಿಂದಾಗಿ, ನಿಮ್ಮ ಯೋಜನೆಗಳನ್ನು ಸಣ್ಣ, ಉತ್ತಮವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಕ್ರೇಟ್‌ಗಳಾಗಿ ರಚಿಸುವುದು, ಅವುಗಳ ನಡುವೆ ಕೋಡ್ ಹಂಚಿಕೊಳ್ಳುವುದು ಮತ್ತು ಸಮುದಾಯವು ರಚಿಸಿದ ಪರಿಹಾರಗಳನ್ನು ಮರುಬಳಕೆ ಮಾಡುವುದು ಸಾಮಾನ್ಯವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ಮುಂದುವರಿದ ಏಕಕಾಲಿಕತೆಗಾಗಿ, ಅಸಮಕಾಲಿಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ಗಾಗಿ ಟೋಕಿಯೊ ಅಥವಾ ಹೆಚ್ಚಿನ ಕಾರ್ಯಕ್ಷಮತೆಯ ಏಕಕಾಲಿಕ ಡೇಟಾ ರಚನೆಗಳಿಗಾಗಿ ಕ್ರಾಸ್‌ಬೀಮ್‌ನಂತಹ ಕ್ರೇಟ್‌ಗಳನ್ನು ನೀವು ಹೊಂದಿರುತ್ತೀರಿ.

ತುಕ್ಕುಗಳಲ್ಲಿ ಏಕಕಾಲಿಕತೆ: ಎಳೆಗಳು, ಮ್ಯೂಟೆಕ್ಸ್‌ಗಳು, ಚಾನಲ್‌ಗಳು ಮತ್ತು ಪರಮಾಣುಗಳು

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

ಏಕಕಾಲದಲ್ಲಿ ಒಂದು ಅಥವಾ ಬಹು ಕೋರ್‌ಗಳಲ್ಲಿ ಕಾಲಾನಂತರದಲ್ಲಿ ಅತಿಕ್ರಮಿಸುವ ಬಹು ಕಾರ್ಯಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದನ್ನು ಕಾನ್ಕರೆನ್ಸಿ ಒಳಗೊಂಡಿರುತ್ತದೆ. ರಸ್ಟ್‌ನಲ್ಲಿ, ನೀವು ಸಮಾನಾಂತರವಾಗಿ ಕೆಲಸ ಮಾಡಲು ಸಿಸ್ಟಮ್ ಥ್ರೆಡ್‌ಗಳನ್ನು ರಚಿಸಬಹುದು ಮತ್ತು ಅವುಗಳ ನಡುವೆ ಡೇಟಾ ಹಂಚಿಕೆ ಸುರಕ್ಷಿತವಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಭಾಷೆ ನಿಮಗೆ ಮಾರ್ಗದರ್ಶನ ನೀಡುತ್ತದೆ. ಒಂದು ಶ್ರೇಷ್ಠ ದೋಷವೆಂದರೆ ರೇಸ್ ಸ್ಥಿತಿ, ಅಲ್ಲಿ ಎರಡು ಥ್ರೆಡ್‌ಗಳು ಏಕಕಾಲದಲ್ಲಿ ಡೇಟಾವನ್ನು ಪ್ರವೇಶಿಸುತ್ತವೆ ಮತ್ತು ಮಾರ್ಪಡಿಸುತ್ತವೆ ಮತ್ತು ಫಲಿತಾಂಶವು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಕ್ರಮವನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ - ಡೀಬಗ್ ಮಾಡಲು ತುಂಬಾ ಕಷ್ಟಕರವಾದ ವಿಷಯ.

ಹಂಚಿದ ಡೇಟಾಗೆ ಪ್ರವೇಶವನ್ನು ಸಂಘಟಿಸಲು, ರಸ್ಟ್ ಪ್ರಾಥಮಿಕ ಅಂಶಗಳನ್ನು ಅವಲಂಬಿಸಿದೆ, ಉದಾಹರಣೆಗೆ ಮ್ಯೂಟೆಕ್ಸ್ಇದು ಪರಸ್ಪರ ಹೊರಗಿಡುವಿಕೆಯನ್ನು ಖಾತರಿಪಡಿಸುತ್ತದೆ: ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಥ್ರೆಡ್ ಮಾತ್ರ ನಿರ್ಣಾಯಕ ವಿಭಾಗವನ್ನು ಪ್ರವೇಶಿಸಬಹುದು. ಇದರೊಂದಿಗೆ ಸಂಯೋಜನೆಯಲ್ಲಿ Arc<T> ಥ್ರೆಡ್‌ಗಳ ನಡುವೆ ಮಾಲೀಕತ್ವವನ್ನು ಹಂಚಿಕೊಳ್ಳಲು, ಮಾಲೀಕತ್ವ ಮತ್ತು ಎರವಲು ನಿಯಮಗಳಿಗೆ ಅನುಸಾರವಾಗಿ ಹಂಚಿಕೆಯಾದ ಡೇಟಾ ರಚನೆಗಳನ್ನು ನಿರ್ಮಿಸಲು ಸಾಧ್ಯವಿದೆ.

ರಸ್ಟ್‌ನಲ್ಲಿ ಹೆಚ್ಚು ಪ್ರೋತ್ಸಾಹಿಸಲ್ಪಡುವ ಇಂಟರ್-ಥ್ರೆಡ್ ಸಂವಹನದ ಮತ್ತೊಂದು ಸಾಮಾನ್ಯ ರೂಪವೆಂದರೆ ಸಂದೇಶ ರವಾನೆಯನ್ನು ಬಳಸಿಕೊಂಡು ವಾಹಿನಿಗಳುಒಂದು ಚಾನಲ್ ಕಳುಹಿಸುವ ತುದಿ ಮತ್ತು ಸ್ವೀಕರಿಸುವ ತುದಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ; ಥ್ರೆಡ್‌ಗಳು ಅದರ ಮೂಲಕ ಸಂದೇಶಗಳನ್ನು (ಮೌಲ್ಯಗಳನ್ನು) ರವಾನಿಸುತ್ತವೆ, ಇದು ರೂಪಾಂತರಿತ ಹಂಚಿಕೆಯ ಮೆಮೊರಿಯ ಬಳಕೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ವ್ಯವಸ್ಥೆಯ ಸ್ಥಿತಿಯ ಬಗ್ಗೆ ತಾರ್ಕಿಕತೆಯನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ.

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

ಸಮಕಾಲೀನತೆ ಮತ್ತು ಪರಮಾಣು ಕಲಿಕೆಗೆ ಮೊದಲ ಹಂತಗಳು ಮತ್ತು ಸಂಪನ್ಮೂಲಗಳು

ನೀವು ಯಾವುದೇ ಪೂರ್ವ ಅನುಭವವಿಲ್ಲದೆಯೇ ಅಖಾಡಕ್ಕೆ ಪ್ರವೇಶಿಸುತ್ತಿದ್ದರೆ, ಅತ್ಯಂತ ಬುದ್ಧಿವಂತ ಕ್ರಮವೆಂದರೆ ಸಾಮಾನ್ಯ ಪರಿಕಲ್ಪನೆಗಳ ಘನ ಅಡಿಪಾಯವನ್ನು ನಿರ್ಮಿಸಿ ರಸ್ಟ್‌ನ ಪರಮಾಣು ಪ್ರಕಾರಗಳಂತಹ ಮುಂದುವರಿದ ಪರಿಕರಗಳನ್ನು ನಿಭಾಯಿಸುವ ಮೊದಲು. "ಪ್ರೋಗ್ರಾಮಿಂಗ್ ರಸ್ಟ್" ನಂತಹ ಪುಸ್ತಕಗಳು ಕ್ರಮೇಣ ಪರಿಚಯವನ್ನು ನೀಡುತ್ತವೆ, ಆದರೆ ಪರಮಾಣು ಪ್ರಕಾರಗಳು ಮತ್ತು ಬೀಗಗಳ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸಿದ ಕೃತಿಗಳು ಮೊದಲಿಗೆ ದಟ್ಟವಾಗಿ ಕಾಣುವುದು ಸಾಮಾನ್ಯವಾಗಿದೆ.

ಹೆಚ್ಚಿನ ಅನುಕೂಲಕ್ಕಾಗಿ, ಮೊದಲು ನಿಮ್ಮನ್ನು ಪರಿಚಯ ಮಾಡಿಕೊಳ್ಳುವುದು ಸೂಕ್ತ ಸಾಂಪ್ರದಾಯಿಕ ಎಳೆಗಳು, ಪರಸ್ಪರ ಹೊರಗಿಡುವಿಕೆ ಮತ್ತು ಸಂದೇಶ ರವಾನೆ ರಸ್ಟ್ ನಲ್ಲಿ. ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ಆಟವಾಡಿ std::thread, std::sync::Mutex, std::sync::Arc ಮತ್ತು ಚಾನಲ್‌ಗಳು std::sync::mpsc ಕಂಪೈಲರ್ ನಿಮಗೆ ಹೇಗೆ ಮಾರ್ಗದರ್ಶನ ನೀಡುತ್ತದೆ ಮತ್ತು ಅದು ಯಾವ ದೋಷಗಳನ್ನು ತಪ್ಪಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಇದು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.

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

ರಸ್ಟ್‌ನಲ್ಲಿ ಪರಮಾಣುಗಳು ಮತ್ತು ಲಾಕ್‌ಗಳ ಕುರಿತು ನೀವು ಹೆಚ್ಚು ಮುಂದುವರಿದ ಪಠ್ಯಗಳಿಗೆ ಹಿಂತಿರುಗಿದಾಗ, ಪ್ರತಿಯೊಂದು ರಚನೆಯು ಯಾವ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿದೆ ಎಂಬುದನ್ನು ನೀವು ಈಗಾಗಲೇ ಅರ್ಥಮಾಡಿಕೊಂಡರೆ ತಾರ್ಕಿಕತೆಯನ್ನು ಅನುಸರಿಸುವುದು ತುಂಬಾ ಸುಲಭವಾಗುತ್ತದೆ: ಸರಳ ಥ್ರೆಡ್-ಸುರಕ್ಷಿತ ಕೌಂಟರ್‌ನಿಂದ ವಿವಾದವನ್ನು ಕಡಿಮೆ ಮಾಡುವ ಲಾಕ್-ಮುಕ್ತ ರಚನೆಗಳವರೆಗೆ.

ಅಂತಿಮವಾಗಿ, ರಸ್ಟ್ ಉನ್ನತ ಮಟ್ಟದ ಆದಿಮ ಮತ್ತು ಅತ್ಯಂತ ಕೆಳಮಟ್ಟದ ಪರಿಕರಗಳನ್ನು ನೀಡುತ್ತದೆ, ಮತ್ತು ಪರಮಾಣು ಸಂಕೇತವನ್ನು ಆಶ್ರಯಿಸುವ ಮೂಲಕ ನಿಮ್ಮ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವ ಸುರಕ್ಷಿತ ಮಟ್ಟದ ಅಮೂರ್ತತೆಯನ್ನು ಯಾವಾಗಲೂ ಆರಿಸುವುದು ಕೀಲಿಯಾಗಿದೆ. unsafe ಅದು ನಿಜವಾಗಿಯೂ ಮೌಲ್ಯವನ್ನು ಸೇರಿಸಿದಾಗ ಮತ್ತು ಅದರ ಪರಿಣಾಮಗಳನ್ನು ನೀವು ಸಂಪೂರ್ಣವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಂಡಾಗ ಮಾತ್ರ.

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