ಪ್ರೋಗ್1 | ಕಾರ್ಯಕ್ರಮ2 -ಪ್ರೋಗ್ರಾಂ prog1 ರ ಔಟ್‌ಪುಟ್ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಪ್ರೋಗ್ರಾಂನ ಇನ್‌ಪುಟ್ ಸ್ಟ್ರೀಮ್‌ಗೆ ವರ್ಗಾಯಿಸಿ ಕಾರ್ಯಕ್ರಮ2.

n> ಫೈಲ್ ಕಡತ.

n >> ಫೈಲ್ - ಫೈಲ್‌ಗೆ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ n ನೊಂದಿಗೆ ಪ್ರಮಾಣಿತ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಮರುನಿರ್ದೇಶಿಸಿ ಕಡತ ಫೈಲ್‌ನ ಅಂತ್ಯಕ್ಕೆ ಸೇರಿಸುವುದರೊಂದಿಗೆ.

n>&m - ಹಿಡಿಕೆಗಳೊಂದಿಗೆ ಎಳೆಗಳನ್ನು ಸಂಯೋಜಿಸುವುದು ಎನ್ ಮತ್ತು ಮೀ .

$ prog1 >/dev/null 2>&1

/dev/null ಒಂದು ಹುಸಿ-ಸಾಧನವು ಅದರೊಳಗೆ ನಿರ್ದೇಶಿಸಿದ ಹರಿವನ್ನು ನಾಶಪಡಿಸುತ್ತದೆ.

ಒಂದು ಪ್ರೋಗ್ರಾಂನ ಔಟ್‌ಪುಟ್ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಇನ್ನೊಂದರ ಇನ್‌ಪುಟ್ ಸ್ಟ್ರೀಮ್‌ಗೆ ರವಾನಿಸುವುದನ್ನು ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ:

$ gzip -d archive.tar.gz | ಟಾರ್ -xf

ಇಲ್ಲಿಯೇ ಫೈಲ್ ಅನ್ನು ಅನ್ಜಿಪ್ ಮಾಡಲಾಗಿದೆ archive.tar.gz , ಎರಡು ಆರ್ಕೈವರ್‌ಗಳಿಂದ ಪ್ಯಾಕ್ ಮಾಡಲಾಗಿದೆ. ಉಪಯುಕ್ತತೆಯಿಂದ ಔಟ್ಪುಟ್ ಸ್ಟ್ರೀಮ್ ಜಿಜಿಪ್ ಉಪಯುಕ್ತತೆಗೆ ಇನ್ಪುಟ್ ಸ್ಟ್ರೀಮ್ಗೆ ರವಾನಿಸಲಾಗಿದೆ ಟಾರ್ . ಅಂತೆಯೇ, ಅದೇ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಇನ್ನೊಂದು ರೀತಿಯಲ್ಲಿ ಮಾಡಬಹುದು:

$ gzip -d archive.tar.gz

$ tar -xf archive.tar

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

ಪರೀಕ್ಷಾ ಸ್ಥಿತಿ

[ಷರತ್ತು]

ಬ್ರಾಕೆಟ್ ಮತ್ತು ಸ್ಥಿತಿಯ ನಡುವೆ ಅಂತರಗಳು ಇರಬೇಕು ಎಂದು ಗಮನಿಸಬೇಕು, ಇಲ್ಲದಿದ್ದರೆ ಶೆಲ್ "[" ಅನ್ನು ಆಜ್ಞೆಯಂತೆ ಗುರುತಿಸುವುದಿಲ್ಲ ಪರೀಕ್ಷೆ . ಯಶಸ್ವಿಯಾಗಿ ಪೂರ್ಣಗೊಂಡ ಮೇಲೆ ಪರೀಕ್ಷೆ ಹಿಂದಿರುಗಿಸುತ್ತದೆ "0" .

ಫೈಲ್‌ಗಳನ್ನು ಪರಿಶೀಲಿಸಲು ಷರತ್ತುಗಳು:

-f ಫೈಲ್ಫೈಲ್ "ಫೈಲ್" ಸಾಮಾನ್ಯ ಫೈಲ್ ಆಗಿದೆ.

-ಡಿ ಫೈಲ್ ಫೈಲ್" ಕಡತ" ಒಂದು ಡೈರೆಕ್ಟರಿ ಆಗಿದೆ.
-ಸಿ ಫೈಲ್ ಫೈಲ್ "ಫೈಲ್" ವಿಶೇಷ ಫೈಲ್ ಆಗಿದೆ.
-ಆರ್ ಫೈಲ್ ಫೈಲ್ "ಫೈಲ್" ಅನುಮತಿ ಓದಿದೆ.

-w ಫೈಲ್ ಫೈಲ್ "ಫೈಲ್" ಬರೆಯಲು ಅನುಮತಿಯನ್ನು ಹೊಂದಿದೆ.

-x ಫೈಲ್ ಫೈಲ್ "ಫೈಲ್" ನಿರ್ವಹಿಸಲು ಅನುಮತಿಯನ್ನು ಹೊಂದಿದೆ.

-s ಫೈಲ್ ಫೈಲ್ "ಫೈಲ್" ಖಾಲಿ ಇಲ್ಲ.

ತಂತಿಗಳನ್ನು ಪರಿಶೀಲಿಸಲು ಷರತ್ತುಗಳು:

ಸ್ಟ್ರಿಂಗ್1=ಸ್ಟ್ರಿಂಗ್2 ತಂತಿಗಳು ಸ್ಟ್ರಿಂಗ್ 1 ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ 2 ಹೊಂದಾಣಿಕೆ.

ಸ್ಟ್ರಿಂಗ್1!=ಸ್ಟ್ರಿಂಗ್2 ತಂತಿಗಳು ಸ್ಟ್ರಿಂಗ್ 1 ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ 2 ಹೊಂದಿಕೆಯಾಗುವುದಿಲ್ಲ.

-ಎನ್ ಸ್ಟ್ರಿಂಗ್ 1 ಸಾಲು ಸ್ಟ್ರಿಂಗ್ 1 ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ.

-z ಸ್ಟ್ರಿಂಗ್ 1 ಸಾಲು ಸ್ಟ್ರಿಂಗ್ 1 ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ.

ಪೂರ್ಣಾಂಕಗಳೊಂದಿಗೆ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಷರತ್ತುಗಳು:

x -eq y x ಯು ಸಮನಾಗಿರುತ್ತದೆ

x -ne ವೈ x y ಗೆ ಸಮಾನವಾಗಿಲ್ಲ

x -gt y x y ಗಿಂತ ದೊಡ್ಡದಾಗಿದೆ

x -ge ವೈ x y ಗಿಂತ ದೊಡ್ಡದು ಅಥವಾ ಸಮನಾಗಿರುತ್ತದೆ

x -lt ವೈ x y ಗಿಂತ ಕಡಿಮೆ

x -le y x y ಗಿಂತ ಕಡಿಮೆ ಅಥವಾ ಸಮಾನವಾಗಿರುತ್ತದೆ

ಈ ಸಂದರ್ಭದಲ್ಲಿ ಆಜ್ಞೆ ಪರೀಕ್ಷೆ ತಂತಿಗಳನ್ನು ನಿಖರವಾಗಿ ಪೂರ್ಣಾಂಕಗಳಂತೆ ಪರಿಗಣಿಸುತ್ತದೆ. ಶೂನ್ಯ ಮೌಲ್ಯಖಾಲಿ ಸ್ಟ್ರಿಂಗ್ ಸಹ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ.

ತಾರ್ಕಿಕ ಕಾರ್ಯಾಚರಣೆಗಳುಸಂದರ್ಭದಲ್ಲಿ ಪರೀಕ್ಷೆ

! (ಅಲ್ಲ) ತಾರ್ಕಿಕ "ಅಲ್ಲ"

-o (ಅಥವಾ) ತಾರ್ಕಿಕ "OR"

-ಎ (ಮತ್ತು) ತಾರ್ಕಿಕ "ಮತ್ತು"

ಷರತ್ತುಬದ್ಧ ಆಪರೇಟರ್ "ಒಂದು ವೇಳೆ"

ಸಾಮಾನ್ಯ ನೋಟಬಳಸಿ ಷರತ್ತುಬದ್ಧ ಆಪರೇಟರ್ಈ ಕೆಳಗಿನಂತೆ ಪ್ರತಿನಿಧಿಸಿದರೆ:

ಒಂದು ವೇಳೆ<условие>

ನಂತರ<список команд>

[ಎಲಿಫ್<условие>

ನಂತರ<список> ]

ಚೌಕ ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿನ ಅಭಿವ್ಯಕ್ತಿಗಳು ಐಚ್ಛಿಕವಾಗಿರುತ್ತವೆ. ಆ. ಷರತ್ತುಬದ್ಧ ಆಪರೇಟರ್ನ ಅತ್ಯಂತ ಸಾಮಾನ್ಯವಾದ "ಕತ್ತರಿಸಿದ" ಮಾರ್ಪಾಡುಗಳನ್ನು ನಾವು ಊಹಿಸಬಹುದು:

ಒಂದು ವೇಳೆ<условие>

