ಬ್ಯಾಷ್ನಲ್ಲಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್ - ಭಾಗ 1

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

"ಸ್ಕ್ರಿಪ್ಟ್" ಎಂದರೇನು?

ಮೂಲತಃ ಇದು ಒಂದು ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಕ್ಕಾಗಿ ಸಿಸ್ಟಮ್ ಬಳಸುವ ನಿರ್ದಿಷ್ಟ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಲ್ಲಿ ಬರೆಯಲಾದ ಕೋಡ್ ಅನ್ನು ಒಳಗೊಂಡಿರುವ ಫೈಲ್ ಎಂದು ನಾವು ಹೇಳುತ್ತೇವೆ. ಇದು ಬಾಹ್ಯ ಇನ್ಪುಟ್ ಅಥವಾ ಗ್ರಾಫಿಕಲ್ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಹೊಂದುವ ಅಗತ್ಯವಿಲ್ಲ, ಆದರೆ ಇದು ಸಂಸ್ಕರಿಸಿದ ಡೇಟಾವನ್ನು output ಟ್ಪುಟ್ ಮಾಡಲು ಕಾರಣವಾಗಬೇಕಾಗುತ್ತದೆ (ಬಳಕೆದಾರರು ಅದನ್ನು ನೋಡದಿದ್ದರೂ ಸಹ).

ಬ್ಯಾಷ್ ಬಳಸುವ ಭಾಷೆಯನ್ನು ತನ್ನದೇ ಆದ ವ್ಯಾಖ್ಯಾನಕಾರರಿಂದ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಮತ್ತು ಕಾರ್ನ್ ಶೆಲ್ (ksh) ಅಥವಾ C ಶೆಲ್ (csh) ನಂತಹ ಇತರ ಚಿಪ್ಪುಗಳ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಸಂಯೋಜಿಸುತ್ತದೆ. ನಿರ್ದಿಷ್ಟ ವಿತರಣೆಗೆ ಕಟ್ಟುನಿಟ್ಟಾಗಿ ಸಂಬಂಧಿಸಿದ ಆಜ್ಞೆಗಳನ್ನು ಹೊರತುಪಡಿಸಿ, ಸಾಮಾನ್ಯವಾಗಿ ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಬಳಸಲಾಗುವ ಅನೇಕ ಆಜ್ಞೆಗಳನ್ನು ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ ಸಹ ಬಳಸಬಹುದು.

ಸ್ಕ್ರಿಪ್ಟ್‌ನ ರಚನೆ

ಪ್ರಾರಂಭಿಸಲು ನಾವು ಪಠ್ಯ ಸಂಪಾದಕ ಮತ್ತು ಕಾರ್ಯಕ್ರಮದ ಬಯಕೆ ಹೊಂದಿರಬೇಕು. .Sh ವಿಸ್ತರಣೆಯೊಂದಿಗೆ ನಾವು ಉಳಿಸುವ ಫೈಲ್‌ಗಳನ್ನು ಕನ್ಸೋಲ್‌ನಿಂದ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು (ಅಥವಾ ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು), ಮೊದಲ ಸಾಲು ಈ ಕೆಳಗಿನವರೆಗೂ ಇರುತ್ತದೆ:

#! / ಬಿನ್ / ಬ್ಯಾಷ್

ಫೈಲ್ ಅನ್ನು ಚಲಾಯಿಸಲು ಕನ್ಸೋಲ್ ಅನ್ನು ಬಳಸಲು ಇದು ಸಿಸ್ಟಮ್ಗೆ ಹೇಳುತ್ತದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, # ಅಕ್ಷರವು ಕಾಮೆಂಟ್ಗಳನ್ನು ಬರೆಯಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಸರಳವಾದ ಉದಾಹರಣೆಯನ್ನು ರಚಿಸಲು ನಾವು ಈ ಕೆಳಗಿನ ಚಿತ್ರದಲ್ಲಿ ಕಂಡುಬರುವ ಇನ್ನೊಂದು ಸಾಲನ್ನು ಸೇರಿಸುತ್ತೇವೆ:

