>> [სემინარი - Unix ჭურვი, გარემოში]
[Douglas Kline - ჰარვარდის უნივერსიტეტის]
[ეს არის CS50. - CS50.TV]
>> დღევანდელი თემა არის Unix shell.
მე Douglas Kline, ექსპერტი, ან თუნდაც გონივრული კომპეტენტური შესახებ, რომ ჭურვი.
Shell ინტერფეისი მომხმარებელს კომპიუტერის ოპერაციული სისტემა.
სახელი შეცდომაში შეჰყავს, განსხვავებით ცხოველის shell,
რომელიც რთულია და დამცავი, კომპიუტერული shell საშუალებას კომუნიკაცია.
ასე რომ, ფოროვანი გარსის, ალბათ, უკეთესი მეტაფორა.
>> ორიგინალური შელი Unix არის Bourne shell.
Bourne წერია B-O-U-R-N-E.
Bourne იყო ერთი ორიგინალური ავტორები Unix,
და ასე ჭურვი მის სახელს ატარებს.
სახელით რომ shell როგორც ბრძანება უბრალოდ შ.
, რომ ბრძანება თქვენ შეგიძლიათ შეასრულოს.
Shell იწყება შესვლა.
როდესაც თქვენ შეხვიდე კომპიუტერი, shell მხოლოდ იწყება გაშვებული თქვენ,
და რომ ის, რაც ხდება თქვენს ბრძანებებს.
ეს შეიძლება დაიწყოს სხვა დროს ასევე.
თუ თქვენ ზრდიან ფანჯარა არ არის სხვა მითითება, იგი დაიწყება ჭურვი თქვენთვის.
ასე, რომ ეს არის, რომ თქვენ შეგიძლიათ წასვლა ფანჯარა და დაიწყოს აკრეფით ბრძანებები
და ა.შ. არ არსებობს, მიუხედავად იმისა, რომ თქვენ არ შეხვიდე, რომ ფანჯარა.
გარდა ამისა, თუ შორეულ login,
მაშინ დავიწყოთ shell დისტანციური კომპიუტერი.
და შესაძლებელია, რომ აწარმოებს ბრძანებები გარეშე ინტერაქტიული ჭურვი.
ეს შეიძლება ნიშნავს თქვენს მიმდინარე ოპერაცია,
და ეს ასევე ნიშნავს იმას, დისტანციური ოპერაცია.
თქვენ ვერ გაგზავნას ბრძანება სხვა კომპიუტერზე,
რომელიც მოიცავს დაწყებული ჭურვი არსებობს.
ფაქტობრივად, ეს უნდა შეიცავდეს დაწყებული ჭურვი არსებობს
მაშინაც კი, თუ ეს არ არის თქვენი საბოლოო მიზანი.
როდესაც რაღაც იწყება ასე, ეს სულაც არ დაიწყოს ახალი გარსი.
თუ გამოიტანს ახალ ფანჯარაში, შესაძლებელია ვუთხრა მას ზრდიან რედაქტორი
ან სხვა რაიმე ბრძანება.
იმ შემთხვევაში, რედაქტორი დაიწყება ნულიდან.
როდესაც რედაქტორი დამთავრდა, ფანჯარა დამთავრდა.
ეს არის პატარა უჩვეულო, მაგრამ ეს შეიძლება გაკეთდეს.
იმ შემთხვევაში, ეს არ იქნება ჭურვი.
ასე რომ, ეს არ არის აუცილებელი იმ შემთხვევაში, რომ ფანჯარა ან რამდენიმე ასეთი განაცხადი გამოიტანს ჭურვი.
>> Shell parses ბრძანებები.
დამუშავების ნიშნავს საიდენტიფიკაციო სხვადასხვა ელემენტები და კლასიფიცირების მათ.
ფარგლებში ბრძანება, სრული string რომ თქვენ ტიპის,
იქნება 1 ან მეტი ერთი ბრძანებები შესრულდება.
სხვა ელემენტები შეიძლება არგუმენტები.
არსებობს ასევე შეიძლება სპეციალური სიმბოლოები, რომლებიც გავლენას ახდენენ აღსრულების ბრძანება.
ისინი შეგიძლიათ გააგზავნოთ გამომავალი სადღაც გარდა ეკრანზე
თუ ბრძანება, რომ ჩვეულებრივ გაუგზავნოთ ეკრანზე.
ეს შეიძლება გადამისამართება შეყვანის; მას შეუძლია გააკეთოს სხვა რამ, ასევე.
არსებობს სხვადასხვა სიმბოლოები, გმირები, და სხვ.
Parsing მოიცავს გამოვლენის და წერით იმ რამ.
>> ახლავე თუ არ არსებობს უფრო მეტი შეკითხვა, რომელიც საკმაოდ სავარაუდოა, რადგან არ არსებობს უფრო მეტი ადამიანი,
ჩვენ გავაგრძელებთ ჩემს მომდევნო გვერდზე აქ.
>> ვთქვი ადრე, რომ Bourne shell არის საწყისი ჭურვი.
არსებობს სხვები.
ერთი არის C-shell. ბრძანება csh.
სახელი C-shell არის მხოლოდ თამაში სიტყვები.
ეს ჭურვი იყო გაეცნენ Berkeley Unix შუა რიცხვებში 1970.
Berkeley Unix იყო seminal მოვლენა განვითარების Unix.
ეს იყო დიდი რევოლუცია და შედის დანერგვა ამ ჭურვი.
მიზეზი თამაში სიტყვებით, C-shell,
ის არის, რომ C-shell აქვს გარკვეული თავისებურებები, რაც ჰგავს C ენაზე
რომელიც Bourne shell ამჯამად არ აქვს -
ან მას არ აქვს იმ დროს.
არსებობს ასევე TC-shell.
ეს არის superset C-shell.
მას აქვს დამატებითი ფუნქციები, რომელთა სასარგებლო ინტერაქტიული გამოყენებისათვის,
როგორიცაა გაიხსენა ბრძანებები ისტორიაში მექანიზმი,
რომელიც მე აღწერს გარკვეულწილად შემდეგ -
მარტივი გზით, მოდელირებული შემდეგ რედაქტორი.
მას ასევე აქვს მალსახმობები, რომელიც საშუალებას გაძლევთ სავალდებულოა მოკლე გასაღები სიმებიანი აღარ ბრძანება.
ჩვენ არ ვაპირებთ, რომ იყოს მიღების, რომ დღეს.
მას აქვს გარკვეული ფუნქციები, რომლებიც სასარგებლო პროგრამირების.
თუმცა, C-shell არ არის ხშირად გამოიყენება shell პროგრამირების.
Shell პროგრამები, თუ თქვენ არ იცით,
არის პროგრამა, რომელიც შედგება shell მახასიათებლები.
თქვენ შეიძლება აწარმოებს ეს როგორც პროგრამებს.
წერთ bunch of ჭურვი ბრძანებები შევიდა ფაილი და შეასრულოს ფაილი.
თქვენ არ გჭირდებათ მისი კომპილირება. ეს არის interpretive ენაზე.
ფრაზა C-shell არის ორაზროვანი, რადგან ეს შეიძლება ეხება მხოლოდ ორიგინალური C-shell, csh,
ან ყველა C-ჭურვები, მათ შორის tcsh. ეს ცოტა ბუნდოვანია.
>> მოგვიანებით shell არის Korn shell, ksh სახელობის პროგრამისტი, Korn.
ეს ჭურვი შეეცადა ითვალისწინებდეს 1 ჭურვი
უპირატესობა C-shell ინტერაქტიული გამოყენება
და Bourne shell პროგრამირების.
ეს უკვე გამოიყენება როგორც ინტერაქტიული ჭურვი ზოგიერთი ადამიანი - უმცირესობა.
მოგვიანებით, თუმცა, იყო კიდევ ერთი შესავალი, Bash shell, Bash,
ერთხელ თამაში სიტყვებით, Bourne კვლავ ჭურვი.
ეს არის გაგრძელება Bourne shell. Korn shell ასევე. ორივე მათგანი.
მას აქვს იგივე მიზნები Korn shell of amalgamating C-shell-ს
და Bourne shell-ის უპირატესობა 1 ჭურვი.
ბევრი დამატებები საქართველოს Korn shell ასევე შედის Bash.
Bash, თუმცა, სულ უფრო და ამიტომ სასურველია.
The Bourne კვლავ ჭურვი და Korn shell უწოდებენ Bourne ტიპის ჭურვები
რადგან ისინი მოიცავს Bourne shell-ის მახასიათებლები,
რომელიც შეუთავსებელია გარკვეული თვალსაზრისით დავუკავშირდეთ C-ჭურვები.
არსებობს სხვა ჭურვები გარდა იმ, ზოგიერთი განკუთვნილია შეზღუდული გამოყენების,
იქნებ შემოიფარგლება ზოგიერთი ბრძანებები, იქნებ სპეციალური მიზნებისათვის, ხშირად არ გამოიყენება.
>> Okay. შემდეგი საქონლის აქ.
Bash shell გახდა ასოცირდება სხვადასხვა სახის Linux.
მე არ ვარ დარწმუნებული, თუ ეს სიმართლეა, ყველა ფორმით.
არსებობს ბევრი ფორმები არსებობს და მე არ გამოიყენება მათ ყველა,
მაგრამ ის, რომ მე არ გამოიყენება გახდა ასოცირდება იგი.
ასე რომ, რამდენადაც ვიცი, არ არსებობს არაფერი Bash
რაც რაიმე უფრო თავსებადი Linux
ვიდრე ნებისმიერი სხვა კომბინაცია shell და ოპერაციული სისტემა.
ვფიქრობ, ეს ალბათ მხოლოდ ასახავს მიდრეკილებები, რომ პროგრამისტები.
რომ იგი გახდა უკავშირდება Linux არის კიდევ ერთი მიზეზი, ერჩივნა Bash to ksh
მას შემდეგ, რაც რამ სავარაუდოდ დაწერილი და ეს სავარაუდოდ გავრცელდა.
მე მივცემ თქვენ სხვა მიზეზის გამო, რომ მოგვიანებით.
Bourne shell სკრიპტები უნდა აწარმოებს ქვეშ Korn shell ან Bash.
თუ წერთ რაღაც Bourne shell,
თქვენ ალბათ შეუძლია შეასრულოს ის ფარგლებში ksh ან bash.
Korn shell scripts ალბათ აწარმოებს ქვეშ Bash, მაგრამ მე ვერ მოგცემთ იმის გარანტიას, რომ.
მოგვიანებით აქ, C-shell სკრიპტები უნდა აწარმოებს ქვეშ TC-shell.
C-shell რეალურად არასდროს ფართოდ გამოიყენება სკრიპტირების
მას შემდეგ, რაც Bourne shell და შემდეგ Bourne ტიპის ჭურვები იყო სასურველია ამ მიზნით.
ასე რომ ნამდვილად არ არის, რომ მნიშვნელოვანია.
არსებობს საკმაოდ ბევრი Bourne shell სკრიპტები რომელიც დაიწერა დიდი ხნის წინ,
ადრე Korn shell ან Bourne კვლავ shell გაეცნენ.
იმ დღესაც გამოიყენება, ნაწილი ოპერაციული სისტემები,
და ა.შ. თქვენ ნახავთ მათ თუ გადავხედავთ შევიდა ოპერაციული სისტემა
ან ძველ პროგრამირების პაკეტი.
>> Bash არის გარკვეულწილად გახდეს ერთგვარი ლინგვა franca ოპერაციული სისტემები.
ეს უკვე გავრცელდა Windows და VMS.
VMS, იმ შემთხვევაში თუ თქვენ არ იცით, არის საკუთრების ოპერაციული სისტემა
of Digital Equipment Corporation, რომელიც დღემდე გამოიყენება, ძირითადად კულისებში.
და თუ ეს იქნება გაშვებული სხვადასხვა ოპერაციული სისტემების,
ალბათ ხალხი ტენდენცია გადაეტანა იგი.
მაგრამ ეს განვითარება შედარებით ბოლო.
ეს მხოლოდ დასაწყისია, ასე რომ მე არ შემიძლია პროგნოზირება, თუ ამ აღმოჩნდება მართლაც იყოს, რომ სახის ლინგვა franca.
ასევე, იმის გამო ფაილი pathnames და ბიბლიოთეკები განსხვავდება
შორის სხვადასხვა ოპერაციული სისტემების,
თქვენ შეიძლება ვერ დაწერა Bash script ერთი ოპერაციული სისტემა
და შემდეგ აწარმოებს კიდევ ერთი.
თქვენ უნდა შეეძლოს მისი გადატანა სხვადასხვა Unix, Linux
Mac OS ოპერაციული სისტემების მაგრამ არ არის აუცილებელი Windows ან VMS.
თქვენ შეიძლება უნდა შეიცვალოს ფაილის pathname აღწერით,
და ზოგიერთი ბიბლიოთეკების შეიძლება იყოს სხვადასხვა,
რომელმაც შეიძლება გავლენა მოახდინოს ისე, რომ ზოგიერთი ბრძანებები მუშაობა
ან როგორ გადაამუშავებს არგუმენტები და ასე შემდეგ.
გარდა ამისა, კიდევ ერთი სიფრთხილით აქ ის არის, რომ არ არსებობს არავითარი გარანტია
რომ ყველა სხვადასხვა ჭურვი მე აღნიშნული - Bourne shell, C-shell,
TC-shell, Korn shell, Bourne კვლავ ჭურვი - ხელმისაწვდომი იქნება ნებისმიერი Unix
ან Linux ან Mac OS კომპიუტერი.
ისინი უბრალოდ არ უნდა იყოს იქ.
ეს არის ერთ ერთი გვაფრთხილებს აქ.
ეს სამწუხარო შეზღუდვა აქ წლიდან გსურთ რამ მუშაობა ყველგან,
მაგრამ, სამწუხაროდ, ვერ დაეყრდნონ, რომ.
>> Okay. შემდეგი აქ.
ვთქვათ, რომ გსურთ დაწეროთ shell სკრიპტი,
პროგრამა შედგება ჭურვი ბრძანებები.
წერთ თქვენი ბრძანებები, თნხების ფაილი, და შეასრულოს ფაილი.
რა მოხდება, თუ გსურთ მოიცავს არგუმენტები?
იმ შემთხვევაში, თუ shell ოპერაციების, არგუმენტები უწოდებენ პარამეტრების ან თანამდებობრივი პარამეტრები
და ისინი ყველაფერს რომელსაც დოლარის ნიშანი და ციფრების, $ 1, $ 2.
ასე რომ, თუ სცენარი აქვს ამ სახელს, ჩემი პირველი არგუმენტი შეიძლება იყოს არგუმენტი 1
და მეორე შეიძლება იყოს არგუმენტი, 2,
და შიგნით ჩემი script თუ მინდა ეხება ეს ყველაფერი -
მოდით წაშლას, რადგან მე ნამდვილად არ აპირებს, რომ -
შიგნით ჩემი script მე შეიძლება $ 1 ეხება ARG1,
$ 2, რომელიც გამოვა, რომ გზა, Arg2.
ასე რომ იმ სიმბოლოები ხელმისაწვდომია ეხება არგუმენტები,
და ის ვრცელდება ყველა ჭურვები.
გარდა ამისა, არსებობს სხვა სიმბოლოები.
$ * ეხება მთელი არგუმენტი სიაში, ყველა მათგანი.
$ # ეხება რიგი არგუმენტები.
ისევ და ისევ, ეს ეხება ყველა ჭურვი.
იმ სიმბოლოები, * და #, შეიძლება გამოყენებულ იქნას იმ მნიშვნელობით სხვა ადგილებში, ასევე.
ჩვენ არ იქნება მისაღებად შევიდა, რომ.
>> Shell specifier ონლაინ. რა არის ეს?
ვთქვათ თქვენ წერილობითი სცენარი და ის კონკრეტული shell და გსურთ გაუშვით.
იცით, რა ჭურვი თქვენი ოპერაციული სისტემა გამოიყენებს აწარმოებს თქვენი სცენარი?
ერთ მომენტში თქვენ შეიძლება ვივარაუდოთ, რომ აწარმოებს წლის Bourne shell
თუ არ უთქვამს, წინააღმდეგ შემთხვევაში,
მაგრამ ხალხი არ წერა სკრიპტები Bourne shell, რომ ბევრი აღარ
და თქვენ კი ვერ დაეყრდნონ, რომ აღარ.
ასე რომ აქ გვაქვს ჭურვი specifier ონლაინ უფლება აქ.
რომელიც განსაზღვრავს Bash.
გაითვალისწინეთ, რომ ეს განსაზღვრავს ის pathname, / bin / bash.
თუ კომპიუტერი აქვს Bash shell მაგრამ არა bin დირექტორია, / bin, ეს არ იმუშავებს.
ეს არის კიდევ ერთი შესარჩევ, მეორე სიფრთხილით აქ.
ფუნტი ნიშანი არის კომენტარი ხაზი ხასიათი.
ეს ეხება ყველა ჭურვები.
კონკრეტულ შემთხვევაში აქ, #! დასაწყისში სკრიპტი, განსაკუთრებული შემთხვევაა.
რომ განსაზღვრავს ჭურვი, რომელიც აწარმოებს სცენარი.
როგორც მე ამბობდა, ეს არ უნდა იყოს და იგივე ადგილზე / bin.
გარდა ამისა, არსებობს კიდევ ერთი რამ აქ.
თუ თქვენ უბრალოდ გამოიყენოთ ფუნტი ნიშანი, რომელსაც არ ძახილის წერტილი და pathname,
რომ უნდა მიუთითოს C-shell.
თუმცა, მე არ ვურჩევ აკეთებს, რომ, რადგან მე ვერ გარანტიას
რომ ეს ყოველთვის მუშაობს.
თუ გსურთ C-shell, უკეთესი იქნება იმის თქმა, რომ ასეა.
შემდეგ იქ რაღაც საკმაოდ დამაბნეველი აქ.
თუ თქვენ იყენებთ shell specifier ხაზი როგორიცაა / bin / bash
და რომ ჭურვი არ არის შესაძლებელი იქ,
არ არსებობს ასეთი რამ, როგორც / bin / bash ამ კონკრეტულ კომპიუტერს,
ან იმიტომ, რომ მას არ გააჩნია Bash ან იმიტომ, რომ სხვადასხვა ადგილას,
თქვენ მიიღებთ შეცდომა გეუბნებოდით, რომ სცენარი თქვენ გაიქცა არ არსებობს.
და რა თქმა უნდა თქვენი სცენარი არსებობს, ასე რომ შეცდომა არის დამაბნეველი.
იმ მიზეზით, რომ ოპერაციული სისტემა გაძლევთ, რომ შეცდომა
ან, უფრო ზუსტად, რომ თქვენი ინტერაქტიული გარსი, რომელიც თქვენ გაშვებული ამ იძლევა, რომ შეცდომა,
არის ის, რომ იუწყება ბრძანება თქვენ გამოიყენება, რომელიც არის სახელი სცენარი.
ეს ბრძანება ეფექტურად მოუწოდა shell სახელით სცენარი.
სწორედ იქ, სადაც თქვენ, რომ გაუგებარია შეცდომა.
სხვა გზა მოვუწოდებთ shell სკრიპტი
არის სასურველი shell ბრძანების სტრიქონში, რადგან აქ.
ეს არის ბრძანება. ეს ამბობს აწარმოებს Bash და შემდეგ აწარმოებს ჩემი სცენარი Bash.
რომ მიიღებს უპირატესი specifier ხაზი,
და ეს ფუნქცია, რომელიც საშუალებას იძლევა სხვადასხვა pathnames.
თუ თქვენ უბრალოდ მისცეს ბრძანება, ოპერაციული სისტემის გამოიყურება, რომ ბრძანება
სხვადასხვა ადგილას.
იმ შემთხვევაში, თუ ეს შესაძლებელია, უნდა იპოვოთ იგი.
კომპიუტერული ნახავთ Bash, სადაც ის მდებარეობს და აწარმოებს,
ასე რომ თქვენ არ გჭირდებათ მაშინ უნდა შეშფოთებულია, სადაც მას პოულობს.
არსებობს პოტენციურად სხვა შეშფოთება აქ,
თითქოს იქ უფრო, ვიდრე 1 მობილური Bash, რაც შესაძლებელია, თუმცა ნაკლებად სავარაუდოა.
ასე რომ სხვა გზა გაუმკლავდეთ ეს ყველაფერი.
Specifier ხაზები შეიძლება მოვუწოდებთ ნებისმიერი ჭურვი.
მათ შეუძლიათ ასევე მოვუწოდებთ რამ გარდა ჭურვები.
მაგალითები მაქვს აქ sed, რომელიც ნაკადი რედაქტორი;
awk, რომელიც არის ნიმუში დამუშავების ენა;
და perl, ძალიან მაღალგანვითარებულ სკრიფტინგის ენა.
თუ თქვენ დააყენა specifier ონლაინ მითითებით ერთ იმ პროგრამების დასაწყისში,
ეს წავა პირდაპირ რომ პროგრამა, ვიდრე დაწყებული ჭურვი.
იმ პროგრამებს აქვთ შეზღუდვები მათი შესაძლებლობები.
Perl ძალიან შეუძლია. Sed არის რედაქტორი. მას შეუძლია გააკეთოს ყველაფერი მიღმა უბრალოდ რედაქტირება.
მაგრამ ეს შეიძლება იყოს რთული პროგრამა, რომელიც.
გარდა ამისა, გავლით არგუმენტები და პერსონალის script ან შეუძლებელია ან გაუგებარია.
ასე რომ, იმ შემთხვევაში, awk ან sed, ის მაინც, ჩემი გამოცდილება,
სასურველია დაწერა shell სკრიპტი და ზარის awk ან sed საწყისი shell სკრიპტი
ვიდრე დარეკვით awk ან sed როგორც script specifier ონლაინ.
Perl არის უაღრესად მრავალფეროვანი ენის, როგორც ვთქვი.
შეგიძლიათ არ აწარმოებს ინტერაქტიული ბრძანებები perl,
რაც იმას ნიშნავს, რომ თქვენ არ შეგიძლიათ შეამოწმოთ ნაწილების სკრიპტები, რომ თქვენ განვითარებადი
მიერ გაშვებული მათ ინტერაქტიულად.
თუმცა, ეს უკიდურესად შეუძლია ენაზე
და ჩამოყალიბდა ძალიან ფართოდ გამოიყენება ინსტრუმენტი.
რომ უბრალოდ ცოტა ჩართული შენიშვნა specifier ხაზები.
>> ყველა ან უმეტესი ფორმები Linux - ისევ და ისევ, მე არ შეიძლება იყოს დარწმუნებული, რომ ყველაფერი -
და Mac OS, თუ ჩაწერეთ csh თქვენ მიიღებთ tcsh,
და თუ ჩაწერეთ შ თქვენ გაქვთ bash.
ისინი ცდილობდნენ იქ მოგცემთ უფრო მოწინავე ვერსიებს ეს ჭურვები,
მაგრამ ეს შეიძლება იყოს დამაბნეველი.
თუ წერთ სკრიპტის გამოყენებით tcsh ან Bash მახასიათებლები მოსაუბრისთვის csh ან sh
და შემდეგ ცდილობენ აწარმოებს კომპიუტერი, რომელსაც არ გააჩნია tcsh ან Bash,
თქვენ შეიძლება მიიღოთ გარკვეული შეცდომები, თუ არსებობს ბრძანებები იქ
რომელიც იმ ჭურვი არ აღიარებს.
გარდა ამისა, თქვენ შეიძლება გაწვევა თქვენი ჭურვი თქვენს კომპიუტერში
უწოდა, როგორც sh ან csh და შემდეგ მიღების მოწინავე ჭურვები.
თქვენ შეიძლება არც კი ვფიქრობ, რომ თქვენ იყენებთ უფრო მოწინავე ჭურვი.
ასე რომ, ეს არის პოტენციური pitfall.
როგორ არის ეს დადგენილია, რომ თუ აკრიფოთ შ თქვენ გაქვთ Bash,
თუ აკრიფოთ csh თქვენ მიიღებთ tsch?
არსებობს რამ, ამ კომპიუტერების მოუწოდა ბმულები
რომელიც შეიძლება დაკავშირება სახელები ეხება იგივე.
ეს შეიძლება იყოს 2 სახელები იგივე ფაილი ან ფაილი, რომლის მიზანია ეხება სხვა ფაილი.
ისინი მოუწოდა მძიმე და სიმბოლური ბმულები. ჩვენ არ მიდის, რომ აღარ გააკეთა.
არსებობს ასევე შეიძლება ცალკეული ფაილები - 1 ფაილი sh 1 ფაილი Bash -
მაგრამ ორივე აწარმოებს Bash.
მაშინ არსებობს კიდევ შესარჩევ აქ.
თუ თქვენ მოუწოდებდა ერთი ასეთი ჭურვები ერთი სახელი,
თქვენ ალბათ ფიქრობთ, ნეტავ კიდევ იგივე ფუნქციონალური როგორც უწოდა მეორე სახელი.
ისე, რომ რეალურად არ არის აუცილებლად ჭეშმარიტი.
ეს ბრძანებები შეუძლია შეამოწმოს სახელი, რომლითაც ისინი მოუწოდა
და მათ შეუძლიათ, საფუძველზე, რომ სახელი, მოიქცეს სხვაგვარად.
შეიძლება იყოს საკითხები ცდილობს შეესაბამებოდეს სტანდარტს.
ზოგიერთ თქვენგანს შეიძლება გსმენიათ POSIX სტანდარტული ან სხვა,
იქნებ სხვა.
ეს შეიძლება იყოს არჩეული ზოგჯერ ბრძანების ხაზი არგუმენტები
ან მიიღწევა shell ცვლადები.
უწოდა, როგორც sh ან bash შეიძლება რეალურად გამოიწვიოს სხვადასხვა აღსრულება
მაშინაც კი, თუ ეს იგივე ფაილი, რომელიც თქვენ შესრულებაში.
სხვა რამ განიხილოს ის არის, რომ თუნდაც ერთი კომპიუტერი tcsh ან Bash,
თუ ისინი არ უკავშირდება, რადგან ისინი თქვენს კომპიუტერში
თუ თქვენ გაქვთ Linux ან Mac OS კომპიუტერში,
მერე ისევ თქვენ მიიღებთ shell, რომ თქვენ მოვუწოდებთ sh ან csh, არა ერთი, რომ თქვენ შეიძლება ურჩევნია.
მიმდინარე Bourne shell აქვს გაუმჯობესებებს ნაკლები ვიდრე Bash
მაგრამ წარსული იმ ორიგინალური Bourne shell.
შედეგად, რომ, მიუხედავად არსებული Bourne shell, sh,
მაშინაც კი, როდესაც ეს არ Bash, ჰგავს C ენის მეტია, ვიდრე C-shell აკეთებს.
ეს არ იყო მართალი, როდესაც C-shell პირველად შეიქმნა, მაგრამ მას შეიმუშავა, რომ გზა.
თქვენ ალბათ შეამჩნევთ, რომ ყველა ეს ჭურვი სახელები გარდა Bourne shell
რაღაც მიუთითებს, რომელიც shell ისინი - csh, bash -
მაგრამ Bourne shell მხოლოდ sh.
რატომ? ეს იყო ორიგინალური ჭურვი.
ეს იყო ჭურვი მაშინ, არ ჭურვი,
და რადგან ეს იყო ჭურვი, არ არსებობს მიზეზი განასხვავებს მას სხვა ჭურვი.
ასე რომ, რატომ აქვს, რომ სახელი და ჯერ კიდევ.
>> ეს ყველაზე აქ ხაზი დაგავიწყდათ მონაცემთა ბაზაში ანგარიში მაქვს არის
კიდევ ერთი კომპიუტერი.
მე ვაპირებ ცდილობენ, რომ სახელი ასე რომ თქვენ ხედავთ, რომ ნაწილი დასასრულს, ჭურვი.
დაგავიწყდათ ბაზაში ფლობს შესვლა მახასიათებლები ყველა მომხმარებლებს.
დასაწყისში არის სახელი, რომელიც შეგიძლიათ ნახოთ ბოლო 2 ასო ნაღმი არის.
სფეროებში აქ გამოყოფილია colons.
ბოლო სფეროში, როგორც ხედავთ, არის bin / tcsh, ჭურვი.
ეს არის ის, shell specifier.
არსებობს რაღაც საინტერესო აქ.
როდესაც Unix პირველად შემუშავდა, იქ იყო მხოლოდ 1 ჭურვი,
ასე არ იყო არჩევანი არსებობს.
ასე რომ, რატომ დაუშვებს სფეროში დაგავიწყდათ ბაზაში მიუთითოთ shell?
მე არ ვიცი, მაგრამ გაგვიმართლა, რომ გააკეთეს.
ეს საკმაოდ რთული ცვლილებების შეტანა დაგავიწყდათ მონაცემთა ბაზის ფორმატში
იმიტომ, რომ ბევრი პროგრამების ეხება ფორმატი
და უნდა იყოს გადაწერილი.
ის felicitous ან fortuitous განვითარებას, მათ შორის ამ სფეროში.
ასეთი სახის დაგავიწყდათ ფაილი ხაზის გამოიყენება ყველა Unix და Linux კომპიუტერები იმდენად, რამდენადაც მე ვიცი.
Mac აქვს საკუთარი სისტემა.
იგი რეალურად აქვს პაროლით ფაილი ხაზები, რომ ფორმატი,
მაგრამ ეს არ არის, სადაც მომხმარებელს მახასიათებლები განისაზღვრა.
სხვა ჩართული შენიშვნა არსებობს.
>> თუ თქვენ მოუწოდებდა shell, შეგიძლიათ დარეკოთ, როგორც sub-shell თქვენი არსებული ჭურვები.
ასე რომ, თუ მე აქ, მოდით დავაღწიოთ ეს ყველაფერი.
აქ ვარ C-shell.
რომ ცვლადი, რომელიც ზუსტად განსაზღვრავს ჩემი shell,
რეალურად ყოველთვის არ არის საიმედო გზა განსაზღვრის რა ჭურვი თქვენ გაშვებული,
მაგრამ ამ შემთხვევაში ეს არის.
რა მოხდება, თუ მხოლოდ ჩაწერეთ -
ახლა მე Bash.
ზოგიერთი რამ იქნება იგივე. ls მეუბნება ჩემი ბრძანებები.
თუ მე შეჩერება თავში ჩემი C-shell, ls, იგივე. უფლება?
fg, წინა პლანზე, უკან ჩემი Bash ჭურვი.
შეზღუდული შესაძლებლობის მქონე პირთა, მიმდინარე დირექტორია, უკან C-shell.
შეზღუდული შესაძლებლობის მქონე პირთა, სხვადასხვა დირექტორია - რეალურად არ განსხვავდება დირექტორია ამ შემთხვევაში.
ეს იგივე დირექტორიაში.
ვთქვათ, მინდა მოვუწოდო ბრძანება აქ: სადაც ls.
რას აკეთებთ?
ის მეუბნება, სადაც ls ბრძანება,
ერთი, რომ მაძლევს დირექტორია ჩამონათვალი, მდებარეობს ls.
მოდით დავუბრუნდეთ Bash ჭურვი. მოდით ცდილობენ იგივე.
Hmm, საინტერესო იქ, სადაც: ბრძანება არ არის ნაპოვნი.
რატომ არის, რომ?
სადაც ბრძანება აგებული, რომ C-shell.
ეს არ არის ბრძანება, რომელიც უნდა წაიკითხო, მეხსიერების სხვაგან და დასაჯეს.
C-shell გადის ის გადაცემის აღსრულება ნაწილი საკუთარი კოდი
და ეს არ არის Bash ჭურვი.
ასე რომ, Bash, არ ასეთი ჩაშენებული ბრძანება, ჩანს, რომ ეს არ ის,
და მივიღებთ შეცდომა.
ასე რომ არ გვაქვს Bash shell გაშვებული ქვეშ C-shell, და მოვუწოდებთ, რომ sub-shell.
და მხოლოდ იმ შემთხვევაში თუ თქვენ საინტერესო, Bash ჭურვი აქვს თავისი გზა განთავსებით ბრძანებები.
hashed შეეხება იმ ფაქტს, რომ ეს შეიძლება განხორციელდეს უფრო სწრაფად,
მიმდინარეობს ნაპოვნი უფრო სწრაფად.
ეს არის ერთ ერთი გაუმჯობესებებს აშენდა ზოგიერთი ჭურვები.
>> Bourne ტიპის ჭურვები ამჯობინა პროგრამირების.
მათ აქვთ კონტროლის სტრუქტურები, როგორიცაა მარყუჟების, პირობითი განცხადებები,
სახის ბრძანებები, რომ თქვენ შეიძლება გამოიყენოთ პროგრამირების ენებს, როგორიცაა C
ან რასაც ენაზე. იქნებ თქვენ პროგრამირების ჯავის ან რასაც.
ჭურვი აქვს იმ ძალიან.
The Bourne ტიპის ჭურვები, კერძოდ, Bash, უფრო მეტი
და ისინი განკუთვნილია დიდი მოქნილობა.
Bash ჭურვი აქვს მასივები. ორიგინალური Bourne shell არ.
ასე რომ, შეიძლება მნიშვნელოვნად მომგებიანი პროგრამირების.
C-shell რეალურად აქვს კოლექტორები, მაგრამ არ აქვს ბევრი ეს სხვა ფუნქციები.
The Bourne ტიპის ჭურვები განახორციელებს სწრაფად
იმ შემთხვევაში, თუ მათ არა აქვთ თვისებები განკუთვნილია ინტერაქტიული გამოყენება.
თქვენ ჩატვირთვა რამ ქვემოთ ერთი მიზანი, ეს ტვირთავს მათ ქვემოთ სხვა მიზნით.
იქ რომ ვაჭრობის საგანი არ არსებობს.
ის თვისებები რომლებიც განკუთვნილია ინტერაქტიული გამოყენება
ნამდვილად არის მცირე ან არ გამოყენების სკრიპტირების.
შესაძლებელია გამოიყენოთ ინტერაქტიული sub-shell, ისევე, როგორც ერთი, დავიწყე იქ
შესამოწმებლად out ბრძანებები, რომლის გამოყენება გსურთ ამ სკრიპტის.
რომ ის, რაც თქვენ ვერ ერთად perl. თქვენ შეგიძლიათ ეს გააკეთოთ ერთად ჭურვები.
კი სტრუქტურები, როგორიცაა მარყუჟების და ა.შ. შეიძლება აწარმოებს ინტერაქტიულად.
ისინი ზოგჯერ სასარგებლოა აწარმოებს ინტერაქტიულად,
მაგრამ უფრო სავარაუდოა, თქვენ იყენებთ მათ უნდა განვითარდეს სცენარი.
>> მაგალითი.
ეს იქნება დაახლოებით C-shell.
ისტორია მექანიზმი, სადაც თქვენ დავუბრუნდეთ ადრე ბრძანებები
ან ნაწილები, რომ თქვენ უკვე აწარმოებს.
ერთხელ, დაახლოებით C-shell, Bourne shell და Korn shell აქვს ეს ყველაფერი,
მაგრამ მე არ ვაპირებ მისაღებად შევიდა მათ.
ასე რომ, აქ არის რამოდენიმე სასარგებლო მაგალითი, რომ მაქვს.
ნაცვლად აკრეფით ls - ის საერთო ბრძანება -
მხოლოდ ჩაწერეთ ლ და გადარჩენა თავის 1 სიმბოლოს.
ls სხვადასხვა ფუნქციები, ყველა იმ სამუშაოს.
გაითვალისწინეთ, რომ იმ განმარტებები აქვს quotes მათ გარშემო.
ამ შემთხვევაში, შეთავაზებები საჭირო არ არის.
თუ თქვენ შეგიძლიათ განსაზღვროს ის მაგალითი გარეშე შეთავაზებები, ის მაინც იმუშავებს.
ისინი რეკომენდირებულია.
არსებობს სიტუაციები, რომელშიც თქვენ შეგიძლიათ არ გამოიყენოთ გაცემა
იმისთვის, რომ გინდათ რაღაც უნდა მოხდეს, რომლის გაცემა ხელს შეუშლის.
ზოგჯერ შეგიძლიათ ციტირებით ნაწილი განმარტება, მაგრამ არა ყველა ეს.
ის ასევე ზოგადად რეკომენდირებულია გამოიყენოთ ერთჯერადი შეთავაზებები, ვიდრე ორმაგი შეთავაზებები.
ორმაგი შეთავაზებები აქვს ეფექტი ცვლადი განმარტებები,
განსაკუთრებით რამაც მათ უნდა შეფასდეს, ვიდრე შეჩერების იგი.
რატომ გვინდა, რომ შეწყვიტოს შეფასების?
და როგორ შეთავაზებები გავაკეთოთ, რომ ჩვენთვის?
>> აქ არის ბრძანება, რომელიც თქვენ შეიძლება საინტერესო.
"Ls g *
g *, როგორც თქვენ ალბათ იცით, არის wildcard გამოხატვის
ყველა სახელები დაწყებული გ.
თუ უბრალოდ დაწერე ბრძანება ls g *, მე კიდევ სიაში ყველა იმ სახელების ჩემი მიმდინარე დირექტორიაში.
თუ მე განმარტავენ, რომ იგივე, როგორც ეს აქ quotes,
იგი აწარმოებს, რომ ბრძანება თქვენი მიმდინარე დირექტორია, სადაც თქვენ გაშვებული ეს.
მაგრამ თუ თქვენ აწარმოებს იგივე განმარტება გარეშე quotes,
ის შეაფასებს wildcard g * როდესაც ის გადის ამ განმსაზღვრელი ბრძანება.
ასე რომ, განმარტება alias იქნება ls მოჰყვა სიაში ფაილი დირექტორია
რომელშიც alias ბრძანება შესრულებული,
მიუხედავად იმისა, სადაც თქვენ რეალურად აპირებს აწარმოებს ბრძანება.
ეს არ არის დიდი გამოყენება, და ერთჯერადი შეთავაზებები ასაცილებლად შეფასება ვარსკვლავი.
ასე, რომ თქვენ უბრალოდ განმარტება ყოფნა ls g *.
მაშინ, როდესაც თქვენ აწარმოებს alias, LGS, მაშინ აყენებს, რომ.
ახლა არ არის ციტატებით, და ის შეაფასებს ვარსკვლავი როდესაც თქვენ აწარმოებს alias ბრძანება.
ასე რომ ერთი რამ.
ორმაგი შეთავაზებები ექნება, რომ იგივე ეფექტი აქ,
მაგრამ არსებობს სხვა საქმე, რომელშიც ორმაგ ბრჭყალებში არ იმუშავებს ასე კარგად.
>> აქ არის კიდევ ერთი.
მოგეხსენებათ, grep ბრძანება.
Grep ბრძანება შეიძლება გამოყენებულ იქნას სკანირების ფაილის ხაზების რომელიც გარკვეული სიმები.
მოდით წავიდეთ აქ და მე გასვლა, ჩემი Bourne shell.
Okay. აი ფაილი.
ვთქვათ ეს grep abc strings. არსებობს ეს.
თუ გავაკეთო grep zddd, მივიღებ არაფერი. Okay.
ასე რომ, იგი აღმოაჩენს სიმებიანი, ის იუწყება, ეს არ იპოვოს, ეს არ ანგარიშს იგი.
ეს შედეგები ნებისმიერი ხაზი, რომელსაც აქვს რომ სიმებიანი იგი.
არსებობს ყველა სახის ვარიანტები აქ რომელიც შეგიძლიათ დოკუმენტაცია.
აი ერთი გზა ამის გაკეთება.
რა შეიძლება ითქვას ამ ერთი, იგივე grabc "grep abc '?
რომ აპირებს შედის 1 არგუმენტი, როდესაც იგივე არ არის დადგენილი.
ასე რომ, თუ მე რომ აქ, ახლა, თუ grabc,
ახლა alias ზე მეტი მარტივი ბრძანება. მას ასევე აქვს არგუმენტი.
აქამდე, რომ მუშაობს.
მაქვს კიდევ ერთი ბრძანება, აქ, ამ ერთი, ისე იმ სხვადასხვა strings იქ
და დავანახოთ, რომ ეს არ არაფერი არ არსებობს, რადგან ეს არ შეესაბამება.
>> რა თუ მინდა მოიცავს alias განმარტება ფაილი, რომ მე ვაპირებ ძიება
და მე მინდა, როგორც არგუმენტი alias სიმებიანი რომ მე ეძებს?
მე შეიძლება მინდა ვთქვა abc როგორც არგუმენტი ჩემს alias,
მაგრამ ალიასი უკვე განსაზღვრული ფაილი.
და რომ სადაც ეს გამოთქმა მოდის შემოსული
ყურადღება მიაქციეთ, რომ აქ გვაქვს grep, ისევე, როგორც ადრე.
ჩვენ ფაილი აქ, სიმები.
\! ^, სახის უცნაური გამოხატვის, მე ვფიქრობ, თუ თქვენ არ მინახავს ადრე.
ძახილის წერტილი არის ნაწილი C-shell history მექანიზმი.
ეს შეიძლება გავიხსენოთ ადრე ბრძანებები, შეიძლება გავიხსენოთ არგუმენტები იმ ბრძანებები და სხვ.
ისტორია მექანიზმი გამოყენებული, როგორც ნაწილი aliasing.
იმ შემთხვევაში, თუ, თქვენ შეიტანეთ ხაზი შემდეგ ძახილის წერტილი, ეს ეხება, რომ ხაზი ისტორიაში სიაში,
რომელიც ჩვენ არ იქნება მისაღებად შევიდა ახლა, რადგან ეს მთელი სხვა თემაზე.
არ არის გამორიცხული, მიუთითოთ ნაწილი ხაზი.
ასე რომ, 3:2 იქნებოდა მეორე არგუმენტი ბრძანების ნომერი 3.
Caret აქ ამ გამოხატვის დგას პირველი არგუმენტი.
თუ თქვენ არ აძლევს მას მითითებით რომელიც ბრძანება თქვენ გულისხმობდა,
ეს ეხება დაუყოვნებლივ წინა ბრძანება,
და caret არის სიმბოლო პირველი არგუმენტი.
რადგან ეს caret და არა რაოდენობის, თქვენ არ უნდა გამოვიყენოთ მძიმე,
ასე! ^ იმას ნიშნავს, პირველი არგუმენტი წინა ბრძანება.
ცოტა აირია აქ.
ამ შემთხვევაში, როდესაც თქვენ გამოიყენოს ეს, როგორც ალიასი განმარტება,
ისტორია ბმული დაბრუნება ბრძანებები რომელშიც alias გამოიყენება.
ასე რომ, ეს ხდება უკან 1 ბრძანება, როგორც history ოპერაცია,
მაგრამ როგორც იგივე ოპერაცია ეს ეხება ბრძანება, რომელიც თქვენ ტიპის,
ამბობენ, grstrings_file.
ჩვენ გვაქვს შეთავაზებები აქ იგი. რა backslash ამისთვის?
ამ შემთხვევაში, როგორც სხვაგან, ჩვენ არ გვინდა, რათა შესრულდეს history მექანიზმი
ხოლო განსაზღვრის alias.
თუ ჩვენ არ გვაქვს backslash იქ, shell, რომ გაიყვანოს პირველი არგუმენტი
ბრძანება უფლება სანამ იგი გაიქცა ამ alias ბრძანება, რომელიც ჩვენ არ გვინდა.
ჩვენ გვინდა, რომ ეს უნდა იყოს აგებული, რომ იგივე ბრძანება მოვუწოდებთ არგუმენტი მოგვიანებით.
ერთჯერადი შეთავაზებები არ გაქცევა ძახილის წერტილი, ისტორია მითითება.
ალბათ იცით გამოთქმა გაქცევის ნიშნავს შეცვლის მნიშვნელობა რამე.
ამ შემთხვევაში, ეს იმას ნიშნავს, რომ შეწყვიტოს რაღაც აქვს განსაკუთრებული მნიშვნელობა.
ძახილის წერტილი სპეციალური მნიშვნელობა ისტორიაში.
გაქცევა და მას არ აქვს, რომ მნიშვნელობა.
შეთავაზებები არ გაგვაჩნია; backslash აკეთებს.
ასე რომ ჩვენ რეალურად გამოყენებით 2 დონეზე აფარებს აქ.
მე ვაპირებ გადაადგილება ამ ბრძანების შევიდა სხვა window გარეშე აკრეფით ის
გამოყენებით ამ რედაქტირების ოპერაციების, რომელიც თქვენ შეიძლება აღმოაჩინოთ სასარგებლო.
რაღაც აქ მე გაჩვენებთ.
თუ თქვენ უბრალოდ აკრიფოთ მომხმარებლის ალიასი, და არც არგუმენტები, ეს გიჩვენებთ ყველა თქვენი არგუმენტები.
ეს არის bunch of მაგალითი მე უკვე აქ
გარდა ამისა, ის, რომ მე არ იყენებს დღეს აქ.
მაგრამ თუ მე აკრიფოთ სახელით alias, ის მეუბნება, რას ნიშნავს.
გაითვალისწინეთ, რომ quotes წავიდა და backslash გაქრა.
ეს კონტექსტი აქ არის შედეგი, რომ იგივე განმარტება,
და ახლა ეს უბრალოდ, ^ მას.
ეს აპირებს გამოიყურებოდეს ფაილი strings არაფერი.
ასე რომ, თუ grstrings_file სიმები, მე არ მისცეს მას არაფერი უნდა ვეძებოთ იქ,
მაგრამ ეძებს strings.
ეს არ იპოვოს სიტყვა strings ფაილი strings, მაგრამ ეს იმას იპოვოს abc.
და ეს არ იპოვოს, რომ.
ასე რომ, აქ ჩვენ ვაძლევთ არგუმენტი, რომ ჰიტები შევიდა განმარტება alias,
რომ არის ჩასმული შევიდა იგი.
ეს არის, სადაც ეს გამოთქმა მომდინარეობს.
თქვენ შეგიძლიათ გამოიყენოთ მეტი 1.
Caret არის სიმბოლო პირველი არგუმენტი.
თუ უნდოდა გამოიყენოს მეორე არგუმენტი, თქვენ მაშინ ამბობენ: 2.
არ არსებობს სპეციალური სიმბოლო მეორე არგუმენტი.
და რადგან თქვენ იყენებთ ციფრების, თქვენ უნდა გამოიყენოთ მსხვილი ნაწლავის.
არსებობს, თუმცა, სხვა არჩევანი აქ.
დოლარის ნიშანი დგას ბოლო არგუმენტი.
და იმიტომ, რომ ეს არის სიმბოლო, შეგიძლიათ გამომრჩეს მსხვილი ნაწლავის.
ასე რომ, ეს იქნება ბოლო არგუმენტი სიაში.
და იქ ასევე, რომ ერთი.
Asterisk ნიშნავს ყველა, ასე რომ ეს არის სრული არგუმენტი სიაში,
და ისევ, შეგიძლიათ გამომრჩეს colon იმიტომ, რომ ეს არ არის ციფრების.
იმედი მაქვს, რომ თქვენ ყველა აკვირდება ყველა ამ.
>> ისტორია მექანიზმი დაბრუნდეს ადრე ხაზები ისტორიაში სიაში.
თქვენ შეიძლება ამის გაკეთება იგივე განმარტება.
მე მინახავს ამ გაკეთდეს.
ეს იქნებოდა ეფექტი ზოლიდან ადრე ბრძანებები ისტორიის სია
როდესაც თქვენ შეასრულოს იგივე, რაც შეიძლება სხვადასხვა ბრძანებები
დამოკიდებულია, როდესაც და სადაც თქვენ შეასრულოს ის.
ცხადია დაგვჭირდება გაიყვანოს ასეთი მითითება
უბრალოდ ვიცი, რა ადრე ბრძანება იყო.
მე მინახავს ეს მოხდეს.
მე ვფიქრობ, ვინმე დაგვჭირდება, მაგრამ ეს არის ძალიან საეჭვოა.
არსებობს კიდევ ერთი რამ აქ.
თუ თქვენ იყენებთ, რომ ისტორია ტიპის მინიშნება,
მაშინ მხოლოდ არგუმენტები, რომელიც არსებობს ასეთი მინიშნება გამოიყენება.
თუ თქვენ გაქვთ იგივე განმარტება, რომელიც არ იყენებს history ტიპის მინიშნება,
თუ ეს უბრალოდ ხდება დასაწყისში ბრძანება
და თქვენ კიდევ არგუმენტები, მაშინ არაფერს, აკრიფოთ მას შემდეგ, რაც
დაემატება ბრძანება.
ამ შემთხვევაში, მაგალითად, მე უბრალოდ მისცა იქ, ჩვენ პირველი არგუმენტი;
ჩვენ არ გამოიყენოს ნებისმიერი სხვები.
იმ შემთხვევაში, თუ სხვა არგუმენტები მიეცა ბრძანების სტრიქონში, ისინი არ უნდა იქნას გამოყენებული.
ასე რომ, თუ თქვენ იყენებთ history მინიშნება ყველა, მაშინ თქვენ უნდა გამოვიყენოთ რომ მიიღოს ნებისმიერი არგუმენტი.
>> არსებობს კიდევ ერთი რამ აქ მინდა აღვნიშნო, ნაწილობრივ parenthetically,
კერძოდ, რომ ამ ისტორიის მექანიზმი ძახილის წერტილი
მიდის უკან ორიგინალური C-shell.
Tcsh გააცნო history ოპერაციების
რომლებიც იყენებენ სახის ბრძანებები და strings საწყისი რედაქტორები,
ან Emacs ან vi.
ჩემი პირადი აზრი Emacs ბევრად უფრო ადვილია გამოყენება ამ მიზნით
მაშინაც კი, თუ თქვენ იყენებთ vi თქვენი რეგულარული რედაქტირება.
არსებობს სხვადასხვა Emacs ბრძანებები რომლებიც ახლა ადაპტირებული ისტორია.
კონტროლის P იღებს წინა ხაზზე ისტორიაში სიაში.
სხვა Control P მიიღებს თქვენ ერთი მანამდე.
ისარი აკეთებს იმავეს.
კონტროლის N იღებს მომდევნო ბრძანება თუ თქვენ უკვე scrolled უკან გარკვეულწილად.
Down arrow აკეთებს, რომ ძალიან.
თქვენ შეგიძლიათ გადაადგილება მარცხნიდან მარჯვნივ ერთად ისრებით და მრავალი სხვა რამ.
ეს შეიძლება გამოიყენონ ისტორიაში მექანიზმი
ბევრად უფრო ადვილია, ვიდრე გამოყენებით ძახილის წერტილი სინტაქსი,
მაგრამ თქვენ არ გამოიყენებს, რომ იგივე განმარტება.
ჩვენ წავიდეთ მეტი რომ სხვა დროს.
>> ცვლადები.
თქვენ იცით, რა ცვლადები პროგრამირების ენები.
ჭურვები მათ ასევე.
C-shell იყენებს ბრძანება მითითებული დაავალოს ცვლადები,
ასე რომ ადგენს ცვლადი ღირებულების ბ -
როგორც ვთქვი, აზრი არა აქვს განმარტება, მაგრამ ილუსტრაცია როგორ ეს გამოიყენება.
კომპლექტი ბრძანება შექმნათ ცვლადი, თუ ის არ არსებობს.
პოზიციური პარამეტრების ჭურვი სკრიპტები შეიძლება ჩაითვალოს ცვლადები,
მაგრამ გამოყენების მათ და წესების მათგანი განსხვავებული.
თქვენ არ შეგიძლიათ დაავალოს ღირებულება $ 1 რა თქმა უნდა, სცენარი.
თქვენ უნდა განსაზღვროს ახალი ცვლადი ამ მიზნით, თუ ზოგიერთი თქვენ სურდა.
ჩაწერეთ მითითებული არანაირი არგუმენტი და თქვენ მიიღებთ სია ყველა გაკეთებული განსაზღვრული ცვლადები.
და მოდით კიდევ მეტი ჩემი სხვა shell აქ და ვნახოთ რა მივიღებთ, თუ ჩვენ გაგვაჩნია.
საკმაოდ გრძელი სია არსებობს, არა?
Scroll up ცოტა. შეხედეთ ყველა, რომ.
ზოგიერთი რამ განისაზღვრება ავტომატურად ჭურვი.
ჭურვი ქმნის ცვლადი და აძლევს ღირებულებით.
ზოგიერთი მათგანი განისაზღვრება shell მაგრამ შემდეგ შეცვალა მომხმარებლის მიერ
მისი პრეფერენციები.
და ზოგიერთი მათგანი შექმნილი შესახებ დამოკიდებულია იმაზე, თუ ის აკეთებს, რომ დღეს.
ეს მხოლოდ მითითებული არანაირი არგუმენტი.
არსებობს უცნაური თვისება აქ ამ რამ.
იქ უნდა იყოს ან არ ფართების შორის ტოლობის ნიშანი და ცვლადის სახელი
და ღირებულება ან ფართები ორივე მხარეს ტოლობის ნიშანი,
როგორც ეს ერთი.
ეს არ იმუშავებს, და ეს რეალურად არის სწორი ბრძანება
მაგრამ ის ამას არ გააკეთებს რას აპირებენ.
ეს ბრძანება იმუშავებს, რადგან თუ თქვენ უბრალოდ ამბობენ მითითებული და ცვლადის სახელი
ერთად არ ტოლობის ნიშნის ან და ცვლადი სახელი ტოლობის ნიშანი და არ ღირებულება,
ეს იქნება მითითებული ცვლადი null ღირებულება.
ასე რომ მითითებული = არის სწორი ბრძანება.
კომპლექტი ბრძანება შეიძლება განისაზღვროს არაუმეტეს 1 ცვლადი იმავე ხაზის.
ასე რომ, ამ ბრძანების აქ აქვს ეფექტი განსაზღვრავს ორივე A და B NULL მნიშვნელობას.
ალბათ არ რა გსურთ.
ეს ერთი აქ, ზემოთ აღინიშნა, გამოიწვევს შეცდომა
რადგან = b არ არის მართებული გამოსახულება.
ცვლადის სახელი არ შეიძლება დაიწყოს ტოლობის ნიშანი.
და არსებობს ამ დამატებითი რამ აქ.
Colons იყო გამოყენებული, რათა აირჩიოთ არგუმენტები ისტორია ხაზები,
და ისინი შეიძლება გამოყენებულ იქნას - და მე არ წასვლას ადრე - ცვლილებები იმ რამ.
ისინი ასევე შეიძლება გამოყენებული იქნას ცვლილებები shell ცვლადები.
ამ ერთი აქ, $ აქვს მნიშვნელობა.
: R მიიღებს off გაფართოება.
გაგრძელება იქნება არაფერი შემდეგ dot,
dot და არაფერი შემდეგ იგი დასასრულს ფაილი,
მხოლოდ დასასრულს სიაში შემდეგ ბოლო ხაზი.
ასე რომ მე აქ.
ის არის, რომ. ეს იქნება ვარდნა. O.
თუ არ არსებობს გაფართოება, მხოლოდ pathnames შემდეგ ბოლო ხაზი, რომ ეს არ მოახდენს.
: h, რომ ცვლადი გამოხატვის, მიიღებს off ბოლო ელემენტს დირექტორია ჩამონათვალი,
ერთხელ, მხოლოდ მას შემდეგ, ბოლო ხაზი.
ასე რომ, / a / b / c ხდება / a / b,
მაგრამ ეს ერთი შეიცვალა, რადგან ელემენტის შემდეგ სიაში null.
აქ არის ის, რაც, ასევე, ხაზგასმით მინდა აღვნიშნო.
ამ შესარჩევ არ მოძებნოთ არსებობა ეს ფაილი.
ისინი უბრალოდ გამოიყურება სიმები.
ეს განკუთვნილია მანიპულირება ფაილის სახელები, pathnames,
მაგრამ ისინი შეიძლება გამოყენებული იქნას ნებისმიერი string მაშინაც კი, თუ ეს არ არის ფაილის სახელი.
და ისინი არ ვეძებთ არსებობა,
ასე რომ, თუ არ არსებობს ასეთი ფაილი, / a / b / c, ეს დღესაც მუშაობს.
თუ არა ის ნებისმიერი გამოყენება სხვა საკითხია, მაგრამ ის მაინც იმუშავებს.
ცვლადები სხვადასხვა Bourne ჭურვები. ჩვენ კიდევ, რომ მოგვიანებით.
დოლარის ნიშანი შეიძლება გაიქცა ისევე ძახილის წერტილი და ვარსკვლავი.
დოლარის ნიშანი შეიძლება გაიქცა backslash ან ერთჯერადი შეთავაზებები.
ორმაგი შეთავაზებები აქვს უცნაური ეფექტი ყველა ჭურვი
აიძულა შეფასების დოლარის ნიშანი ცვლადი გამოხატვის.
ასე რომ, თუ ის, რომელიც გაიქცა ერთი გზა, ორმაგი შეთავაზებები შეიძლება ჰქონდეს ეფექტი
იწვევს ის უნდა შეფასდეს მაინც.
ეს არის პატარა დამაბნეველი.
თუ არსებობს სხვადასხვა დონეზე აფარებს, როგორიცაა ერთჯერადი შეთავაზებები შიგნით ორმაგი შეთავაზებები
ან ორმაგი შეთავაზებები შიგნით ერთჯერადი შეთავაზებები, თქვენ უნდა შეამოწმოთ, თუ რა მოხდება
ცვლადი, თუ თქვენ იყენებთ ერთი.
იმ 2 სიტუაციებში - ორმაგი შიგნით ერთი, ერთი შიგნით ორმაგი -
აუცილებელი არ მოგცემთ იგივე შედეგი.
გარემოს ცვლადები, შეკრული C-shell ცვლადები.
გარემოს ცვლადები ასევე ცვლადები C-shell,
და ისინი ასევე ცვლადები სხვა ჭურვები ძალიან.
In C-shell, ისინი განსხვავდება კომპლექტი.
რაც მე ამბობდა, სანამ დაახლოებით shell ცვლადები.
გარემოს ცვლადები მკაფიო კომპლექტი ცვლადები
გარდა რამოდენიმე ცვლადს, რომელიც ჩვენ მოვუწოდებთ შეკრული ცვლადები,
რომელიც ძალიან მნიშვნელოვანია და ჩვენ კიდევ იმ მოგვიანებით.
გარემოს ცვლადები ავტომატურად გადაეცემა
რომ ჭურვები და ბრძანებები, რომლებიც აწარმოებს თქვენი ჭურვი.
სხვა რამ არ არის. ჭურვი ცვლადები, მაგალითი არ არის. გარემოს ცვლადები.
ამიტომ, ჩვენ მოვუწოდებთ მათ გარემოს ცვლადები,
იდეა იმისა, რომ გარემოს ვრცელდება წარსულში მხოლოდ თქვენს მიმდინარე ჭურვი.
ისინი შეიძლება გამოყენებულ იქნას, რათა განისაზღვროს რამ ბრძანებები.
აქ არის მაგალითი. პრინტერი, LPDEST.
ორივე ცვლადები შეიძლება განისაზღვროს პრინტერი, ბრძანება გამოიყენოთ ბეჭდვა რამ.
თუ თქვენ გაქვთ მრავალჯერადი პრინტერები გარშემო, დაგვჭირდება დააყენა ერთი გსურთ.
მიზეზი ჩვენ 2 ცვლადები არის, რომ სხვადასხვა კომპლექტი ბრძანებები დაიწერა
გამოყენებით ამ სხვადასხვა ცვლადები.
თქვენ შეიძლება მივცეთ სხვადასხვა ფასეულობები გვაქვს.
სავარაუდოდ, თქვენ, რათა მათ, როგორც იგივე ღირებულება.
იმ რამ იმუშავებს, რადგან ბრძანებები, რომ არ ბეჭდვა
იყო დაპროგრამებული შეისწავლოს ღირებულებებს ამ ცვლადებს.
თუ პროგრამა არ იყო დაწერილი, რომ გზა, თუ იგი დაიწერა უნდა გავაკეთოთ რაღაც,
ცვლადი იქნება შეუსაბამო.
ასე რომ, ოპერაციული სისტემა არ ეძებს ამ ცვლადების
ყოველ დროს, თქვენ ეხება პრინტერი.
ბრძანება რომ არ ბეჭდვა ეძებს ამ ცვლადების თუ ის დაპროგრამებულია, რომ გზა.
ეს ცვლადები ხშირად განისაზღვრება თქვენი ინიციალიზაციისას ფაილი
მაგრამ არ არის აუცილებელი.
თქვენ შეგიძლიათ განსაზღვრავს მათ ბრძანებათა სტრიქონიდან.
ისინი შეიძლება განისაზღვროს ბრძანება.
ბრძანება, რომელიც ეშვება რაღაც შეიძლება ჰქონდეს საკუთარი შერჩევა ცვლადები -
ცვლადები რომ უნიკალურია კონკრეტული პროგრამული პაკეტი, მაგალითად.
ისინი შეიძლება განისაზღვროს, როდესაც თქვენ აწარმოებს, რომ პაკეტი.
როგორ ხდება ეს ცვლადები გადაეცემა sub-shell?
როდესაც sub-shell წერია, ის არ დაწეროთ შევიდა, რომ ფართობი.
ფართობი sub-ჭურვი, რომელიც ეძღვნება გარემოს ცვლადები
არ არის დაწერილი sub-shell, ის დაწერილი გადაწერა.
როდესაც თქვენ აწარმოებს ჩვეულებრივი ბრძანება, როგორიცაა ეს ბრძანებები ბეჭდვა ან რასაც,
ისინი დაიწყოს off შექმნის ახალ ჭურვი.
ჭურვი ქმნის ჭურვი და შემდეგ overwrites ნაწილი
ბრძანება, რომ თქვენ გაშვებული, რომელიც ცოტა გაუგებარია,
მაგრამ ასე ეს ბრძანებები მიიღოს გარემოს ცვლადები
რომ ისინი მაშინ მიმართეთ შემდეგ.
ბრძანება აქ განმსაზღვრელი ცვლადი setenv.
ეს არის ის, თუ როგორ განსაზღვრავს მას. ეს არის 3 ელემენტები: setenv, ცვლადი, ღირებულება.
თუ თქვენ უბრალოდ setenv ერთად არანაირი არგუმენტი, რას მივიღებთ?
სიაში ყველა იმ ცვლადები.
ისევ და ისევ, ეს ლამაზი გრძელი სია, და ამ შემთხვევაში, ისევე, როგორც სხვები,
ეს ცვლადები განსაზღვრულია დიდწილად ჩემი შესვლისას ოპერაციის ჭურვი თავად
ვიდრე არაფერი გავაკეთე.
არსებობს კიდევ ერთი ბრძანება, აქ printenv.
რომელიც ასევე ბეჭდავს out გარემოს.
ყურადღება მიაქციეთ ამ ბოლო რამ აქ, რედაქტორისაგან = vi.
რომელიც ამბობს, რომ თუ მე გამოყენებით რაღაც რომ უწოდებს რედაქტორი
და მე არ დააკონკრეტა, რედაქტორი და ეს საშუალებას მაძლევს არჩევანი, ეს შეიძლება მომეცი vi.
რა მოხდება, თუ printenv რედაქტორი? ის მეუბნება, რა არის.
უფლება მანამდე, იყო ცვლადი, ნაკლებად.
ეს არის თქვენი დეფოლტის ვარიანტი, როცა მე აწარმოებს ნაკლები ბრძანება,
რომელიც აჩვენებს ფაილი.
ასე რომ, თუ, რომ, printenv შეუძლია მიიღოს 1 არგუმენტი ან 0 არგუმენტები,
არა უმეტეს 1.
არსებობს სხვა ბრძანებები ასევე, მაგრამ ჩვენ არ ვაპირებთ შეღწევას, რომ ყველა დღეს.
დამახსოვრება იყო მოდიფიკატორები განთავსების ჭურვი ცვლადი, როგორიცაა: h,
რომელიც უარს იტყვის ბოლო ელემენტს pathname,
ან: r, რომელიც უარს იტყვის გაფართოება.
იმ ახლა ვრცელდება გარემოს ცვლადები ძალიან. ისინი არ გამოიყენება.
იგი ითვლებოდა, ისინი არ შეიძლება შეცვლილია. ახლა კი შეიძლება იყოს.
ეს არის ერთ ერთი მიღწევების იმ მოვლენების ჭურვები წლების განმავლობაში.
მე ვამბობ, რომ ჭურვები ნაწილი გარემოში
და შელი ცვლადები C-shell არიან, ზოგიერთი გამონაკლისის გარდა, მკაფიო კომპლექტი.
თქვენ შეუძლია შექმნას გარემოს ცვლადი და shell ცვლადი იგივე სახელი.
ისინი იქნება სხვადასხვა ცვლადები, მათ შეიძლება ჰქონდეთ განსხვავებული ღირებულებები.
შეცვლის ღირებულება ერთი არ შეიცვლება ღირებულება სხვა.
ეს ცვლადები ყველა ფასდება დოლარის ნიშანი - $, $ რასაც.
მერე რა, რომ თქვენ გაქვთ ეს? იცით, რომელიც თქვენ მიიღეთ?
ჩემი ტესტების მე მივიღე shell ცვლადი,
მაგრამ ეს არ არის დოკუმენტირებული და ვერ დაეყრდნონ, რომ.
ასე რომ, გთხოვთ, ქმნის ჭურვი და გარემოს ცვლადები
იგივე სახელები კარგი იდეა? პოსტები Okay.
რა არის ის ძირითადი გამონაკლისი, რომელიც გარემოს დაცვისა და shell ცვლადები
უკავშირდება ერთმანეთს?
არსებობს ამ 4.
Capital წერილი ტერმინის ცვლად გარემოცვას,
ჭურვი ცვლადი ვადა პატარა ასოები, ტიპის ტერმინალის ემულაციის.
მე უბრალოდ აპირებს წასვლა აქ და მე ვაპირებ ამის გაკეთებას echo, სასარგებლო ბრძანება აქ,
$ პერიოდი $ ვადით. და იქ.
xterm არის ტერმინალის ტიპის ფანჯრები ნაჩვენები X Window სისტემის.
xterm ფერი არის ვარიაციით, რომ, რომელიც საშუალებას აძლევს სხვადასხვა ფერის.
რატომ ჩვენ განვსაზღვროთ ეს? რა არის ეს კარგი?
ბრძანებები, rearrange ეკრანზე, როგორც რედაქტორი
გაუგზავნე კერძოდ sequences, ე.წ. გაქცევის sequences,
to ტერმინალი ან ფანჯრის განსამტკიცებლად და სხვ.
იმ sequences სხვადასხვა სხვადასხვა ტიპის ტერმინალები.
ეს ეუბნება, რომ რაც პირობა გამოიყენოს.
ზოგჯერ არსებობს საკითხები არსებობს.
დაგვჭირდება შეცვლის.
თუ რამ არ მუშაობს, ზოგჯერ ტერმინალის ტიპის არის არასწორი,
თქვენ შეუძლია დააფიქსიროს იგი დახვეწის ტერმინი ცვლადი.
ამ შემთხვევაში, იცვლება ერთი ცვლადი, გარემოს ცვლადი ან ჭურვი ცვლადი,
უნდა შეიცვალოს მეორე.
მე აღმოაჩინა მეშვეობით გამოცდილება, რომელიც შეცვლის ვადა ასოებით
ყოველთვის არ შეცვლის shell ცვლადი ვადა პატარა წერილები.
ეს არის შეცდომა.
მე არ ვიცი, თუ ეს ყოველთვის ასეა. ყველაზე დროის ეს ასე არ არის, მაგრამ ეს შეიძლება იყოს.
ასე რომ, თუ თქვენ მიიღოს ცვლილება, უბრალოდ შეამოწმოს, რომ გარეთ.
ეს არ არის ხშირად, რომ თქვენ უნდა შეიცვალოს, რომ ღირებულება, მაგრამ ერთხელ, ხოლო თქვენ.
გარემოს ცვლადი შესახებ.
ერთხელ, გარემოს ცვლადი ასოებით, ჭურვი ცვლადი პატარა წერილები.
ეს არის თქვენი მომხმარებლის სახელი.
ეს მხოლოდ ძალიან გამონაკლის შემთხვევაში
რომ თქვენ გვინდა, რომ შეიცვალოს, რომ.
თუ თქვენი სახელი არის ვინმე, მას შეუძლია ჩააგდოს ყველა სახის რამ off.
მთავარი დირექტორია, შესახებ მთავარი დირექტორია.
ერთხელ, თქვენ არ მინდა, რომ შეიცვალოს, რომ.
ყურადღება მიაქციეთ, ყველა ამ შემთხვევაში, და ერთი, რომ ჩვენ შესახებ საფარი, გზა ცვლადი,
გარემოს ცვლადი ასოებით და შეკრული shell ცვლადი პატარა წერილები.
თუ შეცვლის ერთი, თქვენ უნდა შეიცვალოს სხვა.
ამ სახის სავალდებულო არ დგინდება, როგორც თქვენ ვერ ვუკავშირდები 2 ცვლადები,
გარდა ამ 4 და სავალდებულოა ამ ცვლადებს არ შეიძლება undone,
თქვენ არ შეგიძლიათ გამოყავით ისინი.
ასე რომ, ამ 4 წყვილი ცვლადების შეკრული.
ისინი ყოველთვის იქნება. არა სხვები იქნება.
გარდა ამისა, შესაძლებელი იქნება, რომ შეიქმნას ცვლადები იგივე სახელები
საპირისპირო ტიპები.
თქვენ შეიძლება მიიღოს shell ცვლადი ვადა პატარა ასოები
ან გარემოს ცვლადი ვადა ასოებით.
იმ ცვლადების დამოუკიდებელი იქნება ეს დაწყვილებული ცვლადები
და ისინი დამოუკიდებელი იქნება ერთმანეთთან.
მე ვერ წარმომიდგენია, რატომ თქვენ ყველაფერს გააკეთებს, რომ თუ გსურთ აღრეული ხალხს.
ამ ერთი აქ, გზა ცვლადი, ეს მართლაც მნიშვნელოვანია.
კიდევ ერთი რამ აქ არის ის, რომ იქ შეიძლება იყოს შემთხვევა,
ცვლადები მსგავსი შეწყვილებულ სახელები, რომლებიც არ არიან ერთმანეთთან.
არ შეიძლება ცვლადები, ჭურვი და ჭურვი, კაპიტალის და პატარა ასოები.
დაყრდნობით, რომ სახელს, თქვენ არ იცით, თუ, რომ ცვლადი არის shell ცვლადი
ან გარემოს ცვლადი, და ისინი არ არიან ერთმანეთთან.
ასე რომ ასეთი სახის შეწყვილებულ სახელები არ გულისხმობს შეკრული ცვლადები.
გზა ცვლადი, რომელიც მე გვიჩვენებს ადრე,
ჩამოთვლილია pathnames რომელშიც ჭურვი ეძებს ბრძანებები.
მოდით კიდევ მეტი ეს ფანჯარა აქ და ჩვენ ყველაფერს გავაკეთებთ echo $ PATH, ასოებით -
გარემოს ცვლადი - echo $ გზა, პატარა ასო - ჭურვი ცვლადი.
გაითვალისწინეთ, რომ სიაში დირექტორიები იგივეა. ეს არის შეკრული.
შეცვალოს ერთი, თქვენ შეცვალოს სხვა.
გარემოს ცვლადი ელემენტები გამოყოფილია colons. გაითვალისწინეთ, რომ.
ჭურვი ცვლადების მაქს.
ეს გარემოს ცვლადი ერთი string.
ჭურვი ცვლადი მასივი.
The Bourne shell არ აქვს მასივები.
Bash აკეთებს, მაგრამ ეს უკვე ფიქსირებული ნაწილი ჭურვი.
ეს არის ერთ სიმებიანი და არა მასივი.
C-shell ყოველთვის ჰქონდა მასივები.
კოლექტორები ბევრად უფრო ადვილია მუშაობა.
შეგიძლიათ მიმართოთ ნაწილები.
ასე რომ echo $ გზა [1] და მე / usr / bin, პირველ ელემენტს.
ერთხელ, მახსოვს დოლარის ნიშანი დგას ბოლო ელემენტს ისტორიის სიაში.
რა ხდება იქ? იგი შეეცადა დოლარის ნიშანი, როგორც ცვლადი სიმბოლო.
მე გაქცევა ეს. Oops. იგი არ მიიღებს, რომ არც.
ზოგიერთი რამ არ მუშაობს ისე კარგად.
იქნებ ჩვენ უბრალოდ დატოვონ რომ.
Asterisk ეხება მთელი რამ, მაგრამ ეს არის ის, რაც თქვენ გაქვთ, თუ თქვენ არ დააკონკრეტა ელემენტს.
კიდევ ერთი გზა, რომ მასივი ცვლადები შეიძლება მანიპულირება,
რაოდენობის ელემენტები არსებობს, 7 ელემენტები.
აქ ჩვენ დააყენა ფუნტი ნიშანი სანამ ცვლადის სახელი.
აი კიდევ ერთი. განათავსეთ კითხვის ნიშნის იქ.
ეს არის ლოგიკური მნიშვნელობა. ეს მიუთითებს იმაზე, რომ ცვლადი არსებობს.
ეს არის კიდევ ერთი გზა მუშაობა ცვლადები.
ეს, სხვათა შორის, არ უნდა იყოს მასივი ცვლადი.
ეს შეიძლება იყოს ნებისმიერი ცვლადი.
და თუ მე, არ არსებობს ასეთი ცვლადი და მივიღებ 0.
სხვა პატარა რამ იქ ცვლადი შეფასებები.
დასაწყისზე ეს ერთი აქ, თუ რაიმე მიზეზით თქვენ სურდა მუშაობა ამ
ვიდრე მუშაობა მასივი, ჭურვი ცვლადი,
არსებობს ბრძანებები, შეიძლება გამოვყოთ ეს ყველაფერი საფუძველზე მსხვილი ნაწლავის.
ფაქტობრივად, თუ თქვენ უნდა აკეთებს ამ წელს Bash shell შესაძლოა,
ერთგვარი სცენარი, რომ ეს იქნება ალბათ, თუ როგორ გავაკეთოთ.
მაგრამ C-shell ეს ბევრად უფრო ადვილია გამოყენება მასივი.
ამ Bourne shell, ცვლადების მიერ დანიშნული ერთი გამოხატულება მოსწონს,
მოსწონს გზა თქვენ შეიძლება დაავალოს ცვლადი პროგრამირების ენა,
და აქ არ უნდა არსებობდეს ფართები.
აუცილებელია, რომ ეს იქნება მხოლოდ 1 string.
ამ Bourne ტიპის ჭურვები, ყველა ცვლადები shell ცვლადები.
გარემოს ცვლადები არის subset of the shell ცვლადები.
ისინი გამოირჩევა არასამთავრობო გარემოს ცვლადები მიერ ექსპორტს.
ბრძანება უნდა გავაკეთოთ, რომ ექსპორტი, როგორც ექსპორტის პრინტერი.
თუ ჩვენ უნდა განსაზღვროს ისეთი ცვლადი,
თუ გვინდოდა ბეჭდვის ბრძანება, ის, რომ ეს უნდა იყოს გარემოს ცვლადი,
და ასე ჩვენ ეს ერთი.
აქ არსებობს რაღაც სახის დამაბნეველი.
ეს გამოთქმა, ექსპორტი გარემოს, გამომდინარეობს ამ Bourne shell კონცეფცია,
და კიდევ რომ გამოხატვის გამოიყენება აღწერილობები C-shell,
სადაც არ არსებობს ასეთი ბრძანება, როგორც ექსპორტზე.
თუ თქვენ უბრალოდ ამბობენ ექსპორტი თავისთავად, თქვენ სიაში ექსპორტი -
ასე რომ, თუ მე უბრალოდ საექსპორტო აქ, ასეთი რამ.
Okay, იქ ჩვენ წავიდეთ.
ეს ყველაფერი, სხვათა შორის, ასევე განსაზღვრული ჭურვი.
მე არ განსაზღვრავს რომელიმე ამ თავს.
ჭურვი აკეთებს ყველა სახის რამ თავისთავად.
ეს უნდა გავაკეთოთ ყველაფერი ავტომატურად.
In Bash ან Korn Shell, შეგიძლიათ გაუშვათ ბრძანება მოსწონს,
რომელიც ორივე მისცეს ცვლადი ღირებულება და ექსპორტის 1 ბრძანება.
ამ Bourne shell ისინი უნდა იყოს ცალკე ბრძანებები, როგორიცაა ექსპორტი.
აქ არის კიდევ ერთი ასპექტი, რომ გაუგებარია.
კომპლექტი ბრძანება C-shell განსაზღვრავს ცვლადის
და არანაირი არგუმენტი ეუბნება, თუ რა ცვლადები 'ღირებულებები.
ამ Bash shell, კომპლექტი ბრძანება არგუმენტები არ აკეთებს იმავეს,
მაგრამ არგუმენტები, რომ აკეთებს რაღაც სხვაა.
ასე რომ ეს არის სხვადასხვა არგუმენტები აქ.
ზოგიერთი მათგანი გარემოს ცვლადები, ზოგიერთი მათგანი shell ცვლადები.
ყველა მათგანი shell ცვლადები ნამდვილად. ზოგიერთი იმ გარემოს ცვლადები.
კომპლექტი ბრძანების არგუმენტები შეიძლება იყოს გამოყენებული მუშაობას
წლის თანამდებობრივი პარამეტრების სკრიპტი,
რომელიც არის გზა მიღების მათ ერთდროულად.
ჩვენ არ შეგვიძლია ნამდვილად წასვლას, რომ დღეს.
იგი ასევე შეიძლება გამოყენებული იქნას შეცვალოს shell საქციელისათვის.
განსაკუთრებით Bash არის ცვლადი, რომელიც განსაზღვრავს, თუ როგორ shell იქცევა.
შემდეგ ასევე მხოლოდ ამ ერთი ბრძანება, რომ თქვენ შეიძლება ნახოთ ეს ბრძანება.
Typeset მოჰყვა ცვლადები და ცვლადი ტიპები გამოიყენება Korn და Bash ჭურვები.
ეს არ არის სავალდებულო, მაგრამ ის შეიძლება გამოყენებულ იქნას შეზღუდოს ღირებულებების ცვლადები,
რომელიც შეიძლება იყოს სასარგებლო თავიდან ასაცილებლად შეცდომები, და ეს საკმაოდ საერთო.
ასე რომ მე უბრალოდ აღვნიშნოთ, რომ იმ შემთხვევაში, თუ ვხედავ, რომ სადღაც.
სადაც ბრძანება.
დამახსოვრება ვთქვი ადრე, სადაც ბრძანების C-shell,
რომელიც შემიძლია გითხრათ მდებარეობა ბრძანება pathname.
აქ არის command-ის რიგებში.
თქვენ უნდა იპოვოთ თქვენს კლავიატურაზე სადღაც ხასიათი, რომ ასე გამოიყურება.
განთავსების კლავიატურის აპირებს განსხვავდება.
ჩვენ მას backquote. ეს დაახლოებით ზომა გაცემა.
მიდის ზედა მარცხენა ქვედა მარჯვენა.
აქ ჩემს Mac კლავიატურის ის ზედა მარცხენა კუთხეში.
რომ ხასიათი შეიძლება გამოყენებულ იქნას, რათა შესრულდეს ბრძანება ფარგლებში ბრძანება.
თუ თქვენ გაქვთ გამოხატვის შიგნით backquotes,
რომ გამოხატვის ბრძანება, ის აწარმოებს.
გამომავალი, რომ ბრძანება
შემდეგ შეცვალეს მთელი backquote გამოხატვის
შიგნით აღარ ბრძანება, რომელიც შემდეგ გადის, რომ გამომავალი
როგორც ნაწილი მისი სიმებიანი არგუმენტები და სხვ.
აქ არის ბრძანება, რომელიც იყენებს რომ.
მოდით დემონსტრირება ოპერაცია აქ.
მოდით წავიდეთ აქ, აიღოს backquotes.
კონტროლის იღებს ჩემთვის დასაწყისში შეესაბამება Emacs რედაქტირება სინტაქსის.
ჯერჯერობით pathnames არის რა სად,
მაგრამ როცა ამის გაკეთება, როგორც ეს, მაშინ სანთლებს რომ სიაში pathnames
ადგილზე მთელი ამ backquote გამოხატვისა და ეშვება ls-l მათ.
კეთილი მოსახერხებელი, huh?
ასე რომ, ერთ neat რამ. ასე backquotes მუშაობა.
ახლა მოდით დაცემას ცოტა შემდგომი.
ეს არის მაგალითი. მე რეალურად გამოიყენოს ეს.
ვეცდები კიდევ ამ 1 რედაქტირება ოპერაცია.
Okay.
ახლა ვნახოთ, როგორ იმ განმარტებები გამოვიდა.
alias lwh მეუბნებოდა, როგორ განისაზღვრება.
ყურადღება მიაქციეთ, უბრალოდ, მაგრამ გარე შეთავაზებები უკვე წაიყვანეს
და ძახილის წერტილი აღებული off.
* სრული სია არგუმენტები.
In იგივე განმარტება იგი გამოიყენებს დაბრუნდა, სადაც მე გამოიყენოს ეს.
lwh ksh bash. Okay.
ვნახოთ, როგორ მუშაობს? ეს ზოგავს გარკვეული ფერთა.
მოდით წავიდეთ ცოტა უბრალოდ აღვნიშნო რაღაც აქ.
გაითვალისწინეთ, აქ ამ სხვადასხვა ჭურვები. მე უნდა აღინიშნოს, ეს ადრე.
Csh აქვს 2 მეტი აქ და ასე აკეთებს / bin / tcsh.
ჩვენ შეიძლება შეიქმნას სხვა საშუალებებით, რომ ეს რეალურად იგივე ფაილი.
დამახსოვრება მე ამბობდა თუ აკრიფოთ შ თქვენ გაქვთ bash.
აკრიფოთ ამ და თქვენ ეს.
მაგრამ ისინი, რომლებიც არ უკავშირდება. იმ გვაქვს ერთი პირობა არსებობს.
და ეს არ არის იმ ტიპის ფაილი, რომელიც შეგიძლიათ დარეკოთ კიდევ ერთი.
ასე რომ იმ ცალკე ფაილი, C-shell პირობა იგივე ფაილი.
უკან ქვემოთ აქ, მეორე აქ, ამ alias,
გაითვალისწინოთ, რომ გაშვებული ამ ბრძანების ფაილი.
რომ alias თანახმად. ფაილი გიჩვენებთ ტიპის ფაილი.
ასე fwh ksh bash. Okay.
სწორედ გამომავალი ფაილი ბრძანება.
მე არ ვიცი, თუ იცით რას ნიშნავს აქ,
Mach-O უნივერსალური ორობითი 2 არქიტექტორები.
არსებობს 2 შესაძლო პროცესორი ტიპის Mac,
და ზოგიერთი პროგრამა დაიწერა, რათა მათ შეძლონ აწარმოებს ორივე,
და ფაილის ბრძანება შეიძლება დადგინდეს, რომ, ასე რომ რას ნიშნავს ეს.
ორივე ეს ფაილი დაიწერა, რომ გზა.
ასე რომ, ჩვენ ვხედავთ, თუ როგორ alias მუშაობს, ჩვენ ვხედავთ, თუ როგორ backquote სამუშაოები,
ჩვენ ვხედავთ, თუ როგორ ფაქტობრივი ფაილი ls ან ფაილის მუშაობს.
ეს შეიძლება არ იმუშაოს. ცდილობენ ", სადაც, სადაც" და "lwh სადაც". Okay, მოდით ვცდილობთ რომ.
სადაც სადაც.
სად არის shell ჩამონტაჟებული.
დამახსოვრება ადრე ჩვენ აჩვენა, რომ Bash არ აქვს, სადაც.
თუ თქვენ ტიპის სადაც Bash shell, თქვენ მიიღებთ შეცდომა.
ეს არის მხოლოდ ნაწილი shell ვიდრე ცალკე ბრძანება.
რა მოხდება, თუ მე აკრიფოთ lwh ეძებს სად? ვნახოთ, რა მოხდება იქ.
გაიქცა, სადაც, სადაც მივიღე ამ output, და შემდეგ შევეცადე აწარმოებს ls
როგორც ლ, სადაც არის shell ჩამონტაჟებული.
სად არის იქ, მაგრამ სხვა პირობა არ არსებობს.
არცერთი არსებობს, რეალურად.
ასე რომ, ყოველთვის არ მუშაობს და ასევე ის გვიჩვენებს, თუ როგორ ზოგიერთი რამ
არ აკეთებენ საკმაოდ რა ალბათ ეგონა.
მოდით დაცემას ცოტა უფრო აქ.
ეს აქ არის Bash. ესეც ბრძანება ცვლილება, როგორიცაა backquote.
მაგრამ განსხვავებით backquote, იგი იყენებს ამ ცვლადის სტილი.
არსებობს მთელი რიგი გამონათქვამების რომელიც დაიწყოს დოლარის ნიშანი,
ხოლო ეს არ არის ცვლადი, ისინი ნასესხები გამოყენების დოლარის ნიშანი
მიუთითოს გამოხატვის რაღაც.
რომელიც შეიძლება გარს მრგვალ ან ფრჩხილებში ან ორმაგი ფრჩხილებში,
რომელსაც აქვს სხვადასხვა მიზნით.
Single ფრჩხილებში აქ ბრძანება ცვლილება, ისევე, როგორც backquotes.
Double ფრჩხილებში რეალურად არითმეტიკული ოპერაცია.
არსებობს სხვა syntaxes, სხვა ოპერაციებში.
Backquote სინტაქსი არის შესაძლებელი Bash.
თუმცა, ამ ერთი სასურველია. ეს ბევრად უფრო ადვილი წასაკითხი და ის საშუალებას nesting.
თქვენ შეგიძლიათ შიგნით $ (ბრძანება) კიდევ ერთი ბრძანება,
რაღაც -
მივიღებ სიაში.
რომ იმუშავებს, თუ მქონდა backquote ასევე.
რა მოხდება, თუ მინდა, რომ რამე მსგავსი -
თქვენ ალბათ არ რეალურად გამოიყენოს ამ ბრძანების
მაგრამ ეს შიდა ბრძანება ცვლილება ეხმიანება სახელები ყველა ფაილი დაწყებული,
მაშინ ეს ერთი გადის ls-l იმ ფაილი,
და მაშინ ეს ერთი მხოლოდ ეხმიანება გამომუშავება.
თქვენ ალბათ არ გავაკეთოთ ეს, თქვენ უბრალოდ გაკეთება echo ან ls,
მაგრამ ეს გვიჩვენებს, თუ როგორ nesting ბრძანებები მუშაობს.
ასე რომ მხოლოდ ერთი თვისება აქ.
ვთქვი, ეს ადრე, რომ როდესაც თქვენ გაქვთ სადაც C-shell,
ჩაწერეთ სამუშაოები Bourne ტიპის ჭურვებს განთავსებით ბრძანებები.
ჩაშენებული ბრძანებები, მხოლოდ ის, რაც მე ამბობდა არსებობს.
ბრძანებები ნაწილი shell, ისევე, როგორც, სადაც.
როდესაც ჭურვი ახორციელებს ბრძანება, როგორიცაა ls, ეს მოსაძებნად ის მეშვეობით გზა,
უჭირს ზოგიერთ დირექტორია სადღაც,
ნათქვამია, რომ მეხსიერებაში, ქმნის ახალ shell,
ნათქვამია ბრძანება ls ან რასაც შევიდა ჭურვი
სადაც გარემოს ცვლადები უკვე მდებარეობს,
და მერე გადადის აღსრულების იგი.
ჩაშენებული ბრძანება, კოდი, რომ ბრძანება შიგნით ნაჭუჭით,
ამიტომ shell მხოლოდ იწყებს შესრულებაში ნაწილი საკუთარი კოდი.
სად არის ასეთი ბრძანება. ეს რეალურად იღებს სწრაფად.
ეს არ უნდა წაიკითხოთ არაფერს, მეხსიერებაში, ეს უკვე მეხსიერებაში.
ჩაშენებული ბრძანებები ყოველთვის უპირატესი ბრძანებები იგივე სახელი.
ბრძანებები, რომლებიც დირექტორიები გზა შეიძლება ჰქონდეს ამავე სახელწოდების,
ბრძანებები სხვადასხვა კატალოგები, ფაილი სხვადასხვა დირექტორიების.
ერთი, რომ ხდება ადრე გზა არის ერთი, თქვენ მიიღებთ.
თუ არსებობს ჩაშენებული ბრძანება, თქვენ ყოველთვის მიიღოს იგი.
არ არსებობს გზა, რათა ეს ქვედა უპირატესი, ვიდრე ბრძანება გზას.
თუ გვინდა, რომ გზა ბრძანება, შეგიძლიათ ჩაწეროთ სრული pathname.
თუ არ იყო ბრძანება, სადაც გზა სადღაც,
თქვენ შეიძლება აკრიფოთ / bin / სად და ნეტავ მიიღოს იგი.
თუ თქვენ არ გსურთ შეიტანოთ მთელი pathname, შეგიძლიათ განსაზღვრავს alias.
ფაქტობრივად, თუ მისცა alias იგივე სახელი ჩაშენებული ბრძანება, რომ მუშაობა
იმიტომ, რომ იგივე განმარტება ფასდება
ადრე shell დაადგენს, რომ ეს არის ჩაშენებული ბრძანება რომელიც უნდა განხორციელდეს.
მაშინ ეს იღებს ცოტა უფრო რთული ზოგიერთი ბრძანებები აქ.
იმ შემთხვევაში, თუ ზოგიერთი ბრძანებები რეალურად ჩაშენებული ბრძანებები და გზას.
ერთი მათგანი არის echo, ბრძანება უბრალოდ გამოიყენება ცოტა ხნის წინ იმ მაგალითები.
Echo ბრძანება გზა და ეს ყველა ჭურვი.
ეს იმას არ ნიშნავს ყველა მოიქცევა იგივე გზით.
თავდაპირველად ბრძანება მხოლოდ იმ გზას.
იგი აიგო, რომ ჭურვები შემდეგ.
რადგან არსებობს ვარიანტი, რომელიც დამოკიდებულია გარემო
და ბრძანების პარამეტრები, ჩაშენებული ბრძანებები
დაიწერა ფუნქციონირებას იგივე როგორც ბრძანება, რომ იყო გზა,
ეს ნაკლებად სავარაუდოა, რომ ისინი უკვე დაიწერა, რომ გზა
თუ ბრძანება არ ჰქონდათ უკვე დაწერილი გზას.
ასე რომ, ეს არ აქვს გვერდითი მოვლენები. მისი ისტორია აქვს ეფექტი აქ.
არსებობს ვარიანტი არსებობს.
არსებობს ასევე ვარიანტი განისაზღვრება ცვლადი tcsh მოუწოდა echo_style.
ეს არის ერთ ერთი ეს ცვლადები, რომ შეიძლება შეიცვალოს ისე, რომ echo სამუშაოები.
არსებობს სხვა საქმე, რომელშიც შეგიძლიათ დაავალოს ცვლადი
რომელიც ცვლის ისე, რომ ჭურვი ოპერაცია, მათ შორის ჩაშენებული ბრძანება, მუშაობს.
ეს არ იმოქმედებს არაფერი
მას შემდეგ, რაც სხვა ბრძანებები არ გაქვთ shell ცვლადები,
მხოლოდ გარემოს ცვლადები.
მაგრამ shell ოპერაციების წაიკითხოს shell ცვლადები.
ეს არ იმუშავებს csh. ეს მხოლოდ tcsh. ეს არის ერთ ერთი გაუმჯობესებებს.
დამუშავების აქვს sequences, როდესაც იგი აფასებს metacharacters,
როდესაც იგი აფასებს ცვლადები, მაგალითი, ისტორიის წყაროები.
არსებობს კონკრეტული თანმიმდევრობით ეს ყველაფერი.
თუ ეს ასეა რამ კონკრეტული თანმიმდევრობა
და იღებს რაღაც რომ გამოხატვის ერთგვარი
რომელიც უკვე შეაფასა, ეს არ შეაფასოს იგი ერთხელ.
იმ შემთხვევაში, თუ იგი იღებს, მაშინ იგი მხოლოდ გაივლის სიმბოლო.
ასე რომ, თუ შეფასების ზოგიერთი გამოთქმები, როგორიცაა ბრძანება ცვლილება
ან ცვლადი ან რასაც წარმოშობს გამოხატულება
რომელიც თქვენ სურს შეფასდება,
რომელიც იმუშავებს მხოლოდ იმ შემთხვევაში, რომ შეფასება ხდება შემდეგ თანმიმდევრობით.
იმედი მაქვს, რომ მე, როგორც ნათელი არსებობს.
რომ parsing თანმიმდევრობა, ოპერაციის C-shell,
არ არის იგივე ჩაშენებული ბრძანებები, როგორც ეს არის არასამთავრობო ჩაშენებული ბრძანებები.
მე არ ვარ დარწმუნებული Bash არსებობს.
მაგალითად, თუ ჭურვი ცვლადი წარმოებული history მინიშნება,
ეს ალბათ არ დაბრუნდეს ისტორიაში.
ეს იქნებოდა უბრალოდ ძახილის წერტილი.
ფაქტობრივად, ჩვენ შეგვიძლია მხოლოდ ვეცადოთ, რომ ახლა.
მითითებული = და გვექნება, რომ ეს არსებობს.
ოჰ, დაველოდოთ. უკაცრავად. მე ამ წელს Bash. მინდოდა აქ.
ვხედავ, ასე რომ არ აფასებენ, რომ ისტორია მითითება
იმიტომ, რომ ეს უკვე იყო წარსულში წერტილი შეფასებისას history გამონათქვამები
როდესაც იგი შეაფასა ცვლადი.
ასე რომ 1 ეფექტი parsing.
და ისევ, ჩაშენებული ბრძანებები არ კეთდება იგივე გზით.
ყველა უფლება. მოდით წასვლა მომდევნო ერთი აქ.
ეს მიზნად ისახავს იყოს 1 ხაზი, მაგრამ რაც უფრო წაიკითხა.
რას აკეთებთ?
თქვენ შეიძლება გავიხსენოთ, რომ ჩვენ შეგვიძლია შევაფასოთ asterisks როგორც სახელებში მიღებული შაბლონები,
და არსებობს სხვა სახელებში მიღებული შაბლონები, როგორც კითხვის ნიშნის და bracket გამონათქვამები.
ასეთი სახის შეფასების ეწოდება globbing.
მითითებული noglob დასაწყისში ამ ბრძანების ამბობს, არ გაგვაჩნია.
ამორთულია noglob ამბობს დავუბრუნდეთ აკეთებს, რომ.
გაითვალისწინეთ, რომ საჯარიმო glob არ აქვს, რომ ეფექტი.
ჩვეულებრივი ენა, მითითებული glob ან ამორთულია noglob რომ როგორც ჩანს, ექვივალენტს,
მაგრამ აქ ეს არ არის. ეს ამორთულია noglob.
ახლა tset. tset იდგა ტერმინალში კომპლექტი.
ის არ გამოიყენება, რომ ხშირად, მაგრამ ადრე windowing სისტემები გახდა შესაძლებელი
და გქონდათ ერთი ტერმინალი, თქვენ უნდა განსაზღვროს ტიპის.
და თუ რამე მოდიოდა მეტი Ethernet ან ქსელში,
თქვენ ალბათ მინდა ვთქვა, რომ ეს არის vt100.
VT100 სახის სტანდარტული ტერმინალის ბიზნესი. საქმე საოლქო ტერმინალში.
თუ თქვენ უბრალოდ dialup - შეამჩნია, რომ? ეს მიდის უკან გზა, huh?
ასე რომ, თუ ჩვენ უბრალოდ tset მეტი აქ,
თუ მე უბრალოდ tset, ეს გადატვირთვის ჩემი ტერმინალის, მაგრამ თქვენ არ მინახავს არაფერი.
ეს ნამდვილად არ შევცვლით.
-S
Okay.
setenv TERM xterm ფერი.
ჩვენ უკვე კარგად ვიცით, რომ ტერმინი შეიქმნა, რომ გზა, ისე, რომ არ შეცვლილა.
ეს გზა ჩვენ მინდა ამის გაკეთება.
მაგრამ შეამჩნია, რომ ეს ბრძანება, tset-s, უბრალოდ გამომავალი ეს ბრძანებები. ეს არ აწარმოებს მათ.
ეს არ აწარმოებს ეს ბრძანებები, ეს გამომავალი მათ.
ასე რომ, ეს არის განკუთვნილი წარმოების ბრძანებები რომელიც შემდეგ აწარმოებს.
გახსოვთ ბრძანება, რომ ფაილი უბრალოდ აჩვენა თქვენ ჰქონდა Q იგი.
მოდით გავაკეთოთ ეს.
Q თრგუნავს ზოგიერთი გამომუშავება, არამედ ის, რომ არ აქვს მნიშვნელობა, აქ, როგორც ხედავთ.
მე უბრალოდ აკეთებს, რომ გაჩვენოთ, რომ მას არ აქვს მნიშვნელობა.
ეს არის backquote სინტაქსი.
შენიშვნა backquote აქ, backquote აქ.
მე omitting ეს ყველაფერი აქ.
ეს არის შემთხვევა, ვეუბნებოდი მას, რა უნდა გააკეთოს
იმ შემთხვევაში, თუ კონკრეტული ტიპის ტერმინალები -
Ethernet, ქსელის, dialup, რა.
არ აქვს მნიშვნელობა, აქ იმიტომ, რომ ჩვენ რეალურად არ აკეთებს ნებისმიერი ამ საკითხზე.
მე უბრალოდ ამსახველ ბრძანება.
თუ მე ამას backquote, რა ვარ მე აპირებს მიიღოს?
ასევე შეამჩნევთ, რომ ამ ოთახში კომპლექტი noglob და ამორთულია noglob,
ასე რომ, ეს უკვე ზედმეტი განმარტება.
ეს არ იყო ყოველთვის ასეა, მაგრამ ახლა ისინი შედის ამ ბრძანებას.
მაგრამ ვნახოთ რა მოხდება, თუ მე რომ
და წავიდეთ დასაწყისში შეესაბამება კონტროლის და მე ამის გაკეთება.
Okay, მითითებული: Command არ არის ნაპოვნი. რომ სახის უცნაური, არა?
კომპლექტი არის ცნობილი ბრძანება. ეს ნაწილი ჭურვი.
მითითებული: Command არ მოიძებნება? რატომ არის, რომ?
Hmm. ისე, მოდით ვიფიქროთ ამ.
ის გაშვებული backquote ბრძანება ცვლილება,
და რომ ხდება გარკვეული ნაწილი თანმიმდევრობა დამუშავების ბრძანება.
კომპლექტი არის ჩაშენებული ბრძანება.
ასე რომ, იმ დროისთვის ეს იმას, რომ ბრძანება ცვლილება,
ის უკვე მიღებული წარსულში წერტილი საიდენტიფიკაციო ჩაშენებული ბრძანებები.
ასე რომ ეპყრობა მითითებული თითქოს ბრძანება გზას.
რა თქმა უნდა, ეს არ პოულობთ მას და თქვენ მიიღებთ შეცდომა.
კარგად. არსებობს მაგალითი parsing თანმიმდევრობით.
და რა ვქნათ ამაზე?
შეამჩნია ეს ძალიან საინტერესო ბრძანება აქ პოსტების რაოდენობისა.
მაინტერესებს, რა რომ აკეთებს.
თუ გადავხედავთ სახელმძღვანელო - და მოდით უბრალოდ გავაკეთოთ, რომ
რათა ნახოთ რამდენად დამაბნეველი ეს სახელმძღვანელოები არიან -
კაცი tcsh, დაბნეული სახელმძღვანელო, მოძიებაში რამ აქ არ არის ადვილი ან.
აქ ჩვენ გადასვლა, პოსტების Arg, ასე რომ ჩვენ შეგვიძლია 1 ან მეტი არგუმენტები
და იქ სიაში რამ არსებობს.
ეპყრობა არგუმენტები საშუალებებით ჭურვი
და ახორციელებს შედეგად ბრძანებები კონტექსტში მიმდინარე ჭურვი.
ეს ჩვეულებრივ გამოიყენება შეასრულოს ბრძანებები გამომუშავებული შედეგად ბრძანება
ან ცვლადი ცვლილება, რადგან parsing მოხდა სანამ ამ substitutions.
ძალიან კარგი.
და აქ კი ეხება tset ბრძანება ნიმუში გამოყენება
მოსწონს ერთი მე უბრალოდ აჩვენა თქვენ.
ახლა მე უნდა ფანჯრის თავში სასარგებლო ადგილას.
მოდით კიდევ მეტი აქ და ჩვენ დავინახავთ, რომ პოსტების გამოიყენება მხოლოდ მანამდე.
ასე რომ, ვნახოთ, რა მოხდება, თუ ჩვენ დააყენა - აქ ჩვენ მივდივართ ერთად ისრებით, რომ ბრძანება
და კონტროლის დასაწყისში, eval.
Okay, ასე რომ მუშაობს.
როდესაც თქვენ პოსტების, ის, თუ რა უძღოდა მას და ხდის ბრძანება.
ეს საშუალებას გაძლევთ არსებითად გარჩევის ორჯერ.
სექციაში აქ გადის ეს ბრძანება შიგნით backquotes,
იღებს გამომუშავება.
გამომავალი უნდა აწარმოებს როგორც ისინი ბრძანებები აქ მოსწონს ეს
ამ ერთი და ეს ერთი.
ასე რომ იმ ბრძანებას ახლა აქ, ამ თანმიმდევრობით,
მაგრამ ეს ჩაშენებული ბრძანებები და მას არ შეუძლია მიიღოს მათ დაუყოვნებლივ.
ასე რომ, ჩვენ წასვლა პოსტების, პოსტების მწვერვალებით, რომ, იწყება მთელი რამ თავიდან, და მუშაობს.
მაგალითად, ორივე backquoting, პოსტების, parsing, შედეგების დამუშავება,
და ბრძანება, რომელიც, ალბათ, ძალიან ცოტა გამოყენება თქვენ დღეს.
Okay. ყველა უფლება umask.
მოდით შევხედოთ ამ ბრძანების აქ, umask 022. მაინტერესებს, რა რომ აკეთებს.
მოდით უბრალოდ აკრიფოთ umask არაფერი მას შემდეგ. 22. Okay.
022 და ამის გაკეთება კიდევ ერთხელ.
როგორც თქვენ ალბათ მიხვდა, umask ერთად არანაირი არგუმენტი გიჩვენებთ მიმდინარე ნიღაბი;
umask არგუმენტები ხდის, რომ, მაგრამ რომ იყო ერთი მე უკვე ჰქონდა.
რას 022 ნიშნავს?
ეს არის აქ დაცვის ფაილი.
ისინი განსაზღვრავენ, რომლებიც ნებადართულია წაკითხვის ან ჩაწერის ან შეასრულოს ფაილი.
დაცვის ასევე მოუწოდა უფლებები.
R დგას წაკითხული, w რომ დავწეროთ,
და x, რომელიც არ არის იქ, დგას შეასრულოს.
არსებობს 3 კატეგორიაში არ არსებობს.
ბოლო 3 ელემენტები კატეგორიის შესახებ. იმ ვრცელდება ჩემთვის, შესახებ.
ამ 3 აქ ვრცელდება ჯგუფი.
ფაილი ეკუთვნის 1 ჯგუფი, მომხმარებელს შეუძლია ეკუთვნის რამდენიმე ჯგუფი,
მაგრამ თუ მომხმარებელი არის ჯგუფი, რომელიც ამ ფაილის ეკუთვნის,
მაშინ ეს დაცვას შეეხება მას, თუ ის არ არის შესახებ.
და ამ ერთი ყველას.
ამ კატეგორიაში არის ურთიერთგამომრიცხავი.
მომხმარებლის დაცვის მიმართოს მას,
ჯგუფის დაცვის ვრცელდება ჯგუფის წევრები, გარდა მომხმარებელი,
და სხვა დაცვის მხოლოდ იმ ხალხის გარდა მოძებნა და ჯგუფის წევრები.
თუ არსებობს r ან aw ან x, ეს ნიშნავს, რომ დაცვის მინიჭება.
თუ არსებობს დეფისი, ეს იმას ნიშნავს, რომ ეს ასე არ არის.
იქ სინამდვილეში სხვა რამ, რაც შეიძლება ჩაიდოს აქ გარდა ამისა,
რომელიც მე არ მოხვდება ახლა.
Umask განსაზღვრავს ნაგულისხმევი ფაილი, რომელიც თქვენ შექმნით.
და როგორც ნიღაბი, ძირითადად, ის ამბობს, ბიტი, რომ თქვენ არ მითითებული.
როგორ აქვს ამ გახდეს ბიტი?
თუ ფიქრობთ, რომ თითოეული ეს როგორც octal ნომერი, ან,
ეს არის 1s bit, ეს არის 2s, ეს არის 4S.
ასე რომ, 0 მეშვეობით 7
აღწერს რა კომბინაცია r ს, w, და x-ის გაქვთ ამ 3
და მაშინ მსგავსი ნომრის ეს და შემდეგ ამ.
ასე რომ, 022 ნიშნავს 0 სხვა, 2 ჯგუფი, 2 შესახებ.
მაგრამ ეს არის ნიღაბი. ნიღაბი არის ის, რაც თქვენ არ გაქვთ.
მე ბოდიში. მე უბრალოდ მისცა თქვენ რამ არასწორი მიზნით.
ის პირველი 3. ამ 3 ხართ შესახებ, ეს -3 ჯგუფში, ამ 3 არის სხვა.
უკაცრავად მივეცი თქვენ ამ არასწორი მიზნით.
0, რომელიც არის პირველი იმ, არ არიან ღირებულება,
მაგრამ თუ ნომერი არ არის, ეს არის 0.
ეს ნიშნავს, რომ ყველა 3 ამ იქნებოდა დაშვებული.
გაითვალისწინეთ, რომ ამ კონკრეტულ შემთხვევაში x ნებადართული არ არის.
ამის მიზეზი ის არის, რომ ჭურვი შეუძლია განსაზღვრის
თუ არა ფაილი უნდა განხორციელდეს თუ არა.
რადგან ეს არ არის შესრულებადი ფაილი, ეს არ დააყენოთ x.
2 ნიშნავს, რომ ჩაწერის ნებართვა, მეორე კატეგორიაში აქ,
ერთი შუა, უარყო.
ასე რომ კიდევ ერთხელ, ეს არის რამ, რომ იგი უარყოფს.
ასევე, x ნებადართულია, მაგრამ ეს არ არის აქ იმიტომ, რომ ეს არ არის შესრულებადი
და ანალოგიურად, რომ სხვები.
ასე რომ საერთო umask.
კიდევ ერთი საერთო ერთი 700 - მისცეს თავს ყველაფერს და არავინ არაფერი.
და არსებობს სხვა შესაძლებლობები.
მე დაბრუნდეს, რომ. გამოყენება ისტორიაში მე შეგიძლიათ მოძებნოთ უკან, რომ lwh არსებობს.
Okay. ასე რომ, აქ, ეს არის ჭურვები.
Bash, მფლობელი, რომელიც არის სისტემის ანგარიშზე, შეგვიძლია გავაკეთოთ ყველაფერი.
Group და ყველას შეუძლია გააკეთოს, წაიკითხა ან შეასრულოს, მაგრამ არ წერენ.
ეს ერთი კი არ დაუშვებს მფლობელი დაწერა ეს.
თუ მესაკუთრე სურდა დაეწერა მას, სისტემის ანგარიშზე,
მან უნდა შეცვალოს დაცვის პირველი.
მაგრამ ერთხელ, umask ადგენს ნაგულისხმევი მიერ masking ის,
მითითებით ბიტი, რომ არ იქნება მითითებული.
ეს არის, როგორც წესი, ერთი თქვენი ინიციალიზაციისას ფაილი, რომელიც არის. Cshrc, რომ C-shell
ან. პროფილი Bourne ტიპის ჭურვები.
ეს შეიძლება იყოს სხვაგან ასევე, თუ არსებობს სხვა ინიციალიზაციისას ფაილი სისტემაში.
ყოველ შემთხვევაში, ეს umask.
არსებობს რაღაც სახის უცნაური აქ,
და ეს არის ის, თუ რატომ არის იქ ერთი ბრძანება არის ეს?
იმ შემთხვევაში, თუ მე წერა ამ, მინდა, რომ ეს ცვლადი, umask = გარკვეული მნიშვნელობა.
რატომ არის მთელი ბრძანება მხოლოდ ამ მიზნით?
მიზეზი ის არის, ეს მხოლოდ მიდის უკან წარმოშობის Unix.
Unix იყო მხოლოდ რამდენიმე პროგრამირების პროექტის Bell Labs 1970.
ადამიანი უბრალოდ მიიღო ერთად პროგრამა.
მათ არასდროს არ აპირებს, რომ გახდეს მსოფლიო ოპერაციული სისტემა.
სხვადასხვა ადამიანი წერდა სხვადასხვა ფიქრის გარეშე ძალიან ბევრი
თუ როგორ მიდიოდნენ უნდა იქნას გამოყენებული - საკმაოდ sketchy.
და ის მოვიდა ერთად, როგორც, რომ, და ეს მაინც მინდა, რომ ზოგიერთ ასპექტში.
ასე რომ ასახავს ისტორია და ჯერ კიდევ არსებობს ეს ხარვეზი და უცნაური ელემენტები მას.
Okay. შემდეგი აქ.
როგორც მე დავწერე ადრე, C-shell არ არის ნამდვილად გამოიყენება ძალიან ბევრი პროგრამირება,
მიუხედავად იმისა, რომ ეს შეიძლება იყოს.
იგი ახორციელებს უფრო ნელა, კიდევ ერთხელ შორის ვაჭრობის საგანი ინტერაქტიული გამოყენებისათვის,
რომელსაც აქვს მეტი დამუშავება ჩართული, გარდა სიჩქარე,
რომელიც შეიძლება გავაკეთოთ გარეშე გადამუშავება.
დამატებითი ფუნქციები დაემატა Bourne shell მიერ Korn და Bourne კვლავ ჭურვი
არ ჩანს, ნელი მათ ქვემოთ, და მე არ ვიცი, რატომ, რომ არის.
ეს შეიძლება იყოს უკეთესი, პროგრამირება, მაგრამ მე არ ვარ იმ პოზიციაში, რომ ვიცი.
სიჩქარე აქ რეალურად არ არის ისეთი დიდი გარიგება, თუმცა აღნიშნული.
ამის მიზეზი ის არის, რომ ჭურვი სკრიპტები რეალურად მიიღონ საკმაოდ სწრაფად.
თუ არ არის ბევრი ბრძანებები ისევე როგორც calculational პროგრამა,
თქვენ ალბათ არ ამას shell სკრიპტი.
ოპერატიულ არის საკმაოდ მარტივი და პირდაპირი.
პირობა, რომ მე გამოცდილი, რომ ძალიან ნელი
ჩართვა განმეორებითი განცხადებების ნელი ბრძანებები.
ადრე აღვნიშნე ნაკადი რედაქტორი sed. ეს ბრძანება ნელი.
თუ თქვენ შეასრულოს sed ბევრჯერ, თქვენ მიიღებთ ნელი სცენარი, მაგრამ ეს არ არის ჭურვი, რომ ნელი.
გაშვებული ის Bourne shell არ იქნება უფრო სწრაფად, ვიდრე გაშვებული ის C-shell,
მიუხედავად იმისა, რომ შესაძლოა, გარკვეული უპირატესობა არსებობს.
დამატებითი პროგრამირების შესაძლებლობები, მეორეს მხრივ,
მნიშვნელოვანი მიზეზი, რის გამოც თქვენ უნდა გამოიყენოთ Bourne ტიპის ჭურვები.
C-shell აქვს უცნაური თვისებები მას -
ის ფაქტი, რომ თქვენ არ იცით, თუ ცვლადი ჭურვი ცვლადი ან გარემოს ცვლადი.
ეს შეიძლება იყოს ძალიან დამაბნეველი.
ეს არც ისე ადვილია დაწერა
უბრალოდ ეფუძნება თქვენი გამოცდილება პროგრამირების სხვა ენებზე.
მე ვფიქრობ, თქვენ შეიძლება აღმოაჩინოთ Bourne ტიპის ჭურვები უფრო შეესაბამება თქვენი გამოცდილება.
ზოგიერთი სკრიპტები, თუმცა, შეიძლება ათასობით ხაზების სიგრძის.
ის, რომ მე ვნახე გამოიყენება ბებკი ოპერაციული სისტემები.
იმ შეუძლია შეასრულოს ძალიან ნელა, მაგრამ თქვენ არ აწარმოებს, ვინც ძალიან ხშირად.
ეს მხოლოდ მაშინ, როდესაც თქვენ აკეთებთ ბებკი,
და ეს მხოლოდ სისტემის მენეჯერი, რომელიც აკეთებს იმ რამ,
ასე რომ, ეს ნამდვილად არ არის ბევრი საკითხი.
ის, რომ ასობით ხაზების ხანგრძლივი რეალურად შეასრულოს საკმაოდ სწრაფად.
მოხსენიება ამ აქ, რა არის ის ბონუსები?
მე უკვე აღვნიშნეთ რამდენიმე მათგანი - მასივები, გათვლებით,
$ () გამოხატვის გათვლებით Bash shell,
სხვა სახის ბრძანება რიგებში.
არსებობს სხვადასხვა სახის ტესტირების ბრძანებები
მიერ, რომელიც შეგიძლიათ გააკეთოთ, პირობითი ტესტები არსებობა ფაილი ან სხვა რამ.
ბოლო აქ, ამ ბრძანების აქ.
რას და რატომ არავის გამოყენება?
printenv variablename.
ჩვენ ვიცით, რა printenv აკეთებს. იგი გვეუბნება, ღირებულება ცვლადი.
და printenv variablename არ გვეუბნებიან, ძალიან ბევრი, რადგან არ არსებობს ასეთი ცვლადი.
ცარიელი.
მაგრამ მოდით მივცეთ მას რაღაც მნიშვნელოვანი.
ეს არ არის იქაც. Okay. ვფიქრობ, არასდროს არ განმარტა, რომ.
მოდით უბრალოდ შეამოწმოს ჩემი გარემო.
ეს არის კიდევ ერთი ბრძანება, რომლითაც შეგიძლიათ შეამოწმოს თქვენი გარემო.
არსებობს კარგი ძველი რედაქტორი, ერთი ვნახეთ ადრე.
რას აკეთებთ?
აქ გვაქვს backquote გამოხატვის.
დამახსოვრება ეს არის C-shell.
ასე printenv რედაქტორებისათვის მოგვცემს ღირებულება რედაქტორი. ეს vi.
და მაშინ მითითებული, რომ ღირებულების ცვლადი, კომპლექტი ბრძანება.
ახლა, თუ echo $ a, მივიღებ vi.
რომ არ ჩანს საშინლად სასარგებლო.
თუმცა, ეს, ფაქტობრივად, არ აქვს მიზანი.
მას შემდეგ, რაც ჩვენ არ ვიცით თუ არა ცვლადი ჭურვი ცვლადი ან გარემოს ცვლადი
გამოყენებით დოლარის ნიშანი შეფასების სინტაქსი, ჩვენ შეგვიძლია გამოვიყენოთ printenv
დარწმუნდით, რომ ის გარემოს ცვლადი.
ასე რომ, თუ იყო shell ცვლადი რედაქტორი, ამ შემთხვევაში არ აქვს მიღებული იგი.
ეს მუშაობს მხოლოდ გარემოს ცვლადი.
თუ იყო shell ცვლადი და მინდოდა მისი ღირებულება,
მინდა რაღაც სხვა გზა ამის გაკეთება.
ერთი გზა უნდა გააკეთოს, რომ იქნება ამით კომპლექტი და piping.
ეს არის ერთ ერთი metacharacters, სპეციალური სიმბოლოები.
ის აგზავნის გამოშვება კომპლექტი რაღაც.
ვნახოთ რა შეგვიძლია ვიპოვოთ იქ.
არაფერი. Okay. მოდით უბრალოდ ვნახოთ რა იქ ყველა ერთად.
ეს იყო echo_style, ერთი ვთქვი ადრე. Okay, მოდით, რომ.
დამახსოვრება ვთქვი ადრე, echo_style
განსაზღვრავს გზა echo ბრძანება მიიღებს.
bsd დგას Berkeley სტანდარტული განაწილება.
ეს არის Berkeley Unix 1970.
ეს არის ერთ ერთი გზა, რომ echo შეიძლება აწარმოებს.
შექმნის echo_style რომ ღირებულების TC-shell გამოიწვევს echo მოიქცევა, რომ გზა.
ასე რომ მითითებული აქვს, მაგრამ მითითებული მხოლოდ იღებს shell ცვლადები.
ის არ იპოვოს რედაქტორი, რომელიც არ არის shell ცვლადი.
არაფერი.
ასე რომ ერთი გზა გამორჩევის მათ.
მაგრამ ის ფაქტი, რომ თქვენ უნდა გაიაროს ზოგიერთი უცნაური ბრძანება, როგორიცაა, რომ
განასხვავოს shell ცვლადები ან გარემოს ცვლადები
გვიჩვენებს სახის impractical ბუნების C-shell გარკვეული მიზნებისათვის.
და ახლა, ბოლოს და ბოლოს, შესაძლოა, მინიმუმ, ეს არის ადამიანი, გვერდები.
იმ, რომელიც მოგეხსენებათ, ადამიანი არის ბრძანება მოკლე სახელმძღვანელო.
კაცი გვერდებზე ჭურვი მძიმე წასაკითხი. ისინი ძალიან დიდი ხნის განმავლობაში.
ისინი ორგანიზებული ისე, რომ შეიძლება რთული მოვძებნოთ რას ვეძებთ.
ასე რომ, თუ ვეძებთ რაიმე მიზნით,
თქვენ შეიძლება არ იცით, თუ ამ მიზნით არის shell ცვლადი ან რაღაც,
ასე რომ თქვენ შეიძლება არ ვიცი სად უნდა ვეძებოთ იგი.
თქვენ შეგიძლიათ შეხედოთ სხვადასხვა strings, მაგრამ სიმები ხშირად მეორდება.
ასე რომ ზოგადად მძიმე წასაკითხი.
ჩვენ უბრალოდ შევხედე TC-shell man გვერდი ცოტა ადრე იპოვოს პოსტების ბრძანება.
ზოგიერთი რამ წავიდეთ სწრაფად.
ერთი მიდგომა ძებნის სიმებიანი.
თქვენ შეგიძლიათ გამოიყენოთ ძალაშია.
პეიჯერი აქვს slash ვეძებოთ ბრძანება ან სიმებიანი შიგნით მასალა ოპერაცია.
Man by default გამოიყენებს pagers, იყოს მეტი ან ნაკლები.
მე არ ვიცი, თუ თქვენ იცნობს მათ, მაგრამ იმ შეგიძლიათ ნახოთ ფაილი ნელ bit.
მე გამოყენებით ნაკლებად არიან ამ კონკრეტულ ფაილი გვაქვს აქ.
თქვენ შეგიძლიათ მოძებნოთ შიგნით არსებობს.
თქვენ შეგიძლიათ სცადოთ სხვადასხვა ძიება strings.
ასევე man გვერდების სხვადასხვა ოპერაციული სისტემები არ შეიძლება იყოს ერთი და იგივე.
ეს შეიძლება იყოს ცალკე გვერდებზე csh და tcsh.
ისინი არ არიან Mac, მაგრამ შეიძლება იყოს, თუ აღნიშნული ინფორმაცია ცალკე ბრძანებები.
იმ შემთხვევაში, თუ sh ნამდვილად არ მოვუწოდებთ Bash, იქ ალბათ იქნება ცალკე man გვერდზე.
ზოგიერთ სისტემები აქვს ცალკე კაცი გვერდებზე მხოლოდ C-shell ჩაშენებული ბრძანებები.
ზოგჯერ თუ გსურთ წაკითხული აღწერა ჩაშენებული ბრძანება
რომ ასევე გზას, როგორიცაა echo, თქვენ უნდა წაიკითხოთ კაცი გვერდზე რომ ბრძანება echo
რათა დადგინდეს, თუ იგი იმუშავებს, როგორც ინტეგრირებული ბრძანება
მაშინაც კი, თუ თქვენ არ მოუწოდებდა ჩაშენებული ბრძანება.
ეს პრობლემა ოპერაციული სისტემის ზოგადად, არა მხოლოდ ჭურვები,
თუმცა ჭურვები, კერძოდ, კაცი გვერდებზე საკმაოდ ხანგრძლივი,
ნაწილობრივ იმიტომ, რომ ისინი დასძინა სასარგებლო თვისებები, რომ მათ, რაც შეიძლება იყოს დადებითი.
Okay. არსებობს თუ არა რაიმე კითხვა? ნებისმიერი თემა გსურთ, რათა up?
არაფერს შესაბამისი აქ?
ისე, ეს იყო ძალიან ლამაზი საუბარი თქვენ ყველა.
იმედი მაქვს, რომ თქვენ გაქვთ რაიმე სემინარი
რომ სასარგებლო იქნება თქვენს მომავალ საქმიანობაში.
[CS50.TV]