ನಂತರ<список команд>

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ವೇಳೆ <условие> ಪೂರ್ಣಗೊಂಡಿತು (ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ ಕೋಡ್ 0) ನಂತರ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ <список команд>. ಇಲ್ಲದಿದ್ದರೆ <список команд> ಬಿಟ್ಟುಬಿಟ್ಟರು.

ಆಯ್ಕೆ ಆಪರೇಟರ್ ಪ್ರಕರಣ

ಸಾಮಾನ್ಯವಾಗಿ, ಆಪರೇಟರ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಆಗಿದೆ ಪ್ರಕರಣ ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

ಪ್ರಕರಣ<строка>ಒಳಗೆ

ಟೆಂಪ್ಲೇಟ್ 1)

........

ಟೆಂಪ್ಲೇಟ್2)

........

........

ಅರ್ಥ <строка> ಟೆಂಪ್ಲೆಟ್ಗಳೊಂದಿಗೆ ಹೋಲಿಸಿದರೆ, ಕ್ರಮವಾಗಿ. ಹೊಂದಾಣಿಕೆ ಕಂಡುಬಂದರೆ, ಅನುಗುಣವಾದ ವಿಭಾಗದಲ್ಲಿನ ಆಜ್ಞೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಟೆಂಪ್ಲೆಟ್ಗಳು ಮುಖವಾಡಗಳ ಬಳಕೆಯನ್ನು ಅನುಮತಿಸುತ್ತವೆ ಎಂದು ಗಮನಿಸಬೇಕು. ಯಾವುದೇ ಹೊಂದಾಣಿಕೆ ಕಂಡುಬಂದಿಲ್ಲದಿದ್ದರೆ, "*" ಮಾದರಿಯೊಂದಿಗೆ ವಿಭಾಗದಿಂದ ಆಜ್ಞೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ (ಇದಕ್ಕೆ ಹೋಲುತ್ತದೆ ಪೂರ್ವನಿಯೋಜಿತ ಆಯ್ಕೆಗಾರ ಸ್ವಿಚ್ ವಿ ಜೊತೆಗೆ ).

ಉದಾಹರಣೆಯಾಗಿ, ಪ್ರಾರಂಭಿಕ ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಒಂದು ತುಣುಕು ಇಲ್ಲಿದೆ BSD UNIX . ಅಸ್ಥಿರಗಳು ಇಲ್ಲಿವೆ (inetd_enable ಮತ್ತು inetd_flags) ಇನ್ನೊಂದು ಕಡತದಿಂದ ಪಡೆಯಲಾಗಿದೆ ( rc.conf).

. /etc/rc.conf

ಸಂದರ್ಭದಲ್ಲಿ ($inetd_enable) ರಲ್ಲಿ

)

[-x /usr/sbin/inetd] ವೇಳೆ; ನಂತರ

/usr/sbin/inetd $inetd_flags

fi

;;

ಇಸಾಕ್

ಎಣಿಕೆಯೊಂದಿಗೆ ಲೂಪ್ ಆಪರೇಟರ್ ಫಾರ್

ಆಪರೇಟರ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಫಾರ್

ಫಾರ್<имя>

<список команд>

ಚದರ ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿ ಹೈಲೈಟ್ ಮಾಡಲಾದ ತುಣುಕು ಕಾಣೆಯಾಗಿರಬಹುದು. ಆಪರೇಟರ್ ಫಾರ್ ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಯಲ್ಲಿ ಪದಗಳಿರುವಷ್ಟು ಬಾರಿ ಲೂಪ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ವೇರಿಯಬಲ್ <имя> ಪಟ್ಟಿಯಿಂದ ಪದಗಳ ಅರ್ಥಗಳನ್ನು ಅನುಕ್ರಮವಾಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಇತರ ಆಜ್ಞೆಗಳ ಔಟ್ಪುಟ್ನಿಂದ ಪಟ್ಟಿಯನ್ನು ಸ್ವತಃ ರಚಿಸಬಹುದು. ಪಟ್ಟಿ ಕಾಣೆಯಾಗಿದ್ದರೆ, ನಂತರ <имя> ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಸ್ಥಾನಿಕ ನಿಯತಾಂಕಗಳಾಗಿ ರವಾನಿಸಲಾದ ಮೌಲ್ಯಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ.

ನಿಜವಾದ ಸ್ಥಿತಿಯೊಂದಿಗೆ ಲೂಪ್ ಹೇಳಿಕೆ ಸಮಯದಲ್ಲಿ

ಆಪರೇಟರ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಸಮಯದಲ್ಲಿ ಸಾಮಾನ್ಯವಾಗಿ ಇದು ಹೊಂದಿದೆ ಕೆಳಗಿನ ರಚನೆ:

ಸಮಯದಲ್ಲಿ<условие>

<список команд>

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

ಸುಳ್ಳು ಸ್ಥಿತಿಯೊಂದಿಗೆ ಲೂಪ್ ಹೇಳಿಕೆ ತನಕ

ಆಪರೇಟರ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ತನಕ ಸಾಮಾನ್ಯವಾಗಿ ಇದು ಈ ಕೆಳಗಿನ ರಚನೆಯನ್ನು ಹೊಂದಿದೆ:

ತನಕ<условие>

<список команд>

ಷರತ್ತು ತಪ್ಪಾಗಿರುವವರೆಗೆ ಆಜ್ಞೆಗಳ ಪಟ್ಟಿಯನ್ನು ಲೂಪ್‌ನಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ನೀವು ಮೊದಲ ಬಾರಿಗೆ ಲೂಪ್ ಅನ್ನು ನಮೂದಿಸಿದಾಗ, ಸ್ಥಿತಿಯು ನಿಜವಾಗಿರಬಾರದು. ಪ್ರತಿಯೊಂದರ ನಂತರ ಲೂಪ್ ಸ್ಥಿತಿಯನ್ನು ಸುಳ್ಳುಗಾಗಿ ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ ಎಂದು ಗಮನಿಸಬೇಕು, incl. ಮತ್ತು ಲೂಪ್‌ನಲ್ಲಿ ಮೊದಲ ಕಾರ್ಯಗತಗೊಳಿಸಿದ ಆಜ್ಞೆ.

ಮೂಲ ಆಜ್ಞೆಗಳು UNIX OSಫೈಲ್ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು

1. ತಂಡ pwd.

ವಾಕ್ಯ ರಚನೆ: pwd .

ವಿವರಣೆ: ಆಜ್ಞೆಯು ಚಾಲನೆಯಲ್ಲಿರುವ ಶೆಲ್‌ಗಾಗಿ ಪ್ರಸ್ತುತ ಡೈರೆಕ್ಟರಿಯ ಹೆಸರನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

ಕಾರ್ಯ 1.

ನಿಮ್ಮ ಹೋಮ್ ಡೈರೆಕ್ಟರಿಯನ್ನು ನಿರ್ಧರಿಸಲು pwd ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ.

ವರದಿಯಲ್ಲಿ ತಂಡ ಮತ್ತು ಅದರ ಕೆಲಸದ ಫಲಿತಾಂಶವನ್ನು ಪ್ರತಿಬಿಂಬಿಸಿ.

2. ತಂಡ ಮನುಷ್ಯ.

ವಾಕ್ಯ ರಚನೆ: ಮನುಷ್ಯ ಹೆಸರು.

ಹೆಸರು ನಾವು ಆಸಕ್ತಿ ಹೊಂದಿರುವ ಆಜ್ಞೆ ಅಥವಾ ಉಪಯುಕ್ತತೆಯ ಹೆಸರಾಗಿದೆ, ಸಿಸ್ಟಮ್ ಕರೆ, ಲೈಬ್ರರಿ ಕಾರ್ಯ, ಫೈಲ್.

ವಿವರಣೆ : ಯುನಿಕ್ಸ್ ಮ್ಯಾನುಯಲ್ - ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಕೈಪಿಡಿ UNIX. ಅಲ್ಲಿಂದ ಮಾಹಿತಿ ಲಭ್ಯವಿದೆ ಸಂವಾದಾತ್ಮಕ ಮೋಡ್ಉಪಯುಕ್ತತೆಯನ್ನು ಬಳಸುವುದು ಮನುಷ್ಯ .

ಕಾರ್ಯ 2.

pwd ಆಜ್ಞೆಯ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಹುಡುಕಲು ಮ್ಯಾನ್ ಉಪಯುಕ್ತತೆಯನ್ನು ಬಳಸಿ.

ವರದಿಯಲ್ಲಿ ತಂಡದ ಬಗ್ಗೆ ಸಂಕ್ಷಿಪ್ತ ಮಾಹಿತಿಯನ್ನು ಬರೆಯಿರಿ (ರಷ್ಯನ್ ಭಾಷೆಯಲ್ಲಿ).

3. ತಂಡ ಸಿಡಿ.

ವಾಕ್ಯ ರಚನೆ: ಸಿಡಿ ಡೈರೆಕ್ಟರಿ_ಹೆಸರು.

ವಿವರಣೆ: ಇದು ಪ್ರಸ್ತುತ ಡೈರೆಕ್ಟರಿಯನ್ನು ಬದಲಾಯಿಸುವ ಆಜ್ಞೆಯಾಗಿದೆ. ಡೈರೆಕ್ಟರಿ ನೇಮ್ ನೀವು ಪ್ರಸ್ತುತ ಮಾಡಲು ಬಯಸುವ ಡೈರೆಕ್ಟರಿಯ ಪೂರ್ಣ ಅಥವಾ ಸಂಬಂಧಿತ ಹೆಸರು.

