[Powered by Google Translate] ಟಾಮಿ: ಈ ವಿಡಿಯೋ, ನಾವು ಬಗ್ಗೆ ಕಲಿಯೋಣ
ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಮತ್ತು ಕೊಳವೆಗಳು.
ಇಲ್ಲಿಯವರೆಗೆ, ನಾವು ಕಾರ್ಯಗಳನ್ನು ಗೆ printf ಉಟಿ ಅನ್ನು ಬಳಸುತ್ತಿದ್ದೇನೆ
ಔಟ್ಪುಟ್ ಟರ್ಮಿನಲ್ಗೆ ಅಕ್ಷಾಂಶ ಮತ್ತು GetString ಕೆಲಸ
ಬಳಕೆದಾರ ನಮ್ಮ ಇನ್ಪುಟ್ ಒದಗಿಸಲು ಅವಕಾಶ
ಕೀಬೋರ್ಡ್ ಬಳಸಿ ಪ್ರೋಗ್ರಾಂ.
ಲೆಟ್ಸ್ ತ್ವರಿತವಾಗಿ ಒಂದು ಸಾಲಿನ ಗಳಿಸುವ ಯೋಜನೆಯನ್ನು ನೋಡೋಣ
ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ಮತ್ತು ಅದು ಹೊರತರುವ.
>> ಸಾಲು 7 ರಂದು, ನಾವು ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಬಳಕೆದಾರ ಪ್ರೇರೇಪಿಸಿತು, ಮತ್ತು ನೀವು
ನಂತರ ಸಾಲು 8 ರಂದು, ನಾವು ಔಟ್ ಮತ್ತೆ ಮುದ್ರಿಸುವ ಮಾಡುತ್ತಿದ್ದೇವೆ.
ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಸಂಕಲಿಸಲು ಮತ್ತು ಔಟ್ ಲೆಟ್.
ಗ್ರೇಟ್.
ನೀಡಿರುವ ಸ್ಟ್ರಿಂಗ್ ಮರಳಿ ಧ್ವನಿಸಿದರು
ಟರ್ಮಿನಲ್ ನಮಗೆ.
Printf ಕ್ರಿಯೆಯ ಒಂದು ಬರೆದು ಹೀಗೇಕಾಯಿತೆಂದರೆ
ಸ್ಟ್ರೀಮ್ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಔಟ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ, ಅಥವಾ S-T-D-ಔಟ್.
ಏನೋ stdout ಬರೆಯಲ್ಪಡುತ್ತದೆ ಅದು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಇಲ್ಲಿದೆ
ಟರ್ಮಿನಲ್ ಮೂಲಕ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.
>> ಆದ್ದರಿಂದ ಎಲ್ಲಾ ಚೆನ್ನಾಗಿ ಮತ್ತು ಉತ್ತಮ, ಆದರೆ ಎಂಬುದರ ಬದಲು ಸರಳವಾಗಿ, ವೇಳೆ
ಸ್ಟ್ರಿಂಗ್ ಪ್ರದರ್ಶಿಸುವ, ನಾವು ಒಂದು ಕಡತ ಇದನ್ನು ಉಳಿಸಲು ಬಯಸುತ್ತೇನೆ?
ಉದಾಹರಣೆಗೆ, ನಾವು ನೆನಪು ಬಯಸಬಹುದು ನಿಖರವಾಗಿ ನಮ್ಮ
ನಾವು ನಂತರ ಒಂದು ನಿರ್ದಿಷ್ಟ ಇನ್ಪುಟ್ ನೀಡಿದಾಗ ಪ್ರೋಗ್ರಾಂ ಮಾಡಿದರು.
ಒಂದು ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು, ನಮ್ಮ ಸಿ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಈ ಮಾಡಲು ಎಂದು
ಕಡತಗಳನ್ನು ಬರೆಯಲು ಕೆಲವು ವಿಶೇಷ ಕಾರ್ಯಗಳನ್ನು ನಾವು ಮಾಡುತ್ತೇವೆ ಎಂದು
ಇನ್ನೊಂದು ವಿಡಿಯೋದಲ್ಲಿ ನೋಡಿ.
ಇನ್ನಷ್ಟು ಸುಲಭವಾಗಿರುತ್ತದೆ, ಆದರೂ, ಹೇಗಾದರೂ ಮಾಡಿಕೊಡುವ
ಒಂದು ಕಡತವನ್ನು stdout ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ.
ಆ ರೀತಿಯಲ್ಲಿ, printf stdout ಗೆ ಬರೆದಾಗ ವಿಷಯಗಳ ತಿನ್ನುವೆ
ಒಂದು ಕಡತ ಬದಲಾಗಿ ಬರೆಯಬಹುದು
ಟರ್ಮಿನಲ್ ಮೂಲಕ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.
ನಾವು ಹೆಚ್ಚಾಗಿದ್ದುದು ಸೈನ್ ಸೇರಿಸುವ ಮೂಲಕ ಕೇವಲ ಮಾಡಬಹುದು, ನಂತರ
ಒಂದು ಕಡತದ ಹೆಸರು, ಆಜ್ಞೆಯನ್ನು ನಾವು ನಮ್ಮ ಕಾರ್ಯಕ್ರಮವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಳಸಿ.
>> ಆದ್ದರಿಂದ, ಕೇವಲ ಪಾಲಿಸಲು. / ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ, ನಾವು
ರನ್. / ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ, ನಂತರ, ಸೈನ್ ಹೆಚ್ಚಿನ ನಂತರ
file.txt ನಂತಹ FILENAME.
ಏನಾಗುತ್ತದೆ ಎಂದು ನೋಡೋಣ.
ಸರಿ.
ಈ ಸಮಯದಲ್ಲಿ, ಏನೂ ಟರ್ಮಿನಲ್ ಪ್ರದರ್ಶಿಸಲಾಯಿತು ಗಮನಿಸಿ,
ಆದರೆ ನಾವು ನಮ್ಮ ವಿಷಯಗಳನ್ನು ಬದಲಾಯಿಸಲಾಗಿತ್ತು ಮಾಡಿಲ್ಲ
ಎಲ್ಲ ಸಿ ಪ್ರೋಗ್ರಾಂ.
ಈಗ LS ಈ ಕೋಶದ ವಿಷಯಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು ಅವಕಾಶ.
>> ಎಲ್ಲಾ ಸರಿ.
ನಾವು ಈಗ file.txt ಎಂಬ ನಮ್ಮ ಕೋಶದಲ್ಲಿ ಒಂದು ಹೊಸ ಕಡತವನ್ನು ಹೊಂದಿಲ್ಲ
ಇದು ನಮ್ಮ ಓಡಿ ನಾವು ಸರಬರಾಜು ಫೈಲ್ ಹೆಸರು
ಪ್ರೋಗ್ರಾಂ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ.
ನ file.txt ತೆರೆದುಕೊಳ್ಳಲು ಅವಕಾಶ.
ಮತ್ತು ಇಲ್ಲಿ, ನಾವು ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಆಫ್ stdout ಔಟ್ ಎಂದು ನೋಡಬಹುದು
file.txt ಎಂಬ ಕಡತಕ್ಕೆ ಬರೆಯಲ್ಪಡುತ್ತದೆ.
ಇದರಿಂದ ಮತ್ತೆ ಹಿಂದಿನ ಆಜ್ಞೆಯನ್ನು ಅವಕಾಶ, ಆದರೆ ಪೂರೈಕೆ
ವಿವಿಧ ಇನ್ಪುಟ್ ಈ ಬಾರಿ.
ಸರಿ.
ಈಗ file.txt ಒಂದು ಗಮನಿಸೋಣ.
>> ನಾವು ಫೈಲ್ ಬರೆಯಲ್ಪಟ್ಟಿತೆಂದರೆ ಎಂಬುದನ್ನು ಇಲ್ಲಿ ನೋಡಬಹುದು, ಆದ್ದರಿಂದ ನಮ್ಮ
ಮೂಲ ಇನ್ಪುಟ್ ಎಂದಿಗೂ ಇಲ್ಲ.
ನಾವು ಬದಲಿಗೆ ಈ ಕಡತವನ್ನು ಸೇರಿಸಲು ಬಯಸಿದರೆ, ಹೊಸ ಪುಟ್ಟಿಂಗ್
ಕಡತದ ಪ್ರಸ್ತುತ ವಿಷಯಗಳ ಕೆಳಗೆ ಇನ್ಪುಟ್, ನಾವು
ಕೇವಲ ಒಂದು ಬದಲಿಗೆ ಎರಡು ಹೆಚ್ಚಾಗಿದ್ದುದು ಚಿಹ್ನೆಗಳನ್ನು ಬಳಸಿ.
ಅವರ ಆ ಪ್ರಯತ್ನಿಸೋಣ.
ನಾವು ಮತ್ತೆ file.txt ತೆರೆಯಲು ವೇಳೆ ಈಗ, ನಮ್ಮ ಎರಡೂ ನೋಡಬಹುದು
ಇನ್ಪುಟ್ ಸಾಲುಗಳು.
ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ, ನಾವು ಯಾವುದೇ ತಿರಸ್ಕರಿಸಲು ಬಯಸಬಹುದು
ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಔಟ್ಪುಟ್.
ಬದಲಿಗೆ ಒಂದು ಕಡತಕ್ಕೆ ಔಟ್ಪುಟ್ ಬರೆಯಲು ಮತ್ತು ನಂತರ ಅಳಿಸಲು ಹೆಚ್ಚು
ನಾವು ಪೂರೈಸಿದ ಮೇಲೆ ಫೈಲ್, ನಾವು ವಿಶೇಷ ಒಂದು ಬರೆಯಬಹುದು
ಕಡತ / dev / ಶೂನ್ಯ ಎಂದು.
ಏನು / ಬರೆಯಲ್ಪಡುತ್ತದೆ ಮಾಡಿದಾಗ dev/null--
ಅಥವಾ ಸಂಕ್ಷಿಪ್ತವಾಗಿ devnull -
ಇದು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ತಿರಸ್ಕರಿಸಲಾಗುತ್ತದೆ.
ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಒಂದು ಕಪ್ಪು ಕುಳಿ ಮಾಹಿತಿ devnull ನಗರದ.
>> ಈಗ ನಾವು ಹೆಚ್ಚಿನ ಸೈನ್ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಹೇಗೆ ನೋಡಬಹುದು
stdout, ನಾವು ಗುಣಮಟ್ಟದ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಹೇಗೆ ನೋಡೋಣ -
ಅಥವಾ S-T-D ಇನ್ -
stdout ನ ಸದೃಶ.
ಕಾರ್ಯಗಳನ್ನು ಇಷ್ಟ ಆದರೆ printf ಎಂಬ ಸ್ಟ್ರೀಮ್ಗೆ ಬರೆಯಲು
ಸ್ಟ್ರೀಮ್ ಓದುವುದಕ್ಕೆ stdout, GetString ಮತ್ತು ಸರಿಸಮನಾದ ಕಾರ್ಯಗಳನ್ನು
stdin ಎಂಬ, ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಹರಿವು ಆಗಿದೆ
ಅಕ್ಷರಗಳು ಕೀಬೋರ್ಡ್ ನಲ್ಲಿ ಟೈಪ್.
ನಾವು ಸೈನ್ ಕಡಿಮೆ ಬಳಸಿ stdin ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಮಾಡಬಹುದು, ನಂತರ
ಒಂದು ಕಡತದ ಮೂಲಕ.
ಈಗ, ಬದಲಿಗೆ ನಲ್ಲಿ ಇನ್ಪುಟ್ ಬಳಕೆದಾರ ಪ್ರೇರೇಪಿಸಿತು
ಟರ್ಮಿನಲ್, ಒಂದು ಪ್ರೋಗ್ರಾಂ ನಾವು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಕಡತವನ್ನು ತೆರೆಯಲು ಮತ್ತು ಬಳಸುತ್ತದೆ
ಇನ್ಪುಟ್ ಅದರ ಸಾಲುಗಳು.
>> ಏನಾಗುತ್ತದೆ ಎಂದು ನೋಡೋಣ.
ಗ್ರೇಟ್.
file.txt ಮೊದಲ ಸಾಲಿನ ಟರ್ಮಿನಲ್ಗೆ ಮುದ್ರಿತ ಮಾಡಲಾಗಿದೆ
ನಾವು ಒಮ್ಮೆ GetString ಕರೆ ಇರುವ ಕಾರಣ.
ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ GetString ಮತ್ತೊಂದು ಕರೆ ನೀಡಿದ್ದಾರೆ,
file.txt ಮುಂದಿನ ಸಾಲಿನ ಬಳಸಲಾಗಿದೆ ಎಂದು
ಆ ಕರೆಗೆ ಇನ್ಪುಟ್.
ಮತ್ತೆ, ನಾವು ಎಲ್ಲಾ ನಮ್ಮ ಸಿ ಪ್ರೋಗ್ರಾಂ ಬದಲಾಯಿಸಲಾಗಿತ್ತು ಮಾಡಿಲ್ಲ.
ನಾವು ಕೇವಲ ನಾವು ರನ್ ಹೇಗೆ ಬದಲಾವಣೆ ತರುತ್ತಿದ್ದೇವೆ.
ಮತ್ತು, ನಾವು stdout ಈ ಬಾರಿ ಮರುನಿರ್ದೇಶಿಸಲಾಗುತ್ತದೆ ಮಾಡಿಲ್ಲ, ನೆನಪು
ಆದ್ದರಿಂದ ಕಾರ್ಯಕ್ರಮದ ಔಟ್ಪುಟ್ ಇನ್ನೂ
ಟರ್ಮಿನಲ್ ಪ್ರದರ್ಶಿಸಲಾಯಿತು.
ನಾವು, ಸಹಜವಾಗಿ, stdin ಎರಡೂ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಮಾಡಬಹುದು
ಈ ರೀತಿಯ ಮತ್ತು stdout.
ಈಗ, file2.txt file.txt ಮೊದಲ ಸಾಲನ್ನು ಹೊಂದಿದೆ.
>> ಆದ್ದರಿಂದ, ಈ ನಿರ್ವಾಹಕರು ಬಳಸಿ, ನಾವು ಓದಿ ಸಾಧ್ಯವಾಯಿತು
ಪಠ್ಯ ಕಡತಗಳನ್ನು ಬರೆಯುತ್ತಿರುವೆ.
ಈಗ, ನಾವು ಒಂದು ಕಾರ್ಯಕ್ರಮದ ಔಟ್ಪುಟ್ ಅನ್ನು ಹೇಗೆ ನೋಡೋಣ
ಇನ್ನೊಂದು ಪ್ರೋಗ್ರಾಂಗೆ ಇನ್ಪುಟ್.
ಇಲ್ಲಿ ಇನ್ನೊಂದು ಸರಳ ಸಿ ಪ್ರೋಗ್ರಾಂ I ನ
ಇಲ್ಲಿ hello.c ಎಂದು.
ನೀವು ನೋಡಬಹುದು ಎಂದು, ಈ ಕೇವಲ ಹಾಯ್ "ಫಲಿತಾಂಶ
ಇಲ್ಲ! "ಬಳಕೆದಾರರಿಗೆ.
- ನಾನು ಇನ್ಪುಟ್ ಎಂದು ಹಲೋ ಔಟ್ಪುಟ್ ಅನ್ನು ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಬಯಸಿದರೆ
ಮತ್ತೊಂದು ಕಾರ್ಯಕ್ರಮ -
ನಾನು ಮೊದಲ ಎಂಬ ಕಡತಕ್ಕೆ ಹಲೋ stdout ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ
input.txt, ನಂತರ ಅದೇ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ಆಫ್ stdin ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ
ಕಡತ - input.txt.
ಆದ್ದರಿಂದ ನಾನು ಮಾಡಬಹುದು. / ಹಲೋ> input.txt.
ಈ ಕಾರ್ಯಗತಗೊಳಿಸಲು Enter ಅನ್ನು ಒತ್ತಿರಿ.
ನಂತರ. / ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ <
input.txt, ಮತ್ತು ಎಕ್ಸಿಕ್ಯೂಟ್.
ನಾವು ಅನುಮತಿಸುವ ಒಂದು ಅರ್ಧವಿರಾಮ ಚಿಹ್ನೆಯಿಂದ ಈ ಒಂದು ಬಿಟ್, ಕಡಿಮೆ ಮಾಡಬಹುದು
ನಮಗೆ ಒಂದೇ ಸಾಲಿನಲ್ಲಿ ಎರಡು ಅಥವಾ ಹೆಚ್ಚು ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಲು.
ನಾನು ಹೇಳಬಹುದು. / ಹಲೋ> input.txt, ಅಲ್ಪ ವಿರಾಮ ಚಿಹ್ನೆಯನ್ನು
. / <Input.txt ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ.
>> ಈ ಕೃತಿಗಳು ಆದ್ದರಿಂದ, ಆದರೆ ಇದು ಇನ್ನೂ ಸಾಕಷ್ಟು ಸೊಬಗಿಲ್ಲದ ಭಾವಿಸುತ್ತಾನೆ.
ನನ್ನ ಪ್ರಕಾರ, ನಾವು ಎಂದು ಈ ಮಧ್ಯವರ್ತಿ ಪಠ್ಯ ಕಡತ ಬೇಕು
ರನ್ಗಳು ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ ನಂತರ ಇನ್ನು ಮುಂದೆ ಅಗತ್ಯ?
ಅದೃಷ್ಟವಶಾತ್, ನಾವು ಯಾವುದು ಬಳಸಿಕೊಂಡು ಈ ಹೆಚ್ಚುವರಿ ಪಠ್ಯ ಕಡತ ತಪ್ಪಿಸಲು ಮಾಡಬಹುದು
ಪೈಪ್ ಕರೆಯಲಾಗುತ್ತದೆ.
ನಾನು ಹೇಳಲು ವೇಳೆ, / ಹಲೋ |.. / ನಂತರ, ನ stdout ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ
ಎಡಭಾಗದಲ್ಲಿ ಕಾರ್ಯಕ್ರಮ -
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಿನ್ನ -
ಗುಣಮಟ್ಟ ಇನ್ಪುಟ್ ಆಗಿ ಬಳಸಲಾಗುತ್ತದೆ
ಬಲಭಾಗದಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ.
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ. ಆದ್ದರಿಂದ ಅವರ ಈ ರನ್ ಅವಕಾಶ.
>> ನಾವು ಹೋಗಿ.
ನಾವು ಇನ್ಪುಟ್ ಎಂದು ನಿನ್ನ ಉತ್ಪತ್ತಿಯು ಬಳಸಿದ ನೋಡಬಹುದು
ಮರುನಿರ್ದೇಶಿಸಲು ಫಾರ್.
ಒಟ್ಟಿಗೆ ಆಜ್ಞೆಗಳನ್ನು stringing ಪೈಪ್ ಬಳಸಿ, ನಾವು ಯಾವುದು ರೂಪಿಸುತ್ತದೆ
ನಮ್ಮ ಔಟ್ಪುಟ್ ಮೂಲಭೂತವಾಗಿ ಚಲಿಸುವ ಕಾರಣ, ಒಂದು ಪೈಪ್ಲೈನ್ ಎಂದು
ಆಜ್ಞೆಗಳ ಒಂದು ಅನುಕ್ರಮವನ್ನು ಮೂಲಕ.
ಕೊಳವೆಗಳ ಬಳಕೆಯನ್ನು, ನಾವು ಅಗತ್ಯವಿಲ್ಲದೆ ಕೆಲವು ಕೂಲ್ ಸ್ಟಫ್ ಮಾಡಬಹುದು
ಯಾವುದೇ ಕೋಡ್ ಬರೆಯಲು.
ಉದಾಹರಣೆಗೆ, ಈಗ ನಾವು ಎಷ್ಟು ಕಡತಗಳನ್ನು ತಿಳಿಯಲು ಬಯಸುವ ಹೇಳುತ್ತಾರೆ
ಈ ಕೋಶದ ಒಳಗೆ.
ಪೈಪ್ ಬಳಸಿ, ನಾವು WC ಜೊತೆ LS ಆಜ್ಞೆಯನ್ನು ಒಂದುಗೂಡಿಸಬಹುದು -
ಅಥವಾ wordcount -
ಆಜ್ಞೆಯನ್ನು.
Ls stdout ಕೋಶದ ಪ್ರತಿ ಕಡತ ಔಟ್ಪುಟ್, ಮತ್ತು
WC stdin ಮೂಲಕ ನೀಡಲಾಗುತ್ತದೆ ಎಷ್ಟು ಸಾಲುಗಳು ನಮಗೆ ಕಾಣಿಸುತ್ತದೆ.
ಆದ್ದರಿಂದ, ನಾವು ವೇಳೆ LS | WC-L -
ರೇಖೆಗಳ ಎಣಿಕೆ ಅದನ್ನು ಹೇಳಲು WC ಗೆ-L ಧ್ವಜ ಸರಬರಾಜು -
ನಾವು ನಿಖರವಾಗಿ ಎಷ್ಟು ಕಡತಗಳನ್ನು ನೋಡಬಹುದು
ಪ್ರಸ್ತುತ ಕೋಶದಲ್ಲಿ.
>> ಆದ್ದರಿಂದ ನ ಇನ್ನೊಂದು ಉದಾಹರಣೆಯನ್ನು ಅವಲೋಕಿಸೋಣ.
ನಾನು ಇಲ್ಲಿ students.txt ಎಂಬ ಕಡತ ಹೊಂದಿವೆ
ಹೆಸರುಗಳ ಪಟ್ಟಿಯನ್ನು.
ಆದಾಗ್ಯೂ, ಈ ಹೆಸರುಗಳನ್ನು ಯಾವುದೇ ಕ್ರಮದಲ್ಲಿ ಎಲ್ಲಾ ಇಲ್ಲ, ಮತ್ತು ಇದು ಕಾಣುತ್ತದೆ
ನಂತಹ ಕೆಲವು ಹೆಸರುಗಳು ಪುನರಾವರ್ತಿಸಲಾಗಿದೆ.
ನಾವು ಬಯಸುವ ವರ್ಣಮಾಲೆಯ ವಿಶಿಷ್ಟ ಹೆಸರುಗಳ ಪಟ್ಟಿ
final.txt ಎಂಬ ಕಡತಕ್ಕೆ ಉಳಿಸಲಾಗಿದೆ ಆದೇಶ.
ನಾವು, ವಾಸ್ತವವಾಗಿ, ನಮಗೆ ಈ ಮಾಡಲು ಸಿ ಪ್ರೋಗ್ರಾಮ್ ಬರೆಯಲು ಸಾಧ್ಯವಾಯಿತು.
ಆದರೆ ಅನಗತ್ಯವಾಗಿ ಪಡೆಯಲು ವಿಶೇಷವೇನು
ಬಹಳ ಬೇಗನೆ ಸಂಕೀರ್ಣ.
ಲೆಟ್ಸ್ ಬದಲಿಗೆ ಪರಿಹರಿಸಲು ಕೊಳವೆಗಳು ಮತ್ತು ಕೆಲವು ಅಂತರ್ನಿರ್ಮಿತ-ಸಾಧನಗಳನ್ನು ಬಳಸಿ
ಈ ಸಮಸ್ಯೆ.
>> ನಾವು ಮಾಡಬೇಕಾದ್ದು ಮೊದಲ ವಿಷಯ ಕಡತ students.txt ಓದಲು.
ಬೆಕ್ಕು ಆಜ್ಞೆಯನ್ನು ಕೇವಲ ಹಾಗೆ ಕಾಣಿಸುತ್ತದೆ.
ಇದು ಸೂಚಿಸಲಾದ ಕಡತದಲ್ಲಿ ಓದಲು ಮತ್ತು ಬರೆಯಲು ಕಾಣಿಸುತ್ತದೆ
stdout ತನ್ನ ವಿಷಯಗಳ.
ನಾವು ಪಠ್ಯ ಕಡತ ಓದಿದ ನಂತರ, ನಾವು ಮಾಡುತ್ತೇವೆ
ಹೆಸರುಗಳು ವಿಂಗಡಿಸಲು ಬಯಸುವ.
ರೀತಿಯ ಆದೇಶ ನಮಗೆ ಈ ನಿಭಾಯಿಸಬಲ್ಲದು.
ವಿಂಗಡಿಸಿ stdout ಗೆ stdin ಮೂಲಕ ಸರಬರಾಜು ಸಾಲಿನ ಔಟ್ಪುಟ್ ಕಾಣಿಸುತ್ತದೆ
ವಿಂಗಡಿಸಲಾದ ಸಲುವಾಗಿ.
Students.txt ವಿಷಯಗಳನ್ನು ಗೆ ಸರಬರಾಜು ಮಾಡಲು
ರೀತಿಯ ನ stdin, ನಾವು ಬೆಕ್ಕು ಮತ್ತು ರೀತಿಯ ಸಂಯೋಜಿಸಲು ಪೈಪ್ ಬಳಸಬಹುದಾಗಿತ್ತು.
ರೀತಿಯ ಮತ್ತು | ನಾನು ಬೆಕ್ಕು students.txt ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು
Enter ಒತ್ತಿರಿ.
ಈಗ, ನಾವು students.txt ವಿಷಯಗಳನ್ನು ನೋಡಿ
ಅಕಾರಾದಿಯಲ್ಲಿ.
>> ಆದ್ದರಿಂದ ಅವರ ಇನ್ನೊಂದು ಆಜ್ಞೆಯನ್ನು ಸೇರಿಸಲು ಅವಕಾಶ -
uniq, ಅಥವಾ ಅನನ್ಯ -
ನಮ್ಮ ಪೈಪ್ಲೈನ್ಗೆ.
ನೀವು uniq ಊಹಿಸುವಂತೆ, ಯಾವಾಗ ಒಂದು ವಿಂಗಡಿಸಲಾದ ಅನುಕ್ರಮ ಸರಬರಾಜು
stdin ಮೂಲಕ ಸಾಲುಗಳು ಅನನ್ಯ ಮಾರ್ಗಗಳು ಔಟ್ಪುಟ್ ಕಾಣಿಸುತ್ತದೆ.
ಈಗ ನಾವು ಬೆಕ್ಕು students.txt ಹೊಂದಿವೆ
| ರೀತಿಯ | uniq.
ಅಂತಿಮವಾಗಿ, ನಾವು ಗೆ ಪೈಪ್ ಔಟ್ಪುಟ್ ಉಳಿಸಬಹುದು
ರೀತಿಯ | | uniq ಬೆಕ್ಕು students.txt ಮೂಲಕ ಕಡತ
> Final.txt.
ನಾವು final.txt ತೆರೆಯುತ್ತದೆ ಆದ್ದರಿಂದ, ನಾವು ಎಂದು ನಿಖರವಾಗಿ ಏನು ಹೊಂದಿದ್ದರೆ
ಹುಡುಕುತ್ತಿರುವ:
ಅಕಾರಾದಿಯಲ್ಲಿ ಅನನ್ಯ ಹೆಸರುಗಳ ಪಟ್ಟಿ,
ಒಂದು ಪಠ್ಯ ಕಡತವನ್ನು ಉಳಿಸಿದ.
ಮೂಲಕ, ನಾವು ಕೂಡ ಹೇಳಿದರು ಎಂದು ರೀತಿಯ <
students.txt | uniq> final.txt ಮಾಡಲು ನಿಖರವಾಗಿ
ನಾವು ನೋಡಿರುವ ನಿರ್ವಾಹಕರ ಪ್ರತಿ ಬಳಸಿಕೊಂಡು ಅದೇ ವಿಷಯ,
ಈ ವೀಡಿಯೊ.
>> ನನ್ನ ಹೆಸರು ಟಾಮಿ ಆಗಿದೆ, ಮತ್ತು ಈ CS50 ಹೊಂದಿದೆ.