ಪ್ರತಿಧ್ವನಿ ಆಜ್ಞೆಯು ಪರದೆಯ ಮೇಲೆ ಸಂದೇಶವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ ವಿಶಿಷ್ಟವಾದ "ಹಲೋ ವರ್ಲ್ಡ್!" ನಾವು ಅದನ್ನು ಉಳಿಸಿ ಮತ್ತು ಅದನ್ನು ಕನ್ಸೋಲ್‌ನೊಂದಿಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಿದರೆ ನಾವು ಫಲಿತಾಂಶವನ್ನು ನೋಡುತ್ತೇವೆ.

ಮೂಲ ಆಜ್ಞೆಗಳು

ಕೆಳಗಿನ ಆಜ್ಞೆಗಳು ಸಾಮಾನ್ಯ ಮತ್ತು ಯಾವುದೇ ರೀತಿಯ ಪ್ರೋಗ್ರಾಂಗೆ ತುಂಬಾ ಉಪಯುಕ್ತವಾಗಿವೆ. ಇನ್ನೂ ಹಲವು ಇವೆ ಎಂದು ನಾವು ಸ್ಪಷ್ಟಪಡಿಸುತ್ತೇವೆ, ಆದರೆ ಸದ್ಯಕ್ಕೆ ನಾವು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಒಳಗೊಳ್ಳುತ್ತೇವೆ.

ಅಲಿಯಾಸ್: ಪದಗಳ ಸರಮಾಲೆಯನ್ನು ಚಿಕ್ಕದರಿಂದ ಬದಲಾಯಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ಇದು ಕೋಡ್ ಕಡಿತಕ್ಕೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

# ಪ್ರತಿ ಡೌನ್‌ಲೋಡ್ ಫೋಲ್ಡರ್ ಅಲಿಯಾಸ್ ಪರ್ = '/ ಮನೆ / ಬಳಕೆದಾರ / ಡೌನ್‌ಲೋಡ್‌ಗಳ ವಿಳಾಸದೊಂದಿಗೆ ಪ್ರತಿ ಅಲಿಯಾಸ್ ಅನ್ನು ರಚಿಸಿ # ನಾವು ಅದನ್ನು ಬಳಸಲು ಬಯಸುವ ಪ್ರತಿ ಬಾರಿಯೂ ನಾವು # ಹೊಸ ಪದಕ್ಕೆ ಕರೆ ಮಾಡಬೇಕು

ಬ್ರೇಕ್: ಲೂಪ್ ಆಯ್ಕೆ ಮಾಡುವವರೆಗೆ ಅಥವಾ ಆಯ್ಕೆ ಮಾಡಲು ತಕ್ಷಣವೇ ನಿರ್ಗಮಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ (ನಾವು ನಂತರ ಲೂಪ್‌ಗಳನ್ನು ವಿವರವಾಗಿ ಅಧ್ಯಯನ ಮಾಡುತ್ತೇವೆ)

# 1 ರಿಂದ 5 ರವರೆಗೆ ಕೌಂಟರ್ಗಾಗಿ ಪ್ರತಿ "ಲೂಪ್ನ ತಿರುವು" ಗಾಗಿ 1 ರಿಂದ 2 ರವರೆಗಿನ ಸಂಖ್ಯೆಗಳನ್ನು ನಿಯೋಜಿಸುವ ಲೂಪ್ ಅನ್ನು ರಚಿಸಿ # ನಾವು # ಕೌಂಟರ್ ವೇರಿಯೇಬಲ್ನ ಪ್ರಸ್ತುತ ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸುತ್ತೇವೆ, ಇದನ್ನು $ ಪ್ರತಿಧ್ವನಿ ಅಕ್ಷರದಿಂದ ವಿಶ್ಲೇಷಿಸಲಾಗುತ್ತದೆ. $ counter ”# ಕೌಂಟರ್ ಮೌಲ್ಯವು 3 ಕ್ಕೆ ಸಮನಾಗಿದ್ದರೆ [$ counter –eq 4] ನಂತರ # ಬ್ರೇಕ್ ಫೈಗಾಗಿ ಲೂಪ್ ನಿರ್ಗಮಿಸುತ್ತದೆ