ಸಿಡಿನಿಯತಾಂಕಗಳಿಲ್ಲದೆ ಪ್ರಸ್ತುತವು ನಿಮ್ಮ ಹೋಮ್ ಡೈರೆಕ್ಟರಿಯನ್ನು ಮಾಡುತ್ತದೆ.

ಕಾರ್ಯ 3.

ಪ್ರಸ್ತುತ ಡೈರೆಕ್ಟರಿಯನ್ನು ಒಂದು ಹಂತವನ್ನು ಹೆಚ್ಚಿಸಿ. ಅದನ್ನು ಪರಿಶೀಲಿಸಿ, ನಂತರ ನಿಮ್ಮ ಹೋಮ್ ಡೈರೆಕ್ಟರಿಗೆ ಹಿಂತಿರುಗಿ. ಡೈರೆಕ್ಟರಿ ಬದಲಾವಣೆಯನ್ನು ಪರಿಶೀಲಿಸಿ.

ಪೂರ್ಣಗೊಂಡ ಆಜ್ಞೆಗಳ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯು ವರದಿಯಲ್ಲಿ ಪ್ರತಿಫಲಿಸುತ್ತದೆ.

4. ತಂಡ ls.

ವಾಕ್ಯ ರಚನೆ: ls ಡೈರೆಕ್ಟರಿ_ಹೆಸರು

ವಿವರಣೆ: ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಡೈರೆಕ್ಟರಿಯ ವಿಷಯಗಳನ್ನು ವೀಕ್ಷಿಸಲು ಆಜ್ಞೆ.

lsನಿಯತಾಂಕಗಳಿಲ್ಲದೆ, ಪ್ರಸ್ತುತ ಡೈರೆಕ್ಟರಿಯಿಂದ ಫೈಲ್‌ಗಳ ಪಟ್ಟಿಯನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.

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

ಆ. ls - ಡೈರೆಕ್ಟರಿ_ಹೆಸರು

ಫೈಲ್ ಅನುಮತಿಗಳು

ಪ್ರತಿ ಫೈಲ್‌ನೊಂದಿಗೆ UNIX OS ಫೈಲ್‌ಗೆ "ಅನುಮತಿಗಳು" ಎಂಬ 12-ಬಿಟ್ ಪದದೊಂದಿಗೆ ಸಂಯೋಜಿಸಲಾಗಿದೆ.

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

ನಿರ್ದಿಷ್ಟ ಫೈಲ್ಗೆ ಪ್ರವೇಶ ಹಕ್ಕುಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು, ನೀವು ಆಜ್ಞೆಯನ್ನು ಬಳಸಬಹುದು

, ಉದಾಹರಣೆಗೆ:

> ls -l /bin/cat

ಒಂದು ಸಾಲಿನ ಆರಂಭದಲ್ಲಿ ಇರುವ ಅಕ್ಷರಗಳ ಗುಂಪು -rwxr-xr-x ಫೈಲ್ ಪ್ರಕಾರವನ್ನು ತೋರಿಸುತ್ತದೆ (ಮೊದಲ ಅಕ್ಷರ; ಮೈನಸ್ ಚಿಹ್ನೆ ಎಂದರೆ ನಾವು ಸಾಮಾನ್ಯ ಫೈಲ್, ಅಕ್ಷರದೊಂದಿಗೆ ವ್ಯವಹರಿಸುತ್ತಿದ್ದೇವೆ ಡಿ ಮಾಲೀಕರಿಗೆ ಕ್ರಮವಾಗಿ ಡೈರೆಕ್ಟರಿ, ಇತ್ಯಾದಿ) ಮತ್ತು ಪ್ರವೇಶ ಹಕ್ಕುಗಳನ್ನು ಅರ್ಥೈಸುತ್ತದೆ (ಇನ್ ಈ ಸಂದರ್ಭದಲ್ಲಿ rwx , ಅಂದರೆ ಓದಲು, ಬರೆಯಲು ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸಿ), ಗುಂಪು ಮತ್ತು ಎಲ್ಲರೂ (ಈ ಸಂದರ್ಭದಲ್ಲಿ r-x , ಅಂದರೆ ಬರೆಯುವ ಹಕ್ಕುಗಳಿಲ್ಲ). ಆದ್ದರಿಂದ ಫೈಲ್ /ಬಿನ್/ಬೆಕ್ಕು ಯಾವುದೇ ಬಳಕೆದಾರರಿಂದ ಓದಬಹುದು ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು, ಆದರೆ ಬಳಕೆದಾರರು ಮಾತ್ರ ಅದನ್ನು ಮಾರ್ಪಡಿಸಬಹುದು ಮೂಲ (ಅಂದರೆ ನಿರ್ವಾಹಕರು).

ನೀವು ಫೈಲ್ ಅನುಮತಿಗಳ ಪದವನ್ನು ಹೀಗೆ ಬರೆಯಬಹುದು ಅಷ್ಟಮ ಸಂಖ್ಯೆ(3 ಅಕ್ಷರಗಳು - ಆಕ್ಟಲ್ ಡಿಜಿಟ್), ಮೂರು-ಅಂಕಿಯ (ಮಾಲೀಕರು, ಗುಂಪು, ಇತರ ಬಳಕೆದಾರರು) ಈ ಮೂರು-ಅಂಕಿಯ ಆಕ್ಟಲ್ ಸಂಖ್ಯೆಯ ಪ್ರತಿ ಅಕ್ಷರವು ಹಕ್ಕುಗಳ ಮೊತ್ತವಾಗಿ ರೂಪುಗೊಳ್ಳುತ್ತದೆ: 4 - ಓದುವ ಹಕ್ಕುಗಳು, 2 - ಹಕ್ಕುಗಳನ್ನು ಬರೆಯುವುದು, 1 - ಬಳಕೆ ( ಬೈನರಿ ಟ್ರೈಡ್‌ನಿಂದ) : (111) 2 =2 0 +2 1 +2 2 =(1+2+4) 10 .

ಉದಾಹರಣೆಗೆ, 7 = 1 + 2 + 4 Þ ಬಲ rwx

4 2 1

6 = 0 + 2+ 4 Þ ಬಲ rw- -

4 2 0

ಮೂರು-ಅಂಕಿಯ ಸಂಖ್ಯೆಯಲ್ಲಿ, ಹಕ್ಕುಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿ: 744 ಎಲ್ಲಾ ಹಕ್ಕುಗಳನ್ನು ಮಾಲೀಕರಿಗೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ, ಗುಂಪಿಗೆ ಓದಲು ಮಾತ್ರ ಮತ್ತು ಇತರ ಬಳಕೆದಾರರಿಗೆ ಓದಲು ಮಾತ್ರ.

ಫೈಲ್ ಅನುಮತಿಗಳನ್ನು ಬಳಸಲು, ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ chmod , ಇದು ಹೊಸ ಅನುಮತಿಗಳನ್ನು ಆಕ್ಟಲ್ ಸಂಖ್ಯೆಯಂತೆ ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ:

$ chmod 744 filel.c.

ಕಾರ್ಯ 4.

ಎ) ಸ್ವೀಕರಿಸಲು ಸಂಪೂರ್ಣ ಮಾಹಿತಿ ls ಆಜ್ಞೆಯ ಬಗ್ಗೆ, ಮ್ಯಾನ್ ಉಪಯುಕ್ತತೆಯನ್ನು ಬಳಸಿ. ಕಮಾಂಡ್ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಕೆಲವು ಪಠ್ಯ ಫೈಲ್‌ಗೆ ಮರುನಿರ್ದೇಶಿಸಿ.

ಬಿ) ಪ್ರಸ್ತುತ ಡೈರೆಕ್ಟರಿಯ ಸಂಪೂರ್ಣ ವಿಷಯಗಳನ್ನು ನೋಡಿ ಮತ್ತು ಈ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಪಠ್ಯ ಫೈಲ್‌ಗೆ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ.

ಸಿ) ಆಜ್ಞೆಯನ್ನು ಬಳಸುವುದು ls -l<имя_файла> ಹಂತ 4b ನಲ್ಲಿ ನೀವು ಕೆಲಸ ಮಾಡಿದ ಪಠ್ಯ ಫೈಲ್‌ಗೆ ಪ್ರವೇಶ ಹಕ್ಕುಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಮುದ್ರಿಸಿ, ನಂತರ ಈ ಮಾಹಿತಿಯನ್ನು ಅದೇ ಪಠ್ಯ ಫೈಲ್‌ಗೆ ಮರುನಿರ್ದೇಶಿಸಿ. ನಿಮ್ಮ ತೀರ್ಮಾನವನ್ನು ವಿವರಿಸಿ.

5. ತಂಡ ಬೆಕ್ಕು.

I/O ಮರುನಿರ್ದೇಶನ.

ಪರದೆಯ ಮೇಲೆ ಸಣ್ಣ ಪಠ್ಯ ಫೈಲ್‌ನ ವಿಷಯಗಳನ್ನು ವೀಕ್ಷಿಸಲು, ನೀವು ಆಜ್ಞೆಯನ್ನು ಬಳಸಬಹುದು:

