[Powered by Google Translate] ટોમી: આ વિડિઓ, અમે વિશે જાણવા મળશે
પુનઃદિશામાન અને પાઈપો.
અત્યાર સુધી, અમે વિધેયો નો ઉપયોગ કરી જેમ printf
ટર્મિનલ પર આઉટપુટ માહિતી અને GetString જેવા કાર્યો
વપરાશકર્તા ઇનપુટ અમારી પૂરી પાડવા માટે પરવાનગી આપે છે
કીબોર્ડ મદદથી કાર્યક્રમ.
ચાલો ઝડપથી કાર્યક્રમ છે કે જે એક લીટી નોંધાયો પર એક નજર
વપરાશકર્તા તરફથી ઇનપુટ અને પછી તેને આઉટપુટો.
>> 7 વાક્ય પર, અમે એક શબ્દમાળા માટે વપરાશકર્તાને પૂછવાની કરી રહ્યાં છો, અને
પછી 8 વાક્ય પર, અમે તેને છાપી રહ્યાં છો તે નહીં.
ચાલો કમ્પાઇલ અને અમારો કાર્યક્રમ ચલાવો.
સરસ.
શબ્દમાળા અમે પૂરી પાડવામાં પાછળ દેખાતો હતી
અમને ટર્મિનલ પર.
આ થયું કારણ કે printf કાર્ય કરવા માટે એક લખ્યું હતું
સ્ટ્રીમ પ્રમાણભૂત આઉટ કહેવાય છે, અથવા-s ટી ડી આઉટ.
જ્યારે કંઈક stdout પર લખાયેલ છે, તે મૂળભૂત રીતે છે
ટર્મિનલ દ્વારા દર્શાવવામાં આવે છે.
>> જેથી તમામ સારી અને સારી છે, પરંતુ શું છે જો, તેના બદલે માત્ર એક
શબ્દમાળા પ્રદર્શિત, અમે તેને ફાઇલમાં સંગ્રહો માગે છે?
ઉદાહરણ તરીકે, અમે યાદ શકો છો ચોકકસ શું અમારી
કાર્યક્રમ હતી ત્યારે અમે તેને ચોક્કસ ઇનપુટ આપ્યા પછી.
એક અભિગમ અમારી સી કાર્યક્રમ આ કરવા માટે, ઉપયોગ કરીને હશે
ફાઇલો લખવા માટે અમુક ખાસ કાર્યો અમે કરીશું કે
બીજી વિડિઓ જુઓ.
સરળ પણ છે, જોકે, કોઈક હશે
ફાઇલ માટે stdout પર પુનઃદિશામાન કરે છે.
આ રીતે, જ્યારે printf stdout પર લખે છે, સમાવિષ્ટો કરશે
શકાય ફાઈલ બદલે તેવા પરચૂરણ ખર્ચ
ટર્મિનલ દ્વારા દર્શાવવામાં આવે છે.
અમે વધુ-કરતાં સાઇન ઉમેરીને હમણાં જ આ કરી શકે અનુસર્યું હોય,
ફાઇલ નામ દ્વારા, આ આદેશ માટે અમે અમારી કાર્યક્રમ ચલાવવા ઉપયોગ કરે છે.
>> તેથી, બદલે માત્ર ચલાવવા. / પુનઃદિશામાન થયેલ છે, અમે કરી શકો છો
ચલાવો. / પુનઃદિશામાન થયેલ છે, સાઇન કરતા વધારે અનુસરતા, અનુસરતી
file.txt જેવા ફાઈલનામ.
માતાનો જુઓ શું થાય દો.
ઠીક.
નોંધ કરો કે આ વખતે કશું ટર્મિનલ પર દર્શાવવામાં આવી હતી,
પરંતુ અમે અમારી સમાવિષ્ટો નથી ફેરફાર છે
બધા અંતે સી કાર્યક્રમ.
ચાલો હવે ls સાથે આ ડિરેક્ટરીના સમાવિષ્ટો પરીક્ષણ કરો.
>> અધિકાર છે.
હવે અમે અમારા ડિરેક્ટરીમાં એક નવી ફાઇલ file.txt કહેવાય છે,
જે ફાઈલ નામ અમે પાડેલ જ્યારે અમે અમારી ચાલી હતી છે
કાર્યક્રમ પુનઃદિશામાન કરે છે.
ચાલો અપ file.txt ખોલો.
અને અહીં, અમે જોઈ શકો છો કે પુનઃદિશામાન ના stdout પર આઉટ થયો
આ file.txt તરીકે ઓળખાતી ફાઈલ લખાયેલ છે.
તેથી આપણે અગાઉના આદેશ ફરીથી ચલાવો, પરંતુ પુરવઠો
વિવિધ ઇનપુટ આ સમય.
ઠીક છે.
ચાલો file.txt પર એક નજર હવે લો.
>> અમે અહીં જુઓ કે ફાઈલ ફરીથી લખાઈ કરવામાં આવી છે જેથી, અમારા
મૂળ ઇનપુટ ત્યાં હવે નથી.
જો આપણે તેને બદલે આ ફાઇલ ઉમેરો કરવા માંગો છો, નવા મૂકવા
ફાઇલ હાલના વિષયવસ્તુ નીચે ઈનપુટ કરવા માટે, અમે આ કરી શકો છો
બે મોટી કરતા ચિહ્નો જગ્યાએ વાપરવું માત્ર એક છે.
ચાલો કે પ્રયાસ કરો.
હવે, જો આપણે file.txt ફરીથી ખોલવા માટે, અમે અમારા બંને જોઈ શકો છો
ઈનપુટ લીટીઓ.
કેટલાક કિસ્સાઓમાં, અમે કોઇપણ કાઢી શકો છો
અમારા કાર્યક્રમ આઉટપુટ.
તેના બદલે એક ફાઈલમાં આઉટપુટ લેખન અને પછી કાઢી નાંખવા કરતાં
ફાઇલ ત્યારે અમે તેને પૂર્ણ કરી લીધું છે, તો અમે એક ખાસ લખી શકો છો
ફાઈલ / dev / null માં કહેવાય છે.
જ્યારે કંઈપણ / લખાયેલ છે dev/null--
અથવા માત્ર ટૂંકા માટે devnull -
તે આપોઆપ નાંખવામાં આવે છે.
તેથી તમારા ડેટા માટેની એક બ્લેક હોલ તરીકે devnull લાગે છે.
>> તેથી હવે અમે જોઈ કેવી રીતે કરતા વધારે સાઇન પુનઃદિશામાન કરી શકો છો
stdout પર, ચાલો જોવા અમે કેવી રીતે પ્રમાણભૂત પુનઃદિશામાન કરી શકો છો -
અથવા-s ટી ડી - ઇન
stdout પર ના એનાલોગ.
જ્યારે કાર્યો કરવા માંગો printf કહેવાય સ્ટ્રીમ લખવા માટે
stdout પર GetString, અને સમાન વિધેયો સ્ટ્રીમ વાંચવામાં
stdin ની કહેવાય છે, જે મૂળભૂત રીતે, ના પ્રવાહ હોય છે
અક્ષરો કીબોર્ડ પર ટાઇપ.
અમે સાઇન કરતાં ઓછા મદદથી stdin ની પુનઃદિશામાન કરી શકો છો અનુસર્યું હોય,
ફાઇલનામ દ્વારા.
હવે, કરતા અંતે ઇનપુટ માટે વપરાશકર્તાને પૂછવાની
ટર્મિનલ, એક કાર્યક્રમ ફાઇલ ખોલવા અમે સ્પષ્ટ કરશે અને ઉપયોગ
ઇનપુટ તેની રેખાઓ.
>> માતાનો જુઓ શું થાય દો.
સરસ.
File.txt પ્રથમ વાક્ય ટર્મિનલ કરવામાં મુદ્રિત છે
કારણ કે અમે એક વાર GetString કૉલ કરી રહ્યાં છો.
જો અમે અમારી પ્રોગ્રામ માં GetString બીજી કોલ હતા,
file.txt આગામી રેખા તરીકે કરવામાં આવી છે ઉપયોગ કરશે
તે કોલ માટે ઇનપુટ.
ફરીથી, અમે અમારી સી કાર્યક્રમ બધી ન ફેરફાર કર્યા છે.
અમે ફક્ત બદલી રહ્યાં છીએ અમે કેવી રીતે તે ચલાવો.
અને પણ યાદ રાખો કે, અમે stdout પર આ સમય નથી રીડાયરેક્ટ છે,
જેથી કાર્યક્રમ નું આઉટપુટ હજુ પણ
ટર્મિનલ પર દર્શાવવામાં આવે છે.
અમે, અલબત્ત, બંને stdin ની પુનઃદિશામાન કરી શકો છો
આ જેવા stdout અને.
હવે, file2.txt file.txt પ્રથમ લીટી સમાવે છે.
>> તેથી, આ ઓપરેટર્સનો ઉપયોગ, અમે વાંચી અને કરવાનો થયા છો
લખાણ ફાઈલો લખી.
હવે, ચાલો જોવા અમે કેવી રીતે એક કાર્યક્રમ નું આઉટપુટ ઉપયોગ કરી શકો છો
અન્ય કાર્યક્રમ ઇનપુટ.
તેથી અહીં અન્ય સરળ સી કાર્યક્રમ આઈ
અહીં 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 વાંચી છે.
Cat આદેશ માત્ર કે કરશે.
તે સ્પષ્ટ ફાઈલમાં વાંચી અને લખી કરશે
stdout પર તેના સમાવિષ્ટો.
પછી અમે લખાણ ફાઈલ વાંચી લો તે પછી, અમે કરીશું
આ નામો સૉર્ટ કરવા માંગો છો.
આ પ્રકારના આદેશ અમારા માટે આ સંભાળી શકે છે.
સૉર્ટ કરો આ stdin ની મારફતે stdout પર પૂરુ પાડેલ રેખા બનાવવામાં આવશે
ક્રમમાં.
ક્રમમાં 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 છે.