ಮುಂದುವರಿಸಿ - ಅದು ಪ್ರಸ್ತುತ ಲೂಪ್ ಅನ್ನು ನಿರ್ಲಕ್ಷಿಸಿ ಮುಂದಿನದಕ್ಕೆ ಹೋಗುವುದನ್ನು ಹೊರತುಪಡಿಸಿ, ಮುರಿಯಲು ಹೋಲುತ್ತದೆ.

# 1 5 1 2 ರಲ್ಲಿ ಕೌಂಟರ್ಗಾಗಿ ಪ್ರತಿ "ಲೂಪ್ನ ತಿರುವು" ಗೆ 3 ರಿಂದ 4 ರವರೆಗಿನ ಸಂಖ್ಯೆಗಳನ್ನು ನಿಯೋಜಿಸುವ ಲೂಪ್ ಅನ್ನು ರಚಿಸಿ ಮುಂದಿನ ಸುತ್ತಿಗೆ ಜಿಗಿಯುವ ಮೂಲಕ ಪ್ರಸ್ತುತ ಚಕ್ರದ ಉಳಿದ ಭಾಗಗಳನ್ನು ವಿಶ್ಲೇಷಿಸುವುದನ್ನು ತಡೆಯುತ್ತದೆ, ಅಂದರೆ, # ಮೌಲ್ಯ 5 ಅನ್ನು ಮುದ್ರಿಸಲಾಗುವುದಿಲ್ಲ. ಮುಂದುವರಿಯಿರಿ fi echo "$ counter" ಮುಗಿದಿದೆ

ಘೋಷಿಸು: ಟೈಪ್‌ಸೆಟ್‌ನಂತೆಯೇ ಅಸ್ಥಿರಗಳನ್ನು ಘೋಷಿಸಿ ಮತ್ತು ಅವುಗಳನ್ನು ಮೌಲ್ಯಗಳನ್ನು ನಿಯೋಜಿಸಿ (ಅವು ಒಂದೇ ರೀತಿಯಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ). ನಾವು ಅದನ್ನು ಕೆಲವು ಆಯ್ಕೆಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಬಹುದು: -ಐ ಪೂರ್ಣಾಂಕಗಳನ್ನು ಘೋಷಿಸುತ್ತೇನೆ; -r ಓದಲು-ಮಾತ್ರ ಅಸ್ಥಿರಗಳಿಗಾಗಿ, ಅದರ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಲಾಗುವುದಿಲ್ಲ; –ಒಂದು ಮ್ಯಾಟ್ರಿಸೈಸ್ ಅಥವಾ “ಅರೇ” ಗಾಗಿ; ಕಾರ್ಯಗಳಿಗಾಗಿ -f; ಸ್ಕ್ರಿಪ್ಟ್ ಪರಿಸರದ ಹೊರಗೆ "ರಫ್ತು" ಮಾಡಬಹುದಾದ ಅಸ್ಥಿರಗಳಿಗಾಗಿ -x.

ಡಿಕ್ಲೇರ್ –i ಸಂಖ್ಯೆ = 12 ಡಿಕ್ಲೇರ್ –x ಪೈ = 3.14

ಸಹಾಯ: ನಿರ್ದಿಷ್ಟ ಆಜ್ಞೆಗೆ ಸಹಾಯವನ್ನು ತೋರಿಸುತ್ತದೆ.

ಉದ್ಯೋಗಗಳು: ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ತೋರಿಸುತ್ತದೆ.

# ವಿತ್-ಸಿ ನಾವು ಪ್ರತಿ ಪ್ರಕ್ರಿಯೆಯ ಪಿಡ್ (ಪ್ರಕ್ರಿಯೆ ಐಡಿ) ಯೊಂದಿಗೆ ಆಜ್ಞೆಗಳ ಹೆಸರನ್ನು ತೋರಿಸುತ್ತೇವೆ. ಉದ್ಯೋಗಗಳು -ಸಿಪಿ

ಲೆಟ್: ಅಂಕಗಣಿತದ ಅಭಿವ್ಯಕ್ತಿಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಿ

a = 11 ಅನ್ನು ಅನುಮತಿಸೋಣ a = a + 5 # ಅಂತಿಮವಾಗಿ ನಾವು 16 ಪ್ರತಿಧ್ವನಿ "11 + 5 = $ a" ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸುತ್ತೇವೆ.