ಬೆಕ್ಕುಫೈಲ್ ಹೆಸರು

ಗಮನ!ಈ ರೀತಿಯಲ್ಲಿ ಡೈರೆಕ್ಟರಿ ಮತ್ತು ಬೈನರಿ ಫೈಲ್‌ಗಳ ವಿಷಯಗಳನ್ನು ವೀಕ್ಷಿಸಲು ಪ್ರಯತ್ನಿಸಬೇಡಿ.

ದೊಡ್ಡ ಪರೀಕ್ಷಾ ಫೈಲ್ ಅನ್ನು ತಂಡವು ಸುಲಭವಾಗಿ ವೀಕ್ಷಿಸಬಹುದು ಹೆಚ್ಚು (ಬಳಕೆಯ ವಿವರಣೆಗಾಗಿ, ನೋಡಿ UNIX ಕೈಪಿಡಿ ) ಆಜ್ಞೆಯು ಇಲ್ಲಿ ಏಕೆ ಅನಾನುಕೂಲವಾಗಿದೆ? ಬೆಕ್ಕು ?

ತಂಡದಲ್ಲಿ ಬೆಕ್ಕು ನೀವು ಬಹು ಫೈಲ್ ಹೆಸರುಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು:

ಬೆಕ್ಕು ಫೈಲ್1 ಫೈಲ್ 2 ... ಫೈಲ್ ಎನ್

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಸತತವಾಗಿ ಎಲ್ಲಾ ಫೈಲ್‌ಗಳ ವಿಷಯಗಳನ್ನು ಪರದೆಯ ಮೇಲೆ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.

ನೀವು ಫೈಲ್‌ಗೆ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಮರುನಿರ್ದೇಶಿಸಬಹುದು:

cat file 1 file 2 > results_file

ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಔಟ್‌ಪುಟ್ (ಸ್ಕ್ರೀನ್) ನಿಂದ ಫೈಲ್‌ಗೆ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಮರುನಿರ್ದೇಶಿಸುವುದು ಎಲ್ಲಾ ಆಜ್ಞೆಗಳಿಗೆ ಪ್ರಮಾಣಿತವಾಗಿದೆ. ನೀವು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಇನ್‌ಪುಟ್ ಅನ್ನು ಮರುನಿರ್ದೇಶಿಸಬಹುದು (ಕೀಬೋರ್ಡ್‌ನಿಂದ), ಉದಾಹರಣೆಗೆ, " ಚಿಹ್ನೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಫೈಲ್‌ನಿಂದ ಪ್ರೋಗ್ರಾಂಗಾಗಿ ಡೇಟಾವನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು<”.

ಬೆಕ್ಕು > new_file - ನೀವು ಕೀಬೋರ್ಡ್‌ನಿಂದ ನಮೂದಿಸಿದ ವಿಷಯದೊಂದಿಗೆ ಹೊಸ ಪಠ್ಯ ಫೈಲ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.

ಡೇಟಾ ಎಂಟ್ರಿ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸ್ಥಗಿತಗೊಳಿಸಿ -

ಕಾರ್ಯ 5.

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

6. ಫೈಲ್ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಸರಳವಾದ ಆಜ್ಞೆಗಳು : cp, rm, mkdir, mv

ಹೊಸ ಡೈರೆಕ್ಟರಿಯನ್ನು ರಚಿಸಲು ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ:

mkdirಡೈರೆಕ್ಟರಿ_ಹೆಸರು

ಒಂದು ಫೈಲ್‌ನ ವಿಷಯಗಳನ್ನು ಇನ್ನೊಂದಕ್ಕೆ ನಕಲಿಸಲು, ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ:

cp file_source_file_destination.

ತಂಡ

cp ಫೈಲ್ 1 ಫೈಲ್ 2…. ಫೈಲ್ N ಗಮ್ಯಸ್ಥಾನ ಡೈರೆಕ್ಟರಿ

ಫೈಲ್ ಅಥವಾ ಫೈಲ್‌ಗಳನ್ನು ಈಗಾಗಲೇ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಡೈರೆಕ್ಟರಿಗೆ ತಮ್ಮ ಹೆಸರಿನಲ್ಲಿ destination_directory ಹೆಸರಿನೊಂದಿಗೆ ನಕಲಿಸಲು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ನಕಲಿಸಿದ ಫೈಲ್‌ಗಳ ಹೆಸರುಗಳ ಬದಲಿಗೆ, ನೀವು ಅವುಗಳ ಟೆಂಪ್ಲೇಟ್‌ಗಳನ್ನು ಬಳಸಬಹುದು. ಮೆಟಾಕ್ಯಾರೆಕ್ಟರ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಮಾದರಿಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆ:

* - ಖಾಲಿ ಅಕ್ಷರಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ಎಲ್ಲಾ ಅಕ್ಷರಗಳ ಸಾಲುಗಳಿಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ.

ಎಲ್ಲಾ ಒಂದೇ ಪಾತ್ರಗಳು

[...] - ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿ ಸುತ್ತುವರಿದ ಯಾವುದೇ ಅಕ್ಷರಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ. ಮೈನಸ್ ಚಿಹ್ನೆಯಿಂದ ಬೇರ್ಪಡಿಸಲಾದ ಜೋಡಿ ಅಕ್ಷರಗಳು ಅಕ್ಷರಗಳ ಶ್ರೇಣಿಯನ್ನು ಸೂಚಿಸುತ್ತವೆ.

ತಂಡ

cp-r dir_source dir_destination

ಒಂದು ಡೈರೆಕ್ಟರಿಯನ್ನು (source_dir) ಹೊಸ ಡೈರೆಕ್ಟರಿಗೆ (destination_dir) ಪುನರಾವರ್ತಿತವಾಗಿ ನಕಲು ಮಾಡಲು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

ನಕಲು ಆಜ್ಞೆಗಳಲ್ಲಿನ ಹೆಸರುಗಳ ಬದಲಿಗೆ, ಅವುಗಳ ಟೆಂಪ್ಲೇಟ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.

ತಂಡ

rm ಫೈಲ್ 1 ಫೈಲ್ 2…. ಫೈಲ್ ಎನ್

ಪ್ರಸ್ತುತ ಡೈರೆಕ್ಟರಿಯಿಂದ 1 ಅಥವಾ ಹೆಚ್ಚಿನ ನಿಯಮಿತ ಫೈಲ್‌ಗಳನ್ನು ಅಳಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಹೆಸರುಗಳ ಬದಲಿಗೆ ವೈಲ್ಡ್‌ಕಾರ್ಡ್‌ಗಳನ್ನು ಬಳಸಬಹುದು. ಆಜ್ಞೆಯಲ್ಲಿ ನೀವು ಒಂದು ಅಥವಾ ಹೆಚ್ಚಿನ ಡೈರೆಕ್ಟರಿಗಳನ್ನು ಅವುಗಳ ವಿಷಯಗಳೊಂದಿಗೆ (ಪುನರಾವರ್ತಿತ ಅಳಿಸುವಿಕೆ) ಅಳಿಸಲು ಬಯಸಿದರೆ rm ಕೀಲಿಯನ್ನು ಬಳಸಿ -ಆರ್

Rm-r dir 1 dir 2

ಆಜ್ಞೆಯನ್ನು ಮರುಹೆಸರಿಸಿ:

mv source_name destination_name

source_name ಹೆಸರಿನ ಫೈಲ್ ಅನ್ನು destination_name ಹೆಸರಿನ ಫೈಲ್‌ಗೆ ಮರುಹೆಸರಿಸಲಾಗಿದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೊದಲು, destination_name ಹೆಸರಿನ ಫೈಲ್ ಅಸ್ತಿತ್ವದಲ್ಲಿರಬಾರದು.

ಕಾರ್ಯ 6.

ನಿಮ್ಮ ಹೋಮ್ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಹೊಸ ಡೈರೆಕ್ಟರಿಯನ್ನು ರಚಿಸಿ. ಎರಡು ಸಾಲುಗಳ ವಿಷಯದೊಂದಿಗೆ ಸಣ್ಣ ಪರೀಕ್ಷಾ ಫೈಲ್ ಅನ್ನು ಆಯೋಜಿಸಿ:

“ನಾನು UNIX OS ನಲ್ಲಿ ಹೇಗೆ ಕೆಲಸ ಮಾಡಬೇಕೆಂದು ಕಲಿಯುತ್ತಿದ್ದೇನೆ

ನಾನು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಆಯೋಜಿಸುತ್ತೇನೆ. ”

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

ಕಾರ್ಯ 7.

1) ಮೂಲ UNIX OS ಆಜ್ಞೆಗಳೊಂದಿಗೆ ಸಂವಾದಾತ್ಮಕವಾಗಿ ಕೆಲಸ ಮಾಡುವುದನ್ನು ನೀವು ಕರಗತ ಮಾಡಿಕೊಂಡ ನಂತರ, ಅನುಕ್ರಮವಾದ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಗೆ ಅನುಗುಣವಾದ ಸ್ಕ್ರಿಪ್ಟ್‌ನೊಂದಿಗೆ ಸ್ಕ್ರಿಪ್ಟ್ ರಚಿಸಲು Kwriter ಸಂಪಾದಕವನ್ನು ಬಳಸಿ:

ಕಾರ್ಯ 3,

ಕಾರ್ಯ 4B, 4B,

ಕಾರ್ಯ 5,

ಕಾರ್ಯ 6.

ಕಾರ್ಯ 6 ರಲ್ಲಿ, ಫೈಲ್ ನಕಲು ಯಶಸ್ವಿಯಾಗಿದೆಯೇ, ಪ್ರದರ್ಶಿಸುತ್ತದೆಯೇ ಎಂದು ಪ್ರೋಗ್ರಾಮಿಕ್ ಆಗಿ ಪರಿಶೀಲಿಸಲು ಮರೆಯಬೇಡಿ ಪಠ್ಯ ಸಂದೇಶಗಳುಮತ್ತು ಅನುಗುಣವಾದ ಡೈರೆಕ್ಟರಿಗಳ ವಿಷಯಗಳು.

ಒಳಗೆ ಇರುವುದು ಅವಶ್ಯಕ ಬ್ಯಾಚ್ ಫೈಲ್ಕೀಬೋರ್ಡ್‌ನಿಂದ ಡೇಟಾ ಇನ್‌ಪುಟ್‌ಗಾಗಿ ವಿನಂತಿಗಳ ಸಮರ್ಥ ವಿತರಣೆಯನ್ನು ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಆಯೋಜಿಸಲಾಗಿದೆ: $ echo - n “ವಿನಂತಿ ಪಠ್ಯ”.

2) Myscript1 ಎಂಬ ಹೆಸರಿನೊಂದಿಗೆ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಉಳಿಸಿ, ಆಜ್ಞೆಯೊಂದಿಗೆ ಅದನ್ನು ಚಲಾಯಿಸಿ

sh Myscript1

ವಿನಂತಿಸಿದ ಡೇಟಾವನ್ನು ನಮೂದಿಸಿ ಮತ್ತು ಫಲಿತಾಂಶಗಳನ್ನು ಪರಿಶೀಲಿಸಿ.

3) ಪೂರ್ಣಗೊಂಡ ಪ್ರಯೋಗಾಲಯದ ಕೆಲಸದ ವರದಿಯನ್ನು ಕಂಪೈಲ್ ಮಾಡಿ, ಇದು ಸಂವಾದಾತ್ಮಕ ಮೋಡ್‌ನಲ್ಲಿ ಮತ್ತು ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಪಠ್ಯವನ್ನು (ಕಾಮೆಂಟ್‌ಗಳೊಂದಿಗೆ) ಮತ್ತು ಪರದೆಯ ಮೇಲೆ ಮತ್ತು ಫೈಲ್‌ಗಳಲ್ಲಿ ಪಡೆದ ಫಲಿತಾಂಶಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ನಿಮ್ಮ ಕೆಲಸವನ್ನು ಪ್ರತಿಬಿಂಬಿಸುತ್ತದೆ.

ಸಿಸ್ಟಮ್ ಕರೆಗಳು ಗೆಟುಯಿಡ್ ಮತ್ತು ಗೆಟ್ಪಿಡ್

ಕಾರ್ಯಗತಗೊಳಿಸಲು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿದ ಬಳಕೆದಾರರ ಗುರುತಿಸುವಿಕೆಯನ್ನು ಕಂಡುಹಿಡಿಯಿರಿ - ಯುಐಡಿ ಮತ್ತು ಅದು ಸೇರಿರುವ ಗುಂಪಿನ ID ,-ಜಿಐಡಿ ಸಿಸ್ಟಮ್ ಕರೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸಾಧ್ಯ getuid () ಮತ್ತು getpid () ಈ ಪ್ರೋಗ್ರಾಂ ಒಳಗೆ ಅವುಗಳನ್ನು ಅನ್ವಯಿಸುವ ಮೂಲಕ.

ಸಿಸ್ಟಮ್ ಕರೆ ಮೂಲಮಾದರಿಗಳು:

#ಸೇರಿಸು

#ಸೇರಿಸು

uid_t getuid(ಶೂನ್ಯ);

gid_t getgid(ಶೂನ್ಯ);

ಕಾರ್ಯ 8.

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

ವರದಿಯಲ್ಲಿ ಫಲಿತಾಂಶಗಳೊಂದಿಗೆ ಕಾರ್ಯಕ್ರಮವನ್ನು ಸೇರಿಸಿ.

ಭದ್ರತಾ ಪ್ರಶ್ನೆಗಳು

1. ಫೈಲ್‌ನ ಪರಿಕಲ್ಪನೆ UNIX OS . ಏನಾಯ್ತು ಹೋಮ್ ಡೈರೆಕ್ಟರಿ?

2. ಗ್ರೂಪಿಂಗ್ ಆಜ್ಞೆಗಳ ಅರ್ಥವೇನು? ಶೆಲ್ - ವ್ಯಾಖ್ಯಾನಕಾರ? ಬಳಕೆಯ ಉದಾಹರಣೆಗಳನ್ನು ಒದಗಿಸಿ.

3. I/O ಅನ್ನು ಹೇಗೆ ಮರುನಿರ್ದೇಶಿಸಲಾಗುತ್ತದೆ?

4. ಕಮಾಂಡ್ ಪೈಪ್‌ಲೈನ್ ಎಂದರೇನು? ಒಂದು ಉದಾಹರಣೆ ನೀಡಿ.

5. ಮೂಲಕ ಶೆಲ್ ಅಂಕಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಿ ಶೆಲ್ -ವೇರಿಯಬಲ್?

6. ಫೈಲ್ ಹೆಸರುಗಳನ್ನು ರಚಿಸುವ ನಿಯಮಗಳು ಯಾವುವು?

7. ಕಮಾಂಡ್ ಪರ್ಯಾಯವನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ?

8. ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹೇಗೆ ಅರ್ಥೈಸುವುದು cmd1&cmd2& ?

9. ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹೇಗೆ ಅರ್ಥೈಸುವುದು cmd1 && cmd2 & ?

10. ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹೇಗೆ ಅರ್ಥೈಸುವುದು cmd1 || cmd2& ?

11. ನಲ್ಲಿರುವಂತೆ UNIX ಫೈಲ್ ಅನುಮತಿಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆಯೇ? ನಿರ್ದಿಷ್ಟ ಫೈಲ್‌ಗಾಗಿ ಅವುಗಳನ್ನು ವೀಕ್ಷಿಸಲು ನೀವು ಯಾವ ಆಜ್ಞೆಯನ್ನು ಬಳಸಬಹುದು?

12. ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿದ ಬಳಕೆದಾರರ ಗುರುತಿಸುವಿಕೆಯನ್ನು ಮತ್ತು ಅವರ ಗುಂಪಿನ ಗುರುತಿಸುವಿಕೆಯನ್ನು ಹೇಗೆ ನಿರ್ಧರಿಸುವುದು?

ಪ್ರಯೋಗಾಲಯದ ಕೆಲಸ № 3.

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂನಲ್ಲಿನ ಪ್ರಕ್ರಿಯೆಗಳು UNIX.

ಕೆಲಸದ ಉದ್ದೇಶ

ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ರಚಿಸಲು ಕಲಿಯಿರಿ ಮತ್ತು ಭಾಷೆಯಲ್ಲಿನ ಪ್ರೋಗ್ರಾಂಗಳಲ್ಲಿ ಬಳಸುವ ಸಿಸ್ಟಮ್ ಕರೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರಕ್ರಿಯೆಗಳ ಬಳಕೆದಾರ ಸಂದರ್ಭವನ್ನು ಬದಲಾಯಿಸುವುದನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳಿ ಜೊತೆಗೆ, ವಿ UNIX OS.

1. ಪ್ರಕ್ರಿಯೆಗಳ ಸಂಘಟನೆಯನ್ನು ಅಧ್ಯಯನ ಮಾಡಿ UNIX : ಪ್ರಕ್ರಿಯೆಯ ಪರಿಕಲ್ಪನೆ, ಪ್ರಕ್ರಿಯೆಯ ಸಂದರ್ಭ, ಜೀವನ ಚಕ್ರಪ್ರಕ್ರಿಯೆ, ಪ್ರಕ್ರಿಯೆ ಗುರುತಿಸುವಿಕೆ, ಕ್ರಮಾನುಗತ ರಚನೆಪ್ರಕ್ರಿಯೆಗಳು. ಗೆ ಬರೆಯಿರಿ ಜೊತೆಗೆ ಮತ್ತು ಕಾರ್ಯ 1 ರ ಪ್ರಕಾರ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಡೀಬಗ್ ಮಾಡಿ.

2. ಪ್ರಕ್ರಿಯೆಯನ್ನು ರಚಿಸುವುದರೊಂದಿಗೆ ನೀವೇ ಪರಿಚಿತರಾಗಿರಿ UNIX , ಪ್ರಕ್ರಿಯೆಯ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯ ಸಂಘಟನೆಯೊಂದಿಗೆ. ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಬರೆಯಿರಿ ಮತ್ತು ಡೀಬಗ್ ಮಾಡಿ (ಭಾಷೆ ಜೊತೆಗೆ ) ಕಾರ್ಯ 2 ರ ಪ್ರಕಾರ, ಅದನ್ನು ವರದಿಯಲ್ಲಿ ಸೇರಿಸಿ.

