[Powered by Google Translate] טאַמי: אין דעם ווידעא, מיר וועט לערנען וועגן
רידערעקטינג און פּייפּס.
אַזוי ווייַט, מיר ווע שוין ניצן פאַנגקשאַנז ווי פּרינטף צו
רעזולטאַט דאַטן צו דער וואָקזאַל און פאַנגקשאַנז ווי געצטרינג
צו לאָזן די באַניצער צו צושטעלן אַרייַנשרייַב צו אונדזער
פּראָגראַם ניצן די קלאַוויאַטור.
זאל ס געשווינד נעמען אַ קוק אין אַ פּראָגראַם וואָס געץ אַ שורה פון
אַרייַנשרייַב פון דעם באַניצער און דעמאָלט אַוטפּוץ עס.
>> אויף שורה 7, מיר רע פּראַמפּטינג דער באַניצער פֿאַר אַ שטריקל, און
דעמאָלט אויף שורה 8, מיר רע דרוקן עס צוריק אויס.
זאל ס צונויפנעמען און לויפן אונדזער פּראָגראַם.
גרויס.
די שטריקל מיר צוגעשטעלט איז עקאָוד צוריק
צו אונדז אין דער וואָקזאַל.
דאס געטראפן ווייַל די פּרינטף פונקציאָנירן געשריבן צו אַ
טייַך גערופן נאָרמאַל אויס, אָדער ס-ה-D-אויס.
ווען עפּעס איז געשריבן צו סטדאָוט, עס ס דורך פעליקייַט
געוויזן דורך די וואָקזאַל.
>> אַזוי אַז ס אַלע געזונט און גוט, אָבער וואָס אויב, אַנשטאָט פון פשוט
ווייַזנדיק דעם שטריקל, מיר געוואלט צו ראַטעווען עס צו אַ טעקע?
פֿאַר בייַשפּיל, מיר זאל וועלן צו געדענקען פּונקט וואָס אונדזער
פּראָגראַם האט ווען מיר געגעבן עס אַ באַזונדער אַרייַנשרייַב שפּעטער.
איינער צוגאַנג וואָלט זייַן צו טאָן דאָס אין אונדזער C פּראָגראַם, ניצן
עטלעכע ספּעציעל פאַנגקשאַנז פֿאַר שרייבן צו טעקעס אַז מיר וועט
זען אין אן אנדער ווידעא.
אפילו גרינגער, כאָטש, וואָלט זייַן צו עפעס
רידערעקט סטדאָוט צו אַ טעקע.
אַז וועג, ווען פּרינטף שרייבט צו סטדאָוט, די אינהאַלט וועט
זייַן געשריבן צו אַ טעקע אלא ווי
געוויזן דורך די וואָקזאַל.
מיר קענען טאָן נאָר אַז דורך אַדינג אַ גרעסער-ווי צייכן, נאכגעגאנגען
דורך אַ טעקע נאָמען, צו די באַפֿעלן מיר נוצן צו ויספירן אונדזער פּראָגראַם.
>> אַזוי, אלא ווי פשוט עקסאַקיוטינג. / רידערעקט, מיר קענען
לויפן. / רידערעקט, נאכגעגאנגען דורך אַ גרעסער ווי צייכן, נאכגעגאנגען דורך
פילענאַמע, ווי פילע.טקסט.
זאל ס זען וואָס כאַפּאַנז.
גוט.
נאָטיץ אַז דאָס מאָל, גאָרנישט איז געוויזן אין דער וואָקזאַל,
אָבער מיר האָבן ניט געווארן מאדיפיצירט די אינהאַלט פון אונדזער
C פּראָגראַם אין אַלע.
זאל ס איצט ונטערזוכן די אינהאַלט פון דעם Directory מיט לס.
>> אַלע רעכט.
מיר איצט האָבן אַ נייַ טעקע אין אונדזער Directory גערופן פילע.טקסט,
וואָס איז די טעקע נאָמען מיר סאַפּלייד ווען מיר געלאפן אונדזער
רידערעקט פּראָגראַם.
זאל ס עפענען אַרויף פילע.טקסט.
און דאָ, מיר קענען זען אַז די סטדאָוט אויס פון רידערעקט איז געווען
געשריבן צו דער טעקע גערופן פילע.טקסט.
אַזוי לאָזן ס לויפן די פֿריִערדיקע באַפֿעלן ווידער, אָבער סאַפּלייינג אַ
פאַרשידענע אַרייַנשרייַב דעם צייַט.
אָוקיי.
זאל ס נעמען אַ קוק בייַ פילע.טקסט איצט.
>> מיר קענען זען דאָ אַז דער טעקע האט שוין אָוווערריטאַן, אַזוי אונדזער
אָריגינעל אַרייַנשרייַב איז נישט דאָרט ענימאָר.
אויב מיר אַנשטאָט ווילן צו צוגעבן צו דעם טעקע, פּאַטינג די נייַ
אַרייַנשרייַב ונטער דער שאַפֿן אינהאַלט פון דער טעקע, מיר קענען
נוצן צוויי גרעסער-ווי וואונדער אַנשטאָט פון נאָר איין.
זאל ס פּרובירן וואָס.
איצט, אויב מיר עפענען פילע.טקסט ווידער, מיר קענען זען ביידע פון ​​אונדזער
אַרייַנשרייַב שורות.
אין עטלעכע פאלן, מיר זאל וועלן צו אַוועקוואַרפן קיין
רעזולטאַט פון אונדזער פּראָגראַם.
אלא ווי שרייבן די רעזולטאַט צו אַ טעקע און דעמאָלט דיליטינג
דער טעקע ווען מיר רע געטאן מיט עס, מיר קענען שרייַבן אַ צו ספּעציעל
טעקע גערופן / דעוו / נאַל.
ווען עפּעס איז געשריבן צו / דעוו/נולל--
אָדער נאָר דעוונולל פֿאַר קורץ -
עס איז אויטאָמאַטיש דיסקאַרדיד.
אַזוי טראַכטן פון דעוונולל ווי אַ שוואַרץ לאָך פֿאַר דיין דאַטן.
>> אַזוי איצט מיר ווע געזען ווי די גרעסער ווי צייכן קענען רידערעקט
סטדאָוט, לאָזן ס זען ווי מיר קענען רידערעקט נאָרמאַל אין -
אָדער ס-ה-D-אין -
דער אַנאַלאָג פון סטדאָוט.
בשעת פאַנגקשאַנז ווי פּרינטף שרייַבן צו די טייַך גערופן
סטדאָוט, געצטרינג און ענלעך פאַנגקשאַנז לייענען פון דעם טייַך
גערופן סטדין, וואָס, דורך פעליקייַט, איז דער טייַך פון
אותיות טייפּט אין די קלאַוויאַטור.
מיר קענען רידערעקט סטדין ניצן די ווייניקער ווי צייכן, נאכגעגאנגען
דורך אַ פילענאַמע.
איצט, אלא ווי פּראַמפּטינג דער באַניצער פֿאַר אַרייַנשרייַב בייַ די
וואָקזאַל, אַ פּראָגראַם וועט עפענען די טעקע מיר ספּעסאַפייד און נוצן
זייַן שורות ווי אַרייַנשרייַב.
>> זאל ס זען וואָס כאַפּאַנז.
גרויס.
דער ערשטער שורה פון פילע.טקסט האט שוין געדרוקט צו די וואָקזאַל
ווייַל מיר רע פאַך געצטרינג אַמאָל.
אויב מיר געהאט אן אנדער רופן צו געצטרינג אין אונדזער פּראָגראַם, די
ווייַטער שורה פון פילע.טקסט וואָלט האָבן שוין געניצט ווי
אַרייַנשרייַב צו אַז רופן.
ווידער, מיר האָבן ניט געווארן מאדיפיצירט אונדזער C פּראָגראַם אין אַלע.
מיר רע בלויז טשאַנגינג ווי מיר לויפן עס.
און אויך געדענקען, מיר האָבן ניט רידערעקטיד סטדאָוט דעם צייַט,
אַזוי דער רעזולטאַט פון דעם פּראָגראַם איז געווען נאָך
געוויזן בייַ די וואָקזאַל.
מיר קענען, פון קורס, רידערעקט ביידע סטדין
און סטדאָוט ווי דעם.
איצט, פילע2.טקסט כּולל דער ערשטער שורה פון פילע.טקסט.
>> אַזוי, ניצן די אָפּערייטערז, מיר ווע שוין קענען צו לייענען און
שרייַבן פון טעקסט טעקעס.
איצט, לאָזן ס זען ווי מיר קענען נוצן די רעזולטאַט פון איין פּראָגראַם ווי
די אַרייַנשרייַב צו אן אנדער פּראָגראַם.
אַזוי דאָ ס אנדערן פּשוט C פּראָגראַם איך
האָבן דאָ גערופן העללאָ.ק.
ווי איר קענען זען, דעם פשוט אַוטפּוץ "הי
דאָרט! "צו דעם באַניצער.
אויב איך ווילן רידערעקט צו נוצן ווי אַרייַנשרייַב דער רעזולטאַט פון העלא -
אן אנדער פּראָגראַם -
איך קען ערשטער רידערעקט די סטדאָוט פון העלא צו אַ טעקע גערופן
ינפּוט.טקסט, דעמאָלט רידערעקט די סטדין פון רידערעקט צו אַז זעלביקער
טעקע - ינפּוט.טקסט.
אַזוי איך קענען טאָן. / העלא> ינפּוט.טקסט.
דרוק אַרייַן צו ויספירן דעם.
נאכגעגאנגען דורך. / רידערעקט <
ינפּוט.טקסט, און ויספירן אַז.
אַזוי מיר קענען פאַרקירצן דעם אַ ביסל מיט אַ פּינטל - קאָמע, וואָס אַלאַוז
אונדז צו לויפן צוויי אָדער מער קאַמאַנדז אויף די זעלבע שורה.
אַזוי איך קענען זאָגן,. / העלא> ינפּוט.טקסט, פּינטל - קאָמע,
. / רידערעקט <ינפּוט.טקסט.
>> אַזוי דאָס אַרבעט, אָבער עס נאָך פילז שיין ינעלעגאַנט.
איך מיינען, טאָן מיר טאַקע דאַרפֿן דעם ינערמידיערי טעקסט טעקע אַז ס
ניט מער נייטיק נאָך רידערעקט לויפט?
צומ גליק, מיר קענען ויסמייַדן דעם עקסטרע טעקסט טעקע ניצן וואָס ס
גערופן אַ רער.
אויב איך זאָגן,. / העלא |. / רידערעקט, דעמאָלט דער סטדאָוט פון
די פּראָגראַם אויף די לינקס -
אין דעם פאַל, העלא -
וועט זייַן געניצט ווי דער נאָרמאַל אַרייַנשרייַב פֿאַר די
פּראָגראַם אויף די רעכט.
אין דעם פאַל, רידערעקט. אַזוי לאָזן ס לויפן דעם.
>> עס מיר גיין.
מיר קענען זען וואָס דער רעזולטאַט פון העלא איז געניצט ווי די אַרייַנשרייַב
פֿאַר רידערעקט.
דורך סטרינגינג קאַמאַנדז צוזאַמען ניצן פּייפּס, מיר פאָרעם וואָס ס
גערופן אַ רערנ - ליניע, זינט אונדזער רעזולטאַט איז יסענשאַלי מאָווינג
דורך אַ סיקוואַנס פון קאַמאַנדז.
ניצן פּייפּס, מיר קענען טאָן עטלעכע קיל שטאָפּן אָן נידינג צו
שרייַבן קיין קאָד אין אַלע.
פֿאַר בייַשפּיל, לאָזן ס זאָגן מיר ווילן צו וויסן ווי פילע טעקעס זענען
ין פון דעם וועגווייַזער.
ניצן אַ רער, מיר קענען פאַרבינדן די לס באַפֿעל מיט די קלאָזעט -
אָדער וואָרדקאָונט -
באַפֿעל.
עלעס וועט רעזולטאַט יעדער טעקע אין דער וועגווייַזער צו סטדאָוט, און
קלאָזעט וועט זאָגן אונדז ווי פילע שורות זענען געגעבן צו עס דורך סטדין.
אַזוי, אויב מיר זאָגן לס | קלאָזעט-ל -
סאַפּלייינג דער-ל פאָן צו קלאָזעט צו זאָגן עס צו ציילן שורות -
מיר קענען זען פּונקט ווי פילע טעקעס זענען
אין די קראַנט וועגווייַזער.
>> אַזוי לאָזן ס נעמען אַ קוק בייַ איינער מער בייַשפּיל.
איך האָבן דאָ אַ טעקע גערופן סטודענצ.טקסט,
מיט אַ רשימה פון נעמען.
אבער, די נעמען זענען נישט אין קיין סדר עס אַלע, און עס קוקט
ווי אַ ביסל נעמען זענען ריפּיטיד.
וואָס מיר ווילן איז אַ רשימה פון יינציק נעמען אין אַלפאַבעטיקאַל
סדר, געהאלפן צו אַ טעקע גערופן פינאַל.טקסט.
מיר קען, פון קורס, שרייַבן אַ C פּראָגראַם צו טאָן דעם פֿאַר אונדז.
אבער עס ס געגאנגען צו באַקומען אַננעסאַסעראַלי
קאָמפּלעקס שיין געשווינד.
זאל ס אַנשטאָט נוצן פּייפּס און עטלעכע געבויט-אין-מכשירים צו סאָלווע
דעם פּראָבלעם.
>> דער ערשטער זאַך מיר דאַרפֿן צו טאָן איז לייענען די טעקע סטודענצ.טקסט.
די קאַץ באַפֿעל וועט טאָן נאָר וואָס.
עס וועט לייענען אין דער ספּעסאַפייד טעקע און שרייַבן
זייַן אינהאַלט צו סטדאָוט.
נאָך מיר ווע לייענען די טעקסט טעקע, מיר וועט
ווילן צו סאָרט די נעמען.
די סאָרט באַפֿעל קענען שעפּן דאָס פֿאַר אונדז.
סאָרט וועט רעזולטאַט די שורה סאַפּלייד דורך סטדין צו סטדאָוט
אין אויסגעשטעלט סדר.
אין סדר צו צושטעלן די אינהאַלט פון סטודענצ.טקסט צו
סאָרט ס סטדין, מיר קען נוצן אַ רער צו פאַרבינדן קאַץ און סאָרט.
אַזוי איך קענען ויספירן קאַץ סטודענצ.טקסט | סאָרט און
דריקן אַרייַן.
און איצט, מיר זען די אינהאַלט פון סטודענצ.טקסט אין
אַלפאַבעטיקאַל סדר.
>> אַזוי לאָזן ס לייגן אן אנדער באַפֿעל -
וניק, אָדער יינציק -
צו אונדזער רערנ - ליניע.
ווי איר זאל טרעפן, וניק, ווען סאַפּלייד אַ אויסגעשטעלט סיקוואַנס פון
שורות דורך סטדין, וועט רעזולטאַט די יינציק שורות.
אַזוי איצט מיר האָבן קאַץ סטודענצ.טקסט
| סאָרט | וניק.
צום סוף, מיר קענען ראַטעווען די רעזולטאַט פון די רערנ - ליניע צו אַ
טעקע דורך קאַץ סטודענצ.טקסט | סאָרט | וניק
> פינאַל.טקסט.
אַזוי, אויב מיר עפענען אַרויף פינאַל.טקסט, מיר האָבן פּונקט וואָס מיר זענען
קוקן פֿאַר:
אַ רשימה פון יינציק נעמען אין אַלפאַבעטיקאַל סדר,
געהאלפן צו אַ טעקסט טעקע.
דורך די וועג, מיר אויך קען האָבן געזאגט סאָרט <
סטודענצ.טקסט | וניק> פינאַל.טקסט צו טאָן פּונקט
די זעלבע זאַך, ניצן יעדער פון די אָפּערייטערז מיר ווע געזען אין
דעם ווידעא.
>> מייַן נאָמען איז טאַמי, און דאָס איז קס50.