ಸ್ಥಳೀಯ: ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳನ್ನು ರಚಿಸಿ, ದೋಷಗಳನ್ನು ತಪ್ಪಿಸಲು ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಕಾರ್ಯಗಳಲ್ಲಿ ಇದನ್ನು ಬಳಸಬೇಕು. ಡಿಕ್ಲೇರ್ ಆಜ್ಞೆಯಂತೆಯೇ ನೀವು ಅದೇ ಕಾರ್ಯಗಳನ್ನು ಬಳಸಬಹುದು.

ಸ್ಥಳೀಯ v1 = "ಇದು ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್"

ಲಾಗ್ out ಟ್: ಶೆಲ್ನಿಂದ ಸಂಪೂರ್ಣವಾಗಿ ಲಾಗ್ out ಟ್ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ; ನಾವು ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಶೆಲ್ ವಿಂಡೋಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಸಂದರ್ಭಗಳಲ್ಲಿ ಉಪಯುಕ್ತವಾಗಿದೆ, ಇದರಲ್ಲಿ ನಿರ್ಗಮನ ಆಜ್ಞೆಯು ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ವಿಂಡೋವನ್ನು ಮಾತ್ರ ಕೊನೆಗೊಳಿಸಲು ಅನುಮತಿಸುತ್ತದೆ.

printf: ಡೇಟಾವನ್ನು ಮುದ್ರಿಸಲು ಮತ್ತು ಅದನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಇದು ಅನೇಕ ಆಯ್ಕೆಗಳನ್ನು ಹೊಂದಿದೆ, ಆದ್ದರಿಂದ ನಾವು ಕೆಲವು ಉಲ್ಲೇಖಿಸುತ್ತೇವೆ.

#% f ತೇಲುವ ಸಂಖ್ಯೆಯಾಗಿ ಮುದ್ರಿಸುತ್ತದೆ, ಹೊಸ # ಸಾಲಿನ ಮುದ್ರಣಕ್ಕಾಗಿ n "% fn" 5 5.000000 # & d ದಶಮಾಂಶ ಸಂಖ್ಯೆಗಳನ್ನು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳಾಗಿ ರವಾನಿಸಲು ಅನುಮತಿಸುತ್ತದೆ printf "% d ಡಾಲರ್‌ಗಳಲ್ಲಿ% d ಆದೇಶಗಳಿವೆ. n" 20 500 20 ಮೌಲ್ಯದ 500 ಆದೇಶಗಳಿವೆ ಡಾಲರ್.

ಓದಿ: ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಇನ್‌ಪುಟ್‌ನಿಂದ ಒಂದು ಸಾಲನ್ನು ಓದಿ (ಉದಾಹರಣೆಗೆ ಕೀಬೋರ್ಡ್ ಮೂಲಕ ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡಲು ಬಳಸುವ ಮಾಡ್ಯೂಲ್). ನಾವು ಈ ರೀತಿಯ ಆಯ್ಕೆಗಳನ್ನು ರವಾನಿಸಬಹುದು: -t ಓದುವ ಮಿತಿ ಸಮಯವನ್ನು ನೀಡಲು; -a ಆದ್ದರಿಂದ ಪ್ರತಿ ಪದವನ್ನು ಅನಾಮೀ ಶ್ರೇಣಿಯಲ್ಲಿನ ಸ್ಥಾನಕ್ಕೆ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ; -ಡಿ ಸಾಲಿನ ಕೊನೆಯಲ್ಲಿ ಬರೆಯಬೇಕಾದ ಡಿಲಿಮಿಟರ್ ಅನ್ನು ಬಳಸಲು; ಇತರರ ಪೈಕಿ.

ಪ್ರತಿಧ್ವನಿ "ನಿಮ್ಮ ಹೆಸರನ್ನು ನಮೂದಿಸಿ ಮತ್ತು ENTER ಒತ್ತಿರಿ" # ವೇರಿಯಬಲ್ ಹೆಸರನ್ನು ಓದಿ ಹೆಸರು ಪ್ರತಿಧ್ವನಿ "ನಿಮ್ಮ ಹೆಸರು $ ಹೆಸರು"

ಪ್ರಕಾರ: ಆಜ್ಞೆಯನ್ನು ಮತ್ತು ಅದರ ನಡವಳಿಕೆಯನ್ನು ವಿವರಿಸುತ್ತದೆ. ಪ್ರತಿ ಆಜ್ಞೆಯ ಡೇಟಾ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ಇದು ಉಪಯುಕ್ತವಾಗಿರುತ್ತದೆ.

ಟೈಪ್ –ಎ '[' # ಟೈಪ್ ನಮಗೆ ಹೇಳುತ್ತದೆ [ಇದು ಶೆಲ್ ಬಿಲ್ಟಿನ್ ಆಜ್ಞೆಯಾಗಿದೆ [ಇದು ಶೆಲ್ ಬಿಲ್ಟಿನ್ ಆಗಿದೆ # -ಎ ನಮೂದಿಸಿದ ಹೆಸರಿನೊಂದಿಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ # ಹೊಂದಿರುವ ಡೈರೆಕ್ಟರಿಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ಅನುಮತಿಸುತ್ತದೆ. [is / usr / bin / [

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

# ನಮ್ಮ ಪ್ರಸ್ತುತ ಮಿತಿಗಳನ್ನು ನಾವು ನೋಡುತ್ತೇವೆ ulimit –a # -f ಬಳಕೆದಾರರಿಗೆ # 512000 Kb (500 #Mb) ಗಿಂತ ದೊಡ್ಡದಾದ ಫೈಲ್‌ಗಳನ್ನು ರಚಿಸಲು ಸಾಧ್ಯವಾಗದಂತೆ ಮಿತಿಗೊಳಿಸಲು ಅನುಮತಿಸುತ್ತದೆ - 512000 # -v ಪ್ರಕ್ರಿಯೆಯ ವರ್ಚುವಲ್ ಮೆಮೊರಿಯನ್ನು ಮಿತಿಗೊಳಿಸುತ್ತದೆ. ulimit –v 512000

ನಿರೀಕ್ಷಿಸಿ: ಮುಂದುವರಿಯಲು ಒಂದು ನಿರ್ದಿಷ್ಟ ಪ್ರಕ್ರಿಯೆ ಅಥವಾ ಕೆಲಸವನ್ನು ಕೈಗೊಳ್ಳಲು ಕಾಯಿರಿ.

# ಪಿಡ್ # 2585 ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೈಗೊಳ್ಳಲು ಸ್ಕ್ರಿಪ್ಟ್ ಕಾಯುತ್ತದೆ

ನಿರೀಕ್ಷಿಸಿ 2585

ನಾವು ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಿಗೆ ಸೇರಿಸಬಹುದಾದ ಇತರ ಉಪಯುಕ್ತ ಆಜ್ಞೆಗಳನ್ನು ಚಿಹ್ನೆಗಳಿಂದ ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ.

!!: ಕೊನೆಯ ಆಜ್ಞೆಯನ್ನು ಮತ್ತೆ ಚಲಾಯಿಸಿ

! wer: “wer” ಅಭಿವ್ಯಕ್ತಿಯೊಂದಿಗೆ ಪ್ರಾರಂಭವಾದ ಕೊನೆಯ ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ.

'==', '! =', '>', '<', '> =', ಮತ್ತು '<=': ಸಂಬಂಧಿತ ನಿರ್ವಾಹಕರು.

|: ಅಥವಾ ಆಪರೇಟರ್ ಸಾಮಾನ್ಯವಾಗಿ ಎರಡು ನಿಯಮಿತ ಅಭಿವ್ಯಕ್ತಿಗಳಿಗೆ ಸೇರಲು ಬಳಸಲಾಗುತ್ತದೆ.

: ಎಸ್ಕೇಪ್ ಆಜ್ಞೆಯು ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ: ಧ್ವನಿ ಎಚ್ಚರಿಕೆಗಾಗಿ a, ಹೊಸ ಲೈನ್‌ಗಾಗಿ n, ಬ್ಯಾಕ್‌ಸ್ಪೇಸ್‌ಗಾಗಿ b, ಇತ್ಯಾದಿ.