3. ಕಾರ್ಯ ನಿಯತಾಂಕಗಳನ್ನು ಅನ್ವೇಷಿಸಿ ಮುಖ್ಯ() ಭಾಷೆಯಲ್ಲಿ ಜೊತೆಗೆ , ಪರಿಸರ ಅಸ್ಥಿರಮತ್ತು ವಾದಗಳು ಆಜ್ಞಾ ಸಾಲಿನ. ಒಂದು ಭಾಷೆಯಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ ಬರೆಯಿರಿ ಜೊತೆಗೆ ಕಾರ್ಯ 3 ಗೆ ಅನುಗುಣವಾಗಿ, ಡೀಬಗ್ ಮಾಡಿ ಮತ್ತು ಫಲಿತಾಂಶಗಳೊಂದಿಗೆ ವರದಿಯಲ್ಲಿ ಸೇರಿಸಿ.

4. ಸಿಸ್ಟಮ್ ಕರೆಯನ್ನು ಸಂಘಟಿಸಲು ಕಾರ್ಯಗಳ ಕುಟುಂಬವನ್ನು ಅನ್ವೇಷಿಸಿ ಎಕ್ಸಿಕ್ ().

5. ಭಾಷೆಯಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ ಬರೆಯಿರಿ ಜೊತೆಗೆ ಶಿಕ್ಷಕರು ನೀಡಿದ ಟಾಸ್ಕ್ 4 ರ ಆವೃತ್ತಿಗೆ ಅನುಗುಣವಾಗಿ, ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಡೀಬಗ್ ಮಾಡಿ ಮತ್ತು ಶಿಕ್ಷಕರಿಗೆ ಪಡೆದ ಫಲಿತಾಂಶಗಳನ್ನು ಪ್ರದರ್ಶಿಸಿ. ವರದಿಯಲ್ಲಿ ಫಲಿತಾಂಶಗಳೊಂದಿಗೆ ಕಾರ್ಯಕ್ರಮವನ್ನು ಸೇರಿಸಿ.

6. ಪರೀಕ್ಷಾ ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಿಸುವ ಮೂಲಕ ಶಿಕ್ಷಕರಿಗೆ ಕೆಲಸವನ್ನು ರಕ್ಷಿಸಿ.

ಆಜ್ಞಾ ಸಾಲಿನ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳ ಔಟ್‌ಪುಟ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ನೀವು ಈಗಾಗಲೇ ಎರಡು ವಿಧಾನಗಳೊಂದಿಗೆ ಪರಿಚಿತರಾಗಿರುವಿರಿ:

• ಪರದೆಯ ಮೇಲೆ ಔಟ್ಪುಟ್ ಡೇಟಾವನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತಿದೆ.
• ಫೈಲ್‌ಗೆ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಮರುನಿರ್ದೇಶಿಸಿ.

ಪ್ರಮಾಣಿತ ಫೈಲ್ ವಿವರಣೆಗಳು

ಪ್ರತಿ ಪ್ರಕ್ರಿಯೆಯು ಒಂಬತ್ತು ತೆರೆದ ಫೈಲ್ ಹ್ಯಾಂಡಲ್‌ಗಳನ್ನು ಹೊಂದಲು ಅನುಮತಿಸಲಾಗಿದೆ. ಬ್ಯಾಷ್ ಶೆಲ್ ID ಗಳು 0, 1 ಮತ್ತು 2 ನೊಂದಿಗೆ ಮೊದಲ ಮೂರು ಹ್ಯಾಂಡಲ್‌ಗಳನ್ನು ಕಾಯ್ದಿರಿಸಲಾಗಿದೆ. ಅವುಗಳ ಅರ್ಥ ಇಲ್ಲಿದೆ.

• 0 , STDIN - ಪ್ರಮಾಣಿತ ಇನ್‌ಪುಟ್ ಸ್ಟ್ರೀಮ್.
• 1, STDOUT - ಪ್ರಮಾಣಿತ ಔಟ್‌ಪುಟ್ ಸ್ಟ್ರೀಮ್.
• 2, STDERR - ಪ್ರಮಾಣಿತ ದೋಷ ಸ್ಟ್ರೀಮ್.

STDIN

ಅನೇಕ ಬ್ಯಾಷ್ ಆಜ್ಞೆಗಳುಡೇಟಾವನ್ನು ತೆಗೆದುಕೊಳ್ಳಬೇಕಾದ ಫೈಲ್ ಅನ್ನು ಆಜ್ಞಾ ಸಾಲಿನ ನಿರ್ದಿಷ್ಟಪಡಿಸದಿದ್ದರೆ STDIN ನಿಂದ ಇನ್ಪುಟ್ ಅನ್ನು ಸ್ವೀಕರಿಸಿ. ಉದಾಹರಣೆಗೆ, ಬೆಕ್ಕು ಆಜ್ಞೆಗೆ ಇದು ನಿಜ.

ನೀವು ಪ್ರವೇಶಿಸಿದಾಗ ಬೆಕ್ಕು ಆಜ್ಞೆಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ, ಯಾವುದೇ ನಿಯತಾಂಕಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸದೆ, ಇದು STDIN ನಿಂದ ಇನ್‌ಪುಟ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ. ನೀವು ಮುಂದಿನ ಸಾಲನ್ನು ನಮೂದಿಸಿದ ನಂತರ, ಬೆಕ್ಕು ಅದನ್ನು ಪರದೆಯ ಮೇಲೆ ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

STDOUT

ಆದ್ದರಿಂದ ನಾವು ಈ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಹೆಚ್ಚಿನ ಡೇಟಾವನ್ನು ಸೇರಿಸಬಹುದಾದ ಡೇಟಾ ಫೈಲ್ ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ:

Pwd >> myfile
myfile ಫೈಲ್‌ಗೆ ಯಾವ pwd ಔಟ್‌ಪುಟ್‌ಗಳನ್ನು ಸೇರಿಸಲಾಗುತ್ತದೆ, ಆದರೆ ಈಗಾಗಲೇ ಅದರಲ್ಲಿರುವ ಡೇಟಾ ಎಲ್ಲಿಯೂ ಹೋಗುವುದಿಲ್ಲ.

ಕಮಾಂಡ್ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಫೈಲ್‌ಗೆ ಮರುನಿರ್ದೇಶಿಸಲಾಗುತ್ತಿದೆ

ಇಲ್ಲಿಯವರೆಗೆ ಉತ್ತಮವಾಗಿದೆ, ಆದರೆ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದ xfile ಅನ್ನು ಪ್ರವೇಶಿಸುವ ಮೂಲಕ ನೀವು ಈ ಕೆಳಗಿನಂತೆ ಏನನ್ನಾದರೂ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿದರೆ ಏನು ಮಾಡಬೇಕು, ಎಲ್ಲವನ್ನೂ myfile ಗೆ ದೋಷ ಸಂದೇಶವನ್ನು ಕಳುಹಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ.

Ls –l xfile > myfile
ಈ ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದ ನಂತರ, ನಾವು ಪರದೆಯ ಮೇಲೆ ದೋಷ ಸಂದೇಶಗಳನ್ನು ನೋಡುತ್ತೇವೆ.

ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದ ಫೈಲ್ ಅನ್ನು ಪ್ರವೇಶಿಸಲು ಪ್ರಯತ್ನಿಸುವಾಗ ದೋಷ ಉಂಟಾಗುತ್ತದೆ, ಆದರೆ ಶೆಲ್ ದೋಷ ಸಂದೇಶಗಳನ್ನು ಪರದೆಯ ಮೇಲೆ ಮುದ್ರಿಸುವ ಮೂಲಕ ಫೈಲ್‌ಗೆ ಮರುನಿರ್ದೇಶಿಸಿಲ್ಲ. ಆದರೆ ಫೈಲ್‌ನಲ್ಲಿ ದೋಷ ಸಂದೇಶಗಳನ್ನು ಸೇರಿಸಬೇಕೆಂದು ನಾವು ಬಯಸಿದ್ದೇವೆ. ಏನು ಮಾಡಬೇಕು? ಉತ್ತರ ಸರಳವಾಗಿದೆ - ಮೂರನೇ ಗುಣಮಟ್ಟದ ವಿವರಣೆಯನ್ನು ಬಳಸಿ.

STDERR

ಆದ್ದರಿಂದ, ನಾವು ದೋಷ ಸಂದೇಶಗಳನ್ನು ಪರದೆಯ ಮೇಲೆ ಮುದ್ರಿಸುವ ಬದಲು ಲಾಗ್ ಫೈಲ್ ಅಥವಾ ಬೇರೆಡೆಗೆ ಮರುನಿರ್ದೇಶಿಸಲು ಬಯಸುತ್ತೇವೆ ಎಂದು ಹೇಳೋಣ.

▍ಮರುನಿರ್ದೇಶನ ದೋಷ ಹರಿವು

Ls -l xfile 2>myfile cat ./myfile
ದೋಷ ಸಂದೇಶವು ಈಗ myfile ಗೆ ಹೋಗುತ್ತದೆ.

▍ ಮರುನಿರ್ದೇಶನ ದೋಷ ಮತ್ತು ಔಟ್‌ಪುಟ್ ಸ್ಟ್ರೀಮ್‌ಗಳು

Ls –l myfile xfile anotherfile 2> ದೋಷವಿಷಯ 1> ಸರಿಯಾದ ವಿಷಯ

ಮರುನಿರ್ದೇಶನ ದೋಷಗಳು ಮತ್ತು ಪ್ರಮಾಣಿತ ಔಟ್ಪುಟ್

1> ರಚನೆಗೆ ಧನ್ಯವಾದಗಳು ಸರಿಯಾದ ವಿಷಯ ಫೈಲ್‌ಗೆ ls ಆಜ್ಞೆಯು ಸಾಮಾನ್ಯವಾಗಿ STDOUT ಗೆ ಕಳುಹಿಸುವದನ್ನು ಶೆಲ್ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ. 2> ಮರುನಿರ್ದೇಶನ ಆಜ್ಞೆಯಿಂದಾಗಿ STDERR ಗೆ ಹೋಗುವ ದೋಷ ಸಂದೇಶಗಳು ದೋಷದ ವಿಷಯ ಫೈಲ್‌ನಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುತ್ತವೆ.

ಅಗತ್ಯವಿದ್ದರೆ, &> ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು STDERR ಮತ್ತು STDOUT ಎರಡನ್ನೂ ಒಂದೇ ಫೈಲ್‌ಗೆ ಮರುನಿರ್ದೇಶಿಸಬಹುದು:

ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದ ನಂತರ, STDERR ಮತ್ತು STDOUT ಗಾಗಿ ಉದ್ದೇಶಿಸಿರುವುದು ವಿಷಯ ಫೈಲ್‌ನಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ.

ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಮರುನಿರ್ದೇಶಿಸಲಾಗುತ್ತಿದೆ

• ತಾತ್ಕಾಲಿಕ ಮರುನಿರ್ದೇಶನ, ಅಥವಾ ಏಕ ಸಾಲಿನ ಔಟ್‌ಪುಟ್ ಮರುನಿರ್ದೇಶನ.
• ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಔಟ್‌ಪುಟ್‌ನ ಎಲ್ಲಾ ಅಥವಾ ಭಾಗದ ಶಾಶ್ವತ ಮರುನಿರ್ದೇಶನ ಅಥವಾ ಮರುನಿರ್ದೇಶನ.

▍ತಾತ್ಕಾಲಿಕ ಔಟ್‌ಪುಟ್ ಮರುನಿರ್ದೇಶನ

#!/bin/bash echo "ಇದು ದೋಷ" >&2 ಪ್ರತಿಧ್ವನಿ "ಇದು ಸಾಮಾನ್ಯ ಔಟ್‌ಪುಟ್"
ನೀವು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಚಲಾಯಿಸಿದರೆ, ಎರಡೂ ಸಾಲುಗಳು ಪರದೆಯ ಮೇಲೆ ಗೋಚರಿಸುತ್ತವೆ, ಏಕೆಂದರೆ ನೀವು ಈಗಾಗಲೇ ತಿಳಿದಿರುವಂತೆ, ಡೀಫಾಲ್ಟ್ ದೋಷಗಳು ಸಾಮಾನ್ಯ ಡೇಟಾದಂತೆಯೇ ಅದೇ ಸ್ಥಳದಲ್ಲಿ ಔಟ್ಪುಟ್ ಆಗಿರುತ್ತವೆ.

STDERR ಔಟ್‌ಪುಟ್ ಫೈಲ್‌ಗೆ ಹೋಗುವಂತೆ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ರನ್ ಮಾಡೋಣ.

./myscript 2> myfile
ನೀವು ನೋಡುವಂತೆ, ಈಗ ಸಾಮಾನ್ಯ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಕನ್ಸೋಲ್‌ಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ದೋಷ ಸಂದೇಶಗಳು ಫೈಲ್‌ಗೆ ಹೋಗುತ್ತವೆ.

▍ಶಾಶ್ವತ ಔಟ್‌ಪುಟ್ ಮರುನಿರ್ದೇಶನ

#!/bin/bash exec 1>ಔಟ್‌ಫೈಲ್ ಪ್ರತಿಧ್ವನಿ "ಇದು ಎಲ್ಲಾ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಮರುನಿರ್ದೇಶಿಸುವ ಪರೀಕ್ಷೆ" ಪ್ರತಿಧ್ವನಿ "ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟ್‌ನಿಂದ ಮತ್ತೊಂದು ಫೈಲ್‌ಗೆ." ಪ್ರತಿಧ್ವನಿ "ಪ್ರತಿ ಸಾಲನ್ನು ಮರುನಿರ್ದೇಶಿಸದೆಯೇ"
ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ರನ್ ಮಾಡೋಣ.

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

exec ಆಜ್ಞೆಯನ್ನು ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಪ್ರಾರಂಭದಲ್ಲಿ ಮಾತ್ರವಲ್ಲದೆ ಇತರ ಸ್ಥಳಗಳಲ್ಲಿಯೂ ಬಳಸಬಹುದು:

#!/bin/bash exec 2>myerror echo "ಇದು ಆರಂಭಸ್ಕ್ರಿಪ್ಟ್‌ನ" ಪ್ರತಿಧ್ವನಿ "ಈಗ ಎಲ್ಲಾ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಮತ್ತೊಂದು ಸ್ಥಳಕ್ಕೆ ಮರುನಿರ್ದೇಶಿಸಲಾಗುತ್ತಿದೆ" ಎಕ್ಸಿಕ್ 1>ಮೈಫೈಲ್ ಎಕೋ "ಇದು ಮೈಫೈಲ್ ಫೈಲ್‌ಗೆ ಹೋಗಬೇಕು" ಎಕೋ "ಮತ್ತು ಇದು ಮೈರರ್ ಫೈಲ್‌ಗೆ ಹೋಗಬೇಕು" >&2
ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ರನ್ ಮಾಡಿದ ನಂತರ ಮತ್ತು ನಾವು ಔಟ್‌ಪುಟ್ ಅನ್ನು ಮರುನಿರ್ದೇಶಿಸಿದ ಫೈಲ್‌ಗಳನ್ನು ನೋಡಿದ ನಂತರ ನೀವು ಪಡೆಯುವುದು ಇದನ್ನೇ.

exec ಆಜ್ಞೆಯು ಮೊದಲು STDERR ನಿಂದ ಫೈಲ್ myerror ಗೆ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ. ಹಲವಾರು ಪ್ರತಿಧ್ವನಿ ಆಜ್ಞೆಗಳ ಔಟ್‌ಪುಟ್ ಅನ್ನು ನಂತರ STDOUT ಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಪರದೆಯ ಮೇಲೆ ಮುದ್ರಿಸಲಾಗುತ್ತದೆ. exec ಆಜ್ಞೆಯು ನಂತರ STDOUT ನಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುವ ಯಾವುದನ್ನಾದರೂ ಫೈಲ್ myfile ಗೆ ಕಳುಹಿಸಲು ಕಾರಣವಾಗುತ್ತದೆ ಮತ್ತು ಅಂತಿಮವಾಗಿ ನಾವು ಎಕೋ ಆಜ್ಞೆಯಲ್ಲಿ STDERR ಗೆ ಮರುನಿರ್ದೇಶನ ಆಜ್ಞೆಯನ್ನು ಬಳಸುತ್ತೇವೆ, ಇದು ಫೈಲ್ myerror ಗೆ ಅನುಗುಣವಾದ ಸಾಲನ್ನು ಬರೆಯಲು ಕಾರಣವಾಗುತ್ತದೆ.

ಒಮ್ಮೆ ನೀವು ಇದನ್ನು ಮಾಸ್ಟರಿಂಗ್ ಮಾಡಿದ ನಂತರ, ನೀವು ಎಲ್ಲಿ ಹೋಗಬೇಕೆಂದು ನೀವು ಬಯಸುತ್ತೀರಿ ಅಲ್ಲಿ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಮರುನಿರ್ದೇಶಿಸಲು ನಿಮಗೆ ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಈಗ ಇನ್ಪುಟ್ ಮರುನಿರ್ದೇಶನದ ಬಗ್ಗೆ ಮಾತನಾಡೋಣ.

ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ ಇನ್‌ಪುಟ್ ಅನ್ನು ಮರುನಿರ್ದೇಶಿಸಲಾಗುತ್ತಿದೆ

Exec 0< myfile
ಈ ಆಜ್ಞೆಯು ಶೆಲ್‌ಗೆ ಇನ್‌ಪುಟ್ ಮೂಲವು ಸಾಮಾನ್ಯ STDIN ಗಿಂತ ಮೈಫೈಲ್ ಆಗಿರಬೇಕು ಎಂದು ಹೇಳುತ್ತದೆ. ಕ್ರಿಯೆಯಲ್ಲಿ ಇನ್‌ಪುಟ್ ಮರುನಿರ್ದೇಶನವನ್ನು ನೋಡೋಣ:

#!/bin/bash exec 0< testfile count=1 while read line do echo "Line #$count: $line" count=$(($count + 1)) done
ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ರನ್ ಮಾಡಿದ ನಂತರ ಇದು ಪರದೆಯ ಮೇಲೆ ಕಾಣಿಸುತ್ತದೆ.

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

ಕೆಲವು ಲಿನಕ್ಸ್ ನಿರ್ವಾಹಕರು ಲಾಗ್ ಫೈಲ್‌ಗಳನ್ನು ಓದಲು ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಈ ವಿಧಾನವನ್ನು ಬಳಸುತ್ತಾರೆ.

ನಿಮ್ಮ ಸ್ವಂತ ಔಟ್‌ಪುಟ್ ಮರುನಿರ್ದೇಶನವನ್ನು ರಚಿಸಲಾಗುತ್ತಿದೆ

exec ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಡೇಟಾವನ್ನು ಔಟ್ಪುಟ್ ಮಾಡಲು ನೀವು ಹ್ಯಾಂಡಲ್ ಅನ್ನು ನಿಯೋಜಿಸಬಹುದು:

#!/bin/bash exec 3>myfile echo "ಇದು ಪರದೆಯ ಮೇಲೆ ಪ್ರದರ್ಶಿಸಬೇಕು" ಪ್ರತಿಧ್ವನಿ "ಮತ್ತು ಇದನ್ನು ಫೈಲ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಬೇಕು" >&3 ಪ್ರತಿಧ್ವನಿ "ಮತ್ತು ಇದು ಪರದೆಯ ಮೇಲೆ ಹಿಂತಿರುಗಬೇಕು"
ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಚಲಾಯಿಸಿದ ನಂತರ, ಔಟ್ಪುಟ್ನ ಭಾಗವು ಪರದೆಯ ಮೇಲೆ ಕಾಣಿಸುತ್ತದೆ, ಭಾಗ - ಡಿಸ್ಕ್ರಿಪ್ಟರ್ 3 ನೊಂದಿಗೆ ಫೈಲ್ನಲ್ಲಿ.

ಡೇಟಾ ಎಂಟ್ರಿಗಾಗಿ ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್‌ಗಳನ್ನು ರಚಿಸಲಾಗುತ್ತಿದೆ

ಫೈಲ್ ಅನ್ನು ಓದಿದ ನಂತರ, ನೀವು STDIN ಅನ್ನು ಮರುಸ್ಥಾಪಿಸಬಹುದು ಮತ್ತು ಅದನ್ನು ಎಂದಿನಂತೆ ಬಳಸಬಹುದು:

#!/bin/bash exec 6<&0 exec 0< myfile count=1 while read line do echo "Line #$count: $line" count=$(($count + 1)) done exec 0<&6 read -p "Are you done now? " answer case $answer in y) echo "Goodbye";; n) echo "Sorry, this is the end.";; esac
ಸನ್ನಿವೇಶವನ್ನು ಪ್ರಯತ್ನಿಸೋಣ.

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, STDIN ಗೆ ಉಲ್ಲೇಖವನ್ನು ಸಂಗ್ರಹಿಸಲು ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ 6 ಅನ್ನು ಬಳಸಲಾಗಿದೆ. ನಂತರ ಇನ್‌ಪುಟ್ ಮರುನಿರ್ದೇಶನವನ್ನು ಮಾಡಲಾಯಿತು, ಫೈಲ್ STDIN ಗಾಗಿ ಡೇಟಾ ಮೂಲವಾಯಿತು. ನಂತರ ರೀಡ್ ಕಮಾಂಡ್‌ಗೆ ಇನ್‌ಪುಟ್ ಮರುನಿರ್ದೇಶಿಸಲಾದ STDIN ನಿಂದ ಬಂದಿದೆ, ಅಂದರೆ ಫೈಲ್‌ನಿಂದ.

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

ಫೈಲ್ ಹ್ಯಾಂಡಲ್‌ಗಳನ್ನು ಮುಚ್ಚಲಾಗುತ್ತಿದೆ

#!/bin/bash exec 3> myfile echo "ಇದು ಡೇಟಾದ ಪರೀಕ್ಷಾ ಸಾಲು" >&3 exec 3>&- ಪ್ರತಿಧ್ವನಿ "ಇದು ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ" >&3
ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದ ನಂತರ, ನಾವು ದೋಷ ಸಂದೇಶವನ್ನು ಸ್ವೀಕರಿಸುತ್ತೇವೆ.

ವಿಷಯವೆಂದರೆ ನಾವು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದ ವಿವರಣೆಯನ್ನು ಪ್ರವೇಶಿಸಲು ಪ್ರಯತ್ನಿಸಿದ್ದೇವೆ.

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

ತೆರೆದ ಹಿಡಿಕೆಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಪಡೆಯುವುದು

ಈ ಆಜ್ಞೆಯು ಅನೇಕ ಕೀಲಿಗಳನ್ನು ಹೊಂದಿದೆ, ಪ್ರಮುಖವಾದವುಗಳನ್ನು ನೋಡೋಣ.

• -p ಪ್ರಕ್ರಿಯೆ ID ಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
• -d ನೀವು ಮಾಹಿತಿಯನ್ನು ಪಡೆಯಲು ಬಯಸುವ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ ಸಂಖ್ಯೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಇತರ ಎರಡು ಸ್ವಿಚ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಹಿಂತಿರುಗಿದ ಫಲಿತಾಂಶಗಳ ಮೇಲೆ ತಾರ್ಕಿಕ ಮತ್ತು ಕಾರ್ಯಾಚರಣೆಯನ್ನು ನಿರ್ವಹಿಸಲು -a ಸ್ವಿಚ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ:

Lsof -a -p $$ -d 0,1,2

ತೆರೆದ ಹಿಡಿಕೆಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತಿದೆ

STDIN, STDOUT ಮತ್ತು STDERR ಗೆ ಸಂಬಂಧಿಸಿದ ಫೈಲ್‌ಗಳ ಪ್ರಕಾರವು CHR (ಕ್ಯಾರೆಕ್ಟರ್ ಮೋಡ್) ಆಗಿದೆ. ಅವೆಲ್ಲವೂ ಟರ್ಮಿನಲ್‌ಗೆ ಸೂಚಿಸುವುದರಿಂದ, ಫೈಲ್ ಹೆಸರು ಟರ್ಮಿನಲ್‌ಗೆ ನಿಯೋಜಿಸಲಾದ ಸಾಧನದ ಹೆಸರಿಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ. ಎಲ್ಲಾ ಮೂರು ಪ್ರಮಾಣಿತ ಫೈಲ್ಓದಲು ಮತ್ತು ಬರೆಯಲು ಎರಡೂ ಲಭ್ಯವಿದೆ.

ಸ್ಕ್ರಿಪ್ಟ್‌ನಿಂದ lsof ಆಜ್ಞೆಯನ್ನು ಕರೆಯುವುದನ್ನು ನೋಡೋಣ, ಇದರಲ್ಲಿ ಪ್ರಮಾಣಿತ ಪದಗಳಿಗಿಂತ ಹೆಚ್ಚುವರಿಯಾಗಿ, ಇತರ ವಿವರಣೆಗಳು ತೆರೆದಿರುತ್ತವೆ:

#!/bin/bash exec 3> myfile1 exec 6> myfile2 exec 7< myfile3 lsof -a -p $$ -d 0,1,2,3,6,7
ನೀವು ಈ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ರನ್ ಮಾಡಿದರೆ ಏನಾಗುತ್ತದೆ.

ಸ್ಕ್ರಿಪ್ಟ್ ಔಟ್‌ಪುಟ್‌ಗಾಗಿ (3 ಮತ್ತು 6) ಮತ್ತು ಇನ್‌ಪುಟ್‌ಗಾಗಿ (7) ಎರಡು ಹಿಡಿಕೆಗಳನ್ನು ತೆರೆಯಿತು. ಡಿಸ್ಕ್ರಿಪ್ಟರ್‌ಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲು ಬಳಸಲಾದ ಫೈಲ್‌ಗಳಿಗೆ ಮಾರ್ಗಗಳನ್ನು ಸಹ ತೋರಿಸಲಾಗಿದೆ.

ಔಟ್ಪುಟ್ ನಿಗ್ರಹ

ದೋಷ ಸಂದೇಶಗಳನ್ನು ಹೇಗೆ ನಿಗ್ರಹಿಸುವುದು ಎಂಬುದರ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

Ls -al ಬ್ಯಾಡ್‌ಫೈಲ್ ಇನ್ನೊಂದು ಫೈಲ್ 2> /dev/null
ಉದಾಹರಣೆಗೆ, ನೀವು ಫೈಲ್ ಅನ್ನು ಅಳಿಸದೆಯೇ ಅದನ್ನು ತೆರವುಗೊಳಿಸಬೇಕಾದರೆ ಅದೇ ವಿಧಾನವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ:

Cat /dev/null > myfile

ಫಲಿತಾಂಶಗಳು

ಮುಂದಿನ ಬಾರಿ ನಾವು ಮಾತನಾಡುತ್ತೇವೆ ಲಿನಕ್ಸ್ ಸಂಕೇತಗಳು, ಅವುಗಳನ್ನು ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ ಹೇಗೆ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು, ನಿಗದಿತ ಕೆಲಸಗಳನ್ನು ಚಾಲನೆ ಮಾಡುವ ಬಗ್ಗೆ ಮತ್ತು ಹಿನ್ನೆಲೆ ಕಾರ್ಯಗಳ ಬಗ್ಗೆ.

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