sed და awk-ის გამოყენებით bash სკრიპტებში ტექსტის სრულად დასამუშავებლად, თქვენ უბრალოდ უნდა გამოიყენოთ ჩვეულებრივი ვირუსები. ამ ტიპის ინსტრუმენტების დანერგვა შეგიძლიათ იხილოთ სიტყვასიტყვით ყველგან, და მიუხედავად იმისა, რომ ისინი რეგულარულად რეგულირდება ანალოგიურად, ისინი ეფუძნება ერთსა და იმავე იდეებს და მუშაობის სხვადასხვა გარემოში არის განსაკუთრებული სიმღერა მათ უკან. აქ ვისაუბრებთ რეგულარულ განვითარებაზე, რომლებიც შესაფერისია Linux-ის ბრძანების ხაზის სკრიპტებში გამოსაყენებლად.

იდეების ეს მასალა, რომელიც რეგულარულ კვლევაშია შემოტანილი, აშუქებს მათ, ვინც შეიძლება არც კი იცოდეს რა არის. დავიწყოთ ამით თავიდანვე.

რა არის რეგულარული გამონათქვამები?

მდიდარი ადამიანებისთვის, როდესაც ისინი პირველად იწყებენ რეგულარულ სწავლას, მაშინვე ჩნდება აზრი, რომ მათ წინ არის სიმბოლოების დიდი დაგროვება. ალე წე, ცხადია, შორს არის საქმისგან. შეხედეთ, მაგალითად, ამ ჩვეულებრივ ვირაზს

ჩვენი აზრით, ეს არის აბსოლუტური ახალბედა გაგების გრძნობით, როგორც ეს ნასწავლი და აუცილებელიც არის :) თუ მთლად გასაგები არ ხართ, უბრალოდ წაიკითხეთ და ყველაფერი თავის ადგილზე დადგება.
რეგულარული ფორმატი არის შაბლონი, რომელიც შეიძლება გამოყენებულ იქნას ტექსტების გასაფილტრად sed ან awk პროგრამების გამოყენებით. შაბლონები მოიცავს პირველადი ASCII სიმბოლოებს, რომლებიც ცნობილია მეტახასიათების სახელით, რომლებიც განსაკუთრებულ როლს ასრულებენ, მაგალითად, საშუალებას აძლევს გამოიყენონ სიმბოლოთა სხვადასხვა ჯგუფი.

ჩვეულებრივი ვირუსების ტიპები

რეგულარული გამონათქვამების დანერგვა სხვადასხვა გარემოში, მაგალითად, მშობლიურ პროგრამირებაში Java, Perl და Python-ზე, Linux-ის ინსტრუმენტებში sed, awk და grep-ზე, ბევრი განსაკუთრებული ფუნქციაა. ეს მახასიათებლები მდგომარეობს ჩვეულებრივი ვირუსების დამუშავების ძრავებში, რომლებიც ეხება შაბლონების ინტერპრეტაციას.
Linux-ს აქვს ორი ჩვეულებრივი ვირუსის ძრავა:

• ძრავა, რომელიც მხარს უჭერს POSIX Basic Regular Expression (BRE).
• ძრავა, რომელიც მხარს უჭერს POSIX Extended Regular Expression (ERE) სტანდარტს.

Linux-ის კომუნალური პროგრამების უმეტესობა შეესაბამება, მინიმუმ, POSIX BRE სტანდარტს, მაგრამ ზოგიერთი კომუნალური პროგრამა (მათ შორის sed) არის გაგებული, როგორც მინიმუმ BRE სტანდარტის ქვეჯგუფი. ამ შეზღუდვის ერთ-ერთი მიზეზი არის ისეთი უტილიტების შემუშავების სურვილი, როგორც ჩანს ტექსტის დამუშავებაში.

POSIX ERE სტანდარტი ხშირად გამოიყენება ენის პროგრამირებაში. ის საშუალებას გაძლევთ გაიზარდოთ დიდი რაოდენობით ხილი რეგულარული ვირუსების განვითარების დროს. მაგალითად, შეიძლება არსებობდეს სიმბოლოების სპეციალური თანმიმდევრობა შაბლონებისთვის, რომლებიც ხშირად იძებნება მიმდებარე სიტყვების ტექსტში ან რიცხვების სიმრავლეში. Awk მხარს უჭერს ERE სტანდარტს.

რეგულარული გამონათქვამების შემუშავების მრავალი გზა არსებობს, რაც დამოკიდებულია როგორც პროგრამისტის აზრებზე, ასევე იმ ძრავის მახასიათებლებზე, რომლითაც ისინი წარმოიქმნება. ადვილი არ არის უნივერსალური რეგულარული გამონათქვამების დაწერა, რომლებიც გასაგები იქნება ნებისმიერი ძრავისთვის. ამიტომ, ჩვენ ყურადღებას გავამახვილებთ ყველაზე ხშირად ბოროტად გამოყენებული რეგულარულ გამონათქვამებზე და განვიხილავთ მათი განხორციელების სპეციფიკას sed და awk-ისთვის.

POSIX BRE-ის რეგულარული გამონათქვამები

შესაძლოა, უმარტივესი BRE შაბლონი არის რეგულარული გამოხატულება ტექსტში სიმბოლოების ზუსტი თანმიმდევრობის საპოვნელად. იაკის ღერძი ჰგავს მწკრივის ძიებას sed და awk-ში:

$ echo "ეს ტესტი" | sed -n "/test/p" $ echo "ეს ტესტი" | awk "/test/(ბეჭდვა $0)"

მოძებნეთ ტექსტი შაბლონისთვის sed-ში

მოძებნეთ ტექსტი შაბლონებისთვის awk-ში

შეიძლება აღინიშნოს, რომ მოცემული ნიმუშის ძიება სრულდება მწკრივში ტექსტის ზუსტი მდებარეობის განსაზღვრის გარეშე. გარდა ამისა, შეყვანის რაოდენობას არ აქვს მნიშვნელობა. მას შემდეგ, რაც დავალებების რეგულარული ტექსტი მოიძებნება მწკრივის ნებისმიერ ადგილას, მწკრივი განიხილება თანმიმდევრულად და გადადის შემდგომი დამუშავებისთვის.

რეგულარულ გამონათქვამებთან მუშაობისას, თქვენ უნდა გამოიყენოთ ის, რაც მგრძნობიარეა სიმბოლოების შემთხვევის მიმართ:

$ echo "ეს ტესტი" | awk "/Test/(print $0)" $ echo "ეს ტესტია" | awk "/test/(ბეჭდვა $0)"

რეგულარული გამონათქვამები მგრძნობიარეა რეესტრის მიმართ

უპირველეს ყოვლისა, წარმატებები არ ყოფილა, რადგან სიტყვა "ტესტი", რომელიც დიდი ასოებით იწყება, ტექსტში არ ჩანს. სხვა ადამიანმა, დიდი მწერლების მიერ დაწერილი სიტყვების ძიებაში, მსგავსი თანმიმდევრობა გამოავლინა.

ჩვეულებრივ გამონათქვამებში შეგიძლიათ გამოიყენოთ არა მხოლოდ ასოები, არამედ რიცხვებიც:

$ echo "ტიმს ჰყავს 2 სიმამრი" | awk "/test 2/(ბეჭდვა $0)"

მოძებნეთ ტექსტის ფრაგმენტი დაკარგული რიცხვების გამოსასწორებლად

კლირენგები მუშავდება რეგულარული გამონათქვამების ძრავით, როგორც სტანდარტული ნიშნები.

სპეციალური პერსონაჟები

როდესაც იცვლება სხვადასხვა სიმბოლოები, რეგულარული გამონათქვამები მოითხოვს განსაკუთრებულ ზომებს. ამრიგად, არსებობს გარკვეული სპეციალური სიმბოლოები ან მეტაგმირები, რომელთა გამოყენება შაბლონში განსაკუთრებულ მიდგომას მოითხოვს. Stink Axis:

თუ რომელიმე მათგანი საჭიროა შაბლონში, საჭიროა მისი ეკრანიზაცია უკანა ხაზის მიღმა - .

მაგალითად, თუ თქვენ უნდა იცოდეთ დოლარის ნიშანი ტექსტში, თქვენ უნდა შეიტანოთ იგი შაბლონში, გაქცევის სიმბოლოს წინ. ვთქვათ, არის ფაილი myfile შემდეგი ტექსტით:

ჯიბეზე 10$ დევს

დოლარის ნიშნის იდენტიფიცირება შესაძლებელია ამ ნიმუშის გამოყენებით:

$awk "/$/(ბეჭდვა $0)" ჩემი ფაილი

მოძებნეთ შაბლონი სპეციალური სიმბოლოსთვის

გარდა ამისა, ბრინჯის საყელო ლენტები ასევე განსაკუთრებული სიმბოლოა, ასე რომ, თუ მისი დამატება გჭირდებათ შაბლონში, ის ასევე უნდა იყოს დამალული. როგორც ჩანს, ორი ხაზი მიდის ერთმანეთის მიყოლებით:

$ echo "განსაკუთრებული სიმბოლოა" | awk "/\/(დაბეჭდვა $0)"

უკანა ხაზის სკრინინგი

თუ გსურთ, რომ წინ დახრილი არ იყოს შეტანილი სპეციალური სიმბოლოების სიაში, შეეცადეთ დააჩქაროთ ის ჩვეულებრივ ენაზე, რომელიც დაწერილია sed ან awk-ისთვის, რაც მიგვიყვანს ბოლომდე:

ნიმუშის წინ დახრილობა არასწორად არის შესწორებული

თუ ეს გჭირდებათ, თქვენ ასევე გჭირდებათ მისი ეკრანიზაცია:

$ echo "3/2" | awk "///(ბეჭდვა $0)"

წინ დახრილობის სკრინინგი

იაკირნის სიმბოლოები

არსებობს ორი სპეციალური სიმბოლო ნიმუშის დასაკავშირებლად ტექსტის სერიის დასაწყისთან ან დასასრულთან. სიმბოლო "cap" საშუალებას გაძლევთ აღწეროთ სიმბოლოების თანმიმდევრობა, რომლებიც გვხვდება ტექსტის რიგების დასაწყისში. თუ ნიმუში გამოჩნდება სერიის სხვა ადგილას, ჩვეულებრივი ნიმუში არ რეაგირებს მასზე. ეს სიმბოლო ასე გამოიყურება:

$ echo "კეთილი იყოს თქვენი მობრძანება likegeeks ვებსაიტზე" | awk "/^likegeeks/(ბეჭდვა $0)" $ echo "likegeeks website" | awk "/^likegeeks/(ბეჭდვა $0)"

მოძებნეთ ნიმუში მწკრივის კუბზე

^ სიმბოლო გამოიყენება მწკრივის დასაწყისში ნიმუშის მოსაძებნად, ამ შემთხვევაში გათვალისწინებულია სიმბოლოთა რეესტრიც. მიკვირს, როგორ კეთდება ეს ტექსტური ფაილის დამუშავებისას:

$awk "/^this/(print $0)" myfile

მოძებნეთ ნიმუში მწკრივის დასაწყისში ტექსტში ფაილიდან

თუ იყენებთ sed-ს, თუ თავსახურს აქ შაბლონის შუაში მოათავსებთ, ის გამოჩნდება, როგორც ნებისმიერი სხვა ძირითადი სიმბოლო:

$ echo "ეს ^ არის ტესტი" | sed -n "/s ^/p"

კრიშკა, რა იცით სედში შაბლონის შესახებ?

awk-ში, იგივე შაბლონის გამოყენებისას, ამ სიმბოლოს გაქცევა სჭირდება:

$ echo "ეს ^ არის ტესტი" | awk "/s ^/(დაბეჭდვა $0)"

კრიშკა, რა იცით awk-ის შაბლონის შესახებ?

ტექსტის ფრაგმენტების მოსმენის შემდეგ, რომლებიც ნაპოვნი იქნა მწკრივზე, ჩვენ დავახარისხეთ იგი. რა უნდა იცოდეთ რა კეთდება რიგის ბოლოს?

ეს დაგვეხმარება დოლარის ნიშანში - $, რომელიც არის მწკრივის დასასრულის წამყვანი სიმბოლო:

$ echo "ეს ტესტი" | awk "/test$/(ბეჭდვა $0)"

მოძებნეთ ტექსტი, რომ ნახოთ რა არის მწკრივის ბოლოს

ერთსა და იმავე შაბლონში შეგიძლიათ გამოიყენოთ შეურაცხმყოფელი სიმბოლოები. მოდით შევხედოთ ფაილს myfile , ნაცვლად იმისა, რაც ნაჩვენებია ქვემოთ, შემდეგი რეგულარული გამონათქვამის გამოყენებით:

$ awk "/^ეს არის test$/(დაბეჭდვა $0)" myfile

შაბლონი, რომელშიც ვიკორისტანი არის სპეციალური სიმბოლოები რიგის დასაწყისში და ბოლოს

როგორც ჩანს, თარგი პასუხობდა მხოლოდ რიგს, რომელიც ფაქტობრივად შეესაბამება სიმბოლოების თანმიმდევრობის და მათი განლაგების ამოცანას.

ღერძი, წამყვანის სიმბოლოების გამოყენებით, გაფილტრეთ ცარიელი რიგები:

$awk "!/^$/(დაბეჭდვა $0)" myfile

ამ თარგში გამოვიყენეთ ჯვრის სიმბოლო, სეტყვის ნიშანი - ! . უცვლელად, ასეთ შაბლონს მოჰყვება რიგების ძებნა, რათა არ დადგეს არაფერი კუბსა და მწკრივის ბოლოს შორის და შედეგად, დახაზულია სხვა რიგების გამოძახების ნიშანი, რომლებიც არ შეესაბამება. ამ ნიმუშს.

წერტილის სიმბოლო

წერტილი გამოიყენება რომელიმე ერთი სიმბოლოს ან მწკრივის შებრუნების სიმბოლოს მოსაძებნად. ჩვენ გადავცემთ ფაილს myfile ამ ჩვეულებრივ ვირუსს, ნაცვლად იმისა, რაც ნაჩვენებია ქვემოთ:

$awk "/.st/(ბეჭდვა $0)" myfile

Vikoristannya მიუთითებს რეგულარულ გამონათქვამებში

როგორც ნაჩვენები მონაცემებიდან ჩანს, შაბლონს მხარს უჭერს ფაილის მხოლოდ პირველი ორი სტრიქონი, რადგან შეუძლებელია სიმბოლოების "st" თანმიმდევრობის შეცვლა, რომელსაც წინ უძღვის სხვა სიმბოლო, ხოლო მესამე რიგის იგივე მიმდევრობა. არ უნდა შეიცვალოს და მეოთხეში, მაგრამ იყოს რიგის ყურზე.

სიმბოლოების კლასები

წერტილი მიუთითებს რომელიმე ერთ სიმბოლოზე, მაგრამ აუცილებელია თუ არა უკეთესად განვსაზღვროთ სიმბოლოების ნაკრები, რას ეძებთ? ეს სიტუაცია შეიძლება სწრაფად აიხსნას სიმბოლოების კლასებით.

ამ მიდგომით, თქვენ შეგიძლიათ მოაწყოთ ძიება ნებისმიერი სიმბოლოს მოცემული ნაკრებიდან. სიმბოლოების კლასის აღწერისთვის გამოიყენება კვადრატული მკლავები - :

$awk "/th/(ბეჭდვა $0)" ჩემი ფაილი

პერსონაჟების კლასის აღწერა ჩვეულებრივ ენაზე

აქ ვეძებთ th სიმბოლოების თანმიმდევრობას, რომლის წინ არის o სიმბოლო ან i სიმბოლო.

კლასები ჩნდება წინასწარ ვერბალურიც კი, რადგან ისინი მთავრდება ფრაზით, რომელიც შეიძლება დაიწყოს როგორც დიდი, ასევე პატარა ასოებით:

$ echo "ce є" | awk "/his is a test/(print $0)" $ echo "ეს არის ტესტი" | awk "/his is a test/(print $0)"

მოძებნეთ სიტყვები, რომლებიც შეიძლება დაიწყოს მცირე ან დიდი ასოებით

პერსონაჟების კლასები არ არის გამოყოფილი ასოებით. აქ შეგიძლიათ გამოიყენოთ სხვა სიმბოლოები. წინასწარ არ შეიძლება ითქვას, რა სიტუაციაშია საჭირო კლასი - ყველაფერი დევს ცოდნაში, რომელიც მიმოქცევაშია.

პერსონაჟების კლასების სია

სიმბოლოების კლასები შეიძლება შეიცვალოს ზემოთ აღწერილი მიზნებისთვის. და იმის ნაცვლად, რომ მოძებნოთ სიმბოლოები, რომლებიც შედის კლასში, შეგიძლიათ მოაწყოთ ძიება ყველაფრისთვის, რაც არ შედის კლასში. ამ ტიპის რეგულარული გამოვლენის ქცევის მისაღწევად, თქვენ უნდა მოათავსოთ ^ ნიშანი კლასის სიმბოლოების სიის წინ. ეს ასე გამოიყურება:

$ awk "/[^oi]th/(ბეჭდვა $0)" ჩემი ფაილი

მოძებნეთ სიმბოლოები, რომლებიც არ შედის კლასში

ამ შემთხვევაში ვიპოვით th სიმბოლოების თანმიმდევრობას, რომელსაც წინ არც o და არც i.

პერსონაჟების დიაპაზონი

პერსონაჟების კლასებში შეგიძლიათ აღწეროთ სიმბოლოების დიაპაზონი, ვიკორი და ტირე:

$awk "/st/(ბეჭდვა $0)" ჩემი ფაილი

კლასში სიმბოლოების დიაპაზონის აღწერა

ამ აპლიკაციაში რეგულარული გამოთქმა რეაგირებს სიმბოლოების "st" თანმიმდევრობაზე, რომლის წინ არის ნებისმიერი სიმბოლო, დალაგებული ანბანური თანმიმდევრობით, სიმბოლოებს "e" და "p" შორის.

დიაპაზონები შეიძლება შეიქმნას რიცხვებიდან:

$ echo "123" | awk "//" $ echo "12a" | აუკ "//"

რეგულარული ვირაზი სამი ნომრის მოსაძებნად

სიმბოლოთა კლასი შეიძლება შეიცავდეს რამდენიმე დიაპაზონს:

$awk "/st/(ბეჭდვა $0)" ჩემი ფაილი

სიმბოლოების კლასი, რომელიც შედგება მრავალი დიაპაზონისგან

თქვენ შეგიძლიათ მარტივად იპოვოთ "st"-ის ყველა მიმდევრობა, რომელსაც წინ უძღვის სიმბოლოები a-f და m-z დიაპაზონებიდან.

სიმბოლოების სპეციალური კლასები

BRE-ს აქვს სიმბოლოების სპეციალური კლასები, რომლებიც შეიძლება გამოყენებულ იქნას რეგულარული გამონათქვამების დაწერისას:

• [[:alpha:]] - წარმოადგენს ნებისმიერ ანბანურ სიმბოლოს, რომელიც დაწერილია დიდი ან პატარა ასოებით.
• [[:alnum:]] - წარმოადგენს ან ნებისმიერ ალფანუმერულ სიმბოლოს, ან სიმბოლოებს დიაპაზონში 0-9, A-Z, a-z.
• [[:blank:]] - წარმოადგენს სივრცეს და ჩანართის ნიშანს.
• [[:digit:]] - ნებისმიერი ციფრული სიმბოლო 0-დან 9-მდე.
• [[:upper:]] - ანბანის სიმბოლოები დიდი ასოებით - A-Z.
• [[:lower:]] - ანბანური სიმბოლოები მცირე ასოებით - a-z.
• [[:print:]] - მიუთითებს ნებისმიერ სიმბოლოზე, რომელიც იბრძვის.
• [[:punct:]] - წარმოადგენს გამყოფ ნიშნებს.
• [[:space:]] - ინტერვალის სიმბოლოები, სივრცე - სივრცე, ჩანართი, სიმბოლოები NL, FF, VT, CR.

თქვენ შეგიძლიათ გამოიყენოთ სპეციალური კლასები შაბლონებში, როგორიცაა:

$ echo "abc" | awk "/[[:alpha:]]/(ბეჭდვა $0)" $ echo "abc" | awk "/[[:digit:]]/(ბეჭდვა $0)" $ echo "abc123" | awk "/[[:digit:]]/(დაბეჭდვა $0)"

სიმბოლოების სპეციალური კლასები რეგულარულ გამონათქვამებში

სიმბოლო "ვარსკვლავი"

თუ შაბლონში ათავსებთ ვარსკვლავს სიმბოლოს შემდეგ, ეს ნიშნავს, რომ რეგულარული გამოხატულება ნიშნავს, რომ სიმბოლო ზედიზედ ჩნდება რამდენჯერმე, მათ შორის იმ სიტუაციის ჩათვლით, როდესაც სიმბოლო არის რიგში ყოველ დღე.

$ echo "ტესტი" | awk "/tes*t/(ბეჭდვა $0)" $ echo "tessst" | awk "/tes*t/(ბეჭდვა $0)"

Vykoristannya სიმბოლო * ჩვეულებრივ ვირაზახში

ეს ნიმუშიანი სიმბოლო გამოიყენება სიტყვებთან მუშაობისთვის, რომლებშიც მუდმივად არის დრუკარსკის კეთილგანწყობა, ან სიტყვებისთვის, რომლებიც სწორი მართლწერის სხვადასხვა ვარიანტს იძლევა:

$ echo "მომწონს მწვანე ფერი" | awk "/colou*r/(print $0)" $ echo "მომწონს მწვანე ფერი" | awk "/colou*r/(ბეჭდვა $0)"

მოძებნეთ სიტყვა, რომელსაც აქვს სხვადასხვა ორთოგრაფიული ვარიაციები

ამ შემთხვევაში, სიტყვა „ფერი“ და სიტყვა „ფერი“ ერთნაირი რეგულარული გამოთქმით რეაგირებს. ეს მართალია, რადგან სიმბოლო "u", რომლის შემდეგ არის ვარსკვლავი, შეიძლება იყოს ყოველდღიური, ან მოგვიანებით გახდება რამდენჯერმე.

შესაძლებელია სხვა ფერიც, რომელიც ვარსკვლავის სიმბოლოს თავისებურებების გამო წერტილთან კომბინაციაში მდგომარეობს. ეს კომბინაცია საშუალებას გაძლევთ რეგულარულად განსაზღვროთ რეაქციები ნებისმიერი რაოდენობის სიმბოლოზე:

$ awk "/this.*test/(print $0)" myfile

შაბლონი, რომელიც პასუხობს სიმბოლოების ნებისმიერ რაოდენობას

ამ შემთხვევაში, არ აქვს მნიშვნელობა რამდენი სიმბოლო გამოჩნდება სიტყვებს "ეს" და "ტესტს" შორის.

ვარსკვლავი შეიძლება გამოყენებულ იქნას სიმბოლოების კლასებთან ერთად:

$ echo "st" | awk "/s*t/(ბეჭდვა $0)" $ echo "sat" | awk "/s*t/(ბეჭდვა $0)" $ echo "set" | awk "/s*t/(ბეჭდვა $0)"

Vykoristannya zirochki სიმბოლოების კლასებით

სამივე აპლიკაციაში არის რეგულარული გამოხატულება, სიმბოლოების კლასის შემდეგ პატარა ვარსკვლავი ნიშნავს, რომ მოიძებნება რამდენიმე სიმბოლო "a" ან "e" და ასევე, თუ ისინი ვერ მოიძებნება, მწკრივი დაემთხვევა მოცემულ შაბლონს. .

POSIX ERE-ს რეგულარული გამონათქვამები

POSIX ERE შაბლონები, რომლებიც მხარს უჭერენ Linux უტილიტის მოქმედებებს, შეიძლება შეიცავდეს დამატებით სიმბოლოებს. როგორც უკვე ითქვა, awk მხარს უჭერს ამ სტანდარტს, მაგრამ sed ღერძი არა.

აქ განვიხილავთ სიმბოლოებს, რომლებიც ყველაზე ხშირად გამოიყენება ERE- შაბლონებში, რომლებიც გამოგადგებათ მძლავრი რეგულარული გამონათქვამების შექმნისას.

▍ დენის ნიშანი

დენის ნიშანი მიუთითებს, რომ წამყვანი სიმბოლო შეიძლება გამოჩნდეს ტექსტში ერთხელ ან საერთოდ არ გამოჩნდეს. ეს სიმბოლო გამეორების ერთ-ერთი მეტასიმბოლაა. კონდახის ღერძი:

$ echo "tet" | awk "/tes?t/(ბეჭდვა $0)" $ echo "ტესტი" | awk "/tes?t/(ბეჭდვა $0)" $ echo "test" | awk "/tes?t/(დაბეჭდვა $0)"

კვების ნიშანი ჩვეულებრივ ვირაზაში

როგორც ჩანს, მესამე ტიპის ასო "s"-ს აქვს ორი შეკუმშვა და სიტყვა "ტესტი" რეგულარულად არ პასუხობს სიტყვას "ტესტი".

საკვების ნიშანი შეიძლება გაერთიანდეს სიმბოლოების კლასებთან:

$ echo "tst" | awk "/t?st/(ბეჭდვა $0)" $ echo "ტესტი" | awk "/t?st/(ბეჭდვა $0)" $ echo "გემოვნება" | awk "/t?st/(ბეჭდვა $0)" $ echo "taest" | awk "/t?st/(ბეჭდვა $0)" $ echo "ტესტი" | awk "/t?st/(დაბეჭდვა $0)"

კვების ნიშნების და სიმბოლოების კლასი

იმის გამო, რომ ზედიზედ არ არის სიმბოლოები ზედიზედ, ან ერთი მათგანი გამოჩნდება მხოლოდ ერთხელ, რეგულარული გამოთქმა ითხოვს, რომ სიტყვა დასრულდეს ორი სიმბოლოთი და სისტემა აღარ ცნობს ტექსტის თავსებადობას ნიმუშთან.

▍ პლუს სიმბოლო

შაბლონში "პლუს" სიმბოლო მიუთითებს მათზე, რომლებიც რეგულარულად ჩნდება სიტუაციებში, როდესაც წამყვანი სიმბოლო გამოჩნდება ტექსტში ერთხელ ან მეტჯერ. როდესაც სიმბოლო არსებობს, ეს კონსტრუქცია არ პასუხობს:

$ echo "ტესტი" | awk "/te+st/(ბეჭდვა $0)" $ echo "ტესტი" | awk "/te+st/(ბეჭდვა $0)" $ echo "tst" | awk "/te+st/(ბეჭდვა $0)"

პლუს სიმბოლო რეგულარულ გამონათქვამებში

ამ შემთხვევაში, რადგან სიტყვაში არ არის სიმბოლო "e", ტექსტში არ არის ნაპოვნი რეგულარული გამონათქვამების ძრავები, რომ შეესაბამებოდეს შაბლონს. პლუს სიმბოლო მუშაობს სიმბოლოების კლასებთან - ეს სიმბოლო ჰგავს ვარსკვლავს და საკვების ნიშანს:

$ echo "tst" | awk "/t+st/(ბეჭდვა $0)" $ echo "ტესტი" | awk "/t+st/(ბეჭდვა $0)" $ echo "ტესტი" | awk "/t+st/(ბეჭდვა $0)" $ echo "teeast" | awk "/t+st/(ბეჭდვა $0)"

პლუს ნიშანი და სიმბოლოების კლასი

თუ მწკრივს აქვს რაიმე სიმბოლო კლასიდან, ტექსტი იქნება შესაფერისი შაბლონი.

▍ხვეული მკლავები

თაღოვანი ფორმები, რომლებიც შეიძლება გამოყენებულ იქნას ERE- შაბლონებში, მსგავსია ზემოთ განხილული სიმბოლოების, მაგრამ საშუალებას გაძლევთ უფრო ზუსტად მიუთითოთ შეყვანის საჭირო რაოდენობა წამყვან სიმბოლოზე. განლაგება შესაძლებელია ორ ფორმატში:

• n - რიცხვი, რომელიც განსაზღვრავს მოძიებული შენატანების ზუსტ რაოდენობას
• n, m არის ორი რიცხვი, რომლებიც ინტერპრეტირებულია შემდეგნაირად: „მინიმუმ n-ჯერ, მაგრამ არა უმეტეს m“.

პირველი ვარიანტის კონდახის ღერძი:

$ echo "tst" | awk "/te(1)st/(ბეჭდვა $0)" $ echo "ტესტი" | awk "/te(1)st/(ბეჭდვა $0)"

ფიგურული თაღები შაბლონებში, მოძებნეთ ჩანაწერების ზუსტი რაოდენობა

awk-ის ძველ ვერსიებში საჭირო იყო --re-interval ბრძანების სტრიქტორის გამოყენება, რათა პროგრამამ ამოიცნო ინტერვალები რეგულარულ გამონათქვამებში, მაგრამ ახალ ვერსიებში ეს არ არის საჭირო.

$ echo "tst" | awk "/te(1,2)st/(ბეჭდვა $0)" $ echo "ტესტი" | awk "/te(1,2)st/(ბეჭდვა $0)" $ echo "ტესტი" | awk "/te(1,2)st/(print $0)" $ echo "teeest" | awk "/te(1,2)st/(ბეჭდვა $0)"

ინტერვალი, ამოცანები ხვეულ მკლავებზე

ამ შემთხვევაში, სიმბოლო "e" უნდა გამოჩნდეს ზედიზედ 1 ან 2-ჯერ, ამიტომ ის რეგულარულად რეაგირებს ტექსტზე.

თაღოვანი ფორმები შეიძლება გაერთიანდეს ნიშნების კლასებთან. აქ არის პრინციპები, რომლებიც თქვენ უკვე იცით:

$ echo "tst" | awk "/t(1,2)st/(ბეჭდვა $0)" $ echo "ტესტი" | awk "/t(1,2)st/(ბეჭდვა $0)" $ echo "ტესტი" | awk "/t(1,2)st/(ბეჭდვა $0)" $ echo "teeast" | awk "/t(1,2)st/(ბეჭდვა $0)"

იარაღის ფიგურები და სიმბოლოების კლასები

შაბლონი ტექსტზე რეაგირებს ისევე, როგორც სიმბოლო a ან სიმბოლო e გამოჩნდება ერთხელ ან ორჯერ.

▍ ლოგიკური "abo" სიმბოლო

სიმბოლო | - ვერტიკალური ბრინჯი ჩვეულებრივ გამოთქმებში უფრო ლოგიკურია, ვიდრე "აბო". ასეთი ნიშნით გამოყოფილი ფრაგმენტების რეგულარულად ძიება, ტექსტის მნიშვნელოვანი ანალიზების გატარება მსგავსია ფრაგმენტების კანის მსგავსი ტიპის. ღერძის კონდახი:

$ echo "ეს ტესტი" | awk "/test|exam/(print $0)" $ echo "Tim exam" | awk "/test|გამოცდა/(ბეჭდვა $0)" $ echo "რაც არ არის ძალიან მდიდარი" | awk "/test|გამოცდა/(დაბეჭდვა $0)"

"აბო" უფრო ლოგიკურია რეგულარულ გამონათქვამებში

ამ შემთხვევაში, არსებობს ტექსტის ძიების რეგულარული ნიმუში სიტყვებით „ტესტი“ ან „გამოცდა“. ყურადღება მიაქციეთ მათ შორის ფრაგმენტები ნიმუში და სიმბოლო, რომელიც ჰყოფს მათ | შენი ბრალი არ არის, მაგრამ გაწმენდები.

რეგულარული გამონათქვამების ფრაგმენტები შეიძლება დაჯგუფდეს მრგვალი თაღების ფორმირებით. როდესაც აჯგუფებთ სიმბოლოების თანმიმდევრობას, სისტემა განიხილება, როგორც პირველადი სიმბოლო. შემდეგ, მაგალითად, შესაძლებელი იქნება მის წინ მეტახასიათების გამეორება. ღერძი ასე გამოიყურება:

$ echo "Like" | awk "/Like(Geeks)?/(ბეჭდვა $0)" $ echo "LikeGeeks" | awk "/Like(Geeks)?/(ბეჭდვა $0)"

რეგულარული ვირუსების ფრაგმენტების დაჯგუფება

ამ აქციებზე სიტყვა "Geeks" მოთავსებულია მრგვალ ტაძრებში, რასაც მოჰყვება ძალაუფლების სიმბოლო. როგორც ჩანს, კვების ნიშანი ნიშნავს "0 ან 1 გამეორებას", რის შედეგადაც ის რეგულარულად რეაგირებს როგორც "Like" და "LikeGeeks" რიგზე.

პრაქტიკული დუნდულები

მას შემდეგ, რაც ჩვენ ვისწავლეთ რეგულარული გამონათქვამების საფუძვლები, დადგა დრო, ვიმუშაოთ მათ დახმარებაზე.

▍ განაახლეთ ფაილების რაოდენობა

მოდით დავწეროთ bash სკრიპტი, რომელიც ინახავს ფაილებს, რომლებიც მდებარეობს დირექტორიაში, რომელიც ჩაწერილია PATH ჩანაწერში. ფულის გამომუშავებისთვის, ჯერ უნდა ჩამოაყალიბოთ დირექტორიების გზების სია. ჩვენ დაგეხმარებით სედის დახმარებით, გაორმაგების ჩანაცვლება კლირინგებით:

$echo $PATH | sed "s/:/ /g"

ჩანაცვლების ბრძანება მხარს უჭერს რეგულარულ გამონათქვამებს, როგორც შაბლონებს ტექსტის საძიებლად. ამ შემთხვევაში, ყველაფერი ძალიან მარტივია, ჩვენ ვეძებთ ორმაგ სიმბოლოს, მაგრამ აქ არავის აინტერესებს ვიკორიზმი და სჯობს სხვაგვარად მოვიქცეთ - ყველაფერი უნდა იყოს შენახული კონკრეტულ ამოცანაში.
ახლა თქვენ უნდა გაიაროთ არჩეული სია მარყუჟში და დააწკაპუნოთ რამდენიმე ფაილის შესანახად. სცენარის ორიგინალური სქემა ასეთი იქნება:

Mypath=$(echo $PATH | sed "s/:/ /g") დირექტორიებისთვის $mypath-ზე შესრულებულია

ახლა მოდით დავწეროთ საბოლოო ტექსტი სკრიპტზე, ls ბრძანების გამოყენებით, რათა აჩვენოს ინფორმაცია თითოეულ დირექტორიაში ფაილების რაოდენობის შესახებ:

#!/bin/bash mypath=$(echo $PATH | sed "s/:/ /g") count=0 დირექტორიაში $mypath for check=$(ls $directory) ელემენტისთვის $check do count=$ [ $count + 1 ] გაკეთდა ექო "$directory - $count" count=0 შესრულებულია

სკრიპტის გაშვებისას შეიძლება აღმოაჩინოთ, რომ PATH-ში ზოგიერთი დირექტორია არ არის შენახული, მაგრამ შეიძლება ვერ შეძლოთ ფაილების შენახვა სხვა დირექტორიაში.

ფაილის შენახვა

ამ კონდახის მთავარი ღირებულება მდგომარეობს იმაში, რომ სწორედ ამ მიდგომის გამოყენებით, თქვენ შეგიძლიათ გადალახოთ კიდევ უფრო უარესი პრობლემები. ყველა მათგანი შეინახება თქვენი საჭიროების მიხედვით.

▍ შეამოწმეთ თქვენი ელფოსტის მისამართი

არის ვებსაიტები რეგულარული საკვანძო სიტყვების დიდი კოლექციებით, რომლებიც საშუალებას გაძლევთ შეამოწმოთ ელექტრონული ფოსტის მისამართები, ტელეფონის ნომრები და ა.შ. თუმცა, ერთი მარჯვნივ მზად არის აიღოს, მეორე კი თავად შექმნა. ასე რომ, ჩვენ დავწერთ რეგულარულ ელ.წერილს თქვენი ელ.ფოსტის მისამართის შესამოწმებლად. დავიწყოთ გამომავალი მონაცემების ანალიზით. ღერძი, მაგალითად, არის მისამართი:

[ელფოსტა დაცულია]

მომხმარებლის სახელი, მომხმარებლის სახელი, შეიძლება შედგებოდეს ალფანუმერული და სხვა სიმბოლოებით. ზოკრემა, წერტილი, ტირე, ისრის ნიშანი, პლუს ნიშანი. მფლობელის სახელს მოსდევს ნიშანი @.

ამ ცოდნის მიღების შემდეგ, დროა ჩამოვაყალიბოთ რეგულარული გამოხატულება მარცხენა ნაწილიდან, რომელიც ემსახურება კორისტუვაჩის სახელს. ჩვენში გაჩენილი ღერძი:

^(+)@

ახლა - მასპინძლის სახელი - მასპინძლის სახელი. აქ არის თავად ძირითადი წესები, კორისტუვაჩის სახელით, ასე რომ, შაბლონი ასე გამოიყურება:

(+)

უმაღლესი დონის დომენური სახელები ექვემდებარება სპეციალურ წესებს. შეიძლება იყოს არაანბანური სიმბოლოები, რომელთაგან შეიძლება იყოს არანაკლებ ორი (მაგალითად, ასეთი დომენები მოითხოვს ლოკალურ კოდს) და არაუმეტეს ხუთი. ეს ყველაფერი ნიშნავს, რომ მისამართის დარჩენილი ნაწილის გადამოწმების შაბლონი იქნება ასეთი:

.({2,5})$

შეგიძლიათ წაიკითხოთ ასე: ”ჯერ არის წერტილი, შემდეგ არის 2-დან 5 ანბანური სიმბოლო და ამის შემდეგ მთავრდება მწკრივი”.

რეგულარული გამოხატვის შემდეგი ნაწილებისთვის შაბლონების მომზადების შემდეგ, ჩვენ მათ ერთდროულად ავიღებთ:

^(+)@(+).({2,5})$

ახლა უკვე აღარ შეიძლება მათი პროტესტი, ვინც თქვა:

$ ექო" [ელფოსტა დაცულია]" | awk "/^(+)@(+).((2,5))$/(დაბეჭდვა $0)" $ echo " [ელფოსტა დაცულია]" | awk "/^(+)@(+).((2,5))$/(დაბეჭდვა $0)"

ელ.ფოსტის მისამართის შემოწმება რეგულარული განახლებების გამოყენებით

თუ ტექსტი awk გამოჩნდება ეკრანზე, ეს ნიშნავს, რომ სისტემამ ამოიცნო ახალი ელფოსტის მისამართი.

ჩანთები

როგორც ჩვეულებრივი ვირუსი იმ ელ.ფოსტის მისამართის შესამოწმებლად, რომელიც გამოგიგზავნათ სტატიის დასაწყისში, თუმცა სრულიად არაგონივრულად გვეჩვენება, ჩვენ გვჯერა, რომ ახლა ის აღარ ჰგავს სიმბოლოების უაზრო ნაკრებს. თუ ეს მართალია, ეს ნიშნავს, რომ ეს მასალა ემსახურებოდა თავის მიზანს. ფაქტობრივად, რეგულარული წერა არის თემა, რომელსაც შეიძლება მთელი ცხოვრება შეეხო, მაშინაც კი, თუ ჩვენ მიერ ნასწავლი ცოტათი უკვე დაგეხმარება დაწერილი სკრიპტებით, რაც საკმარისი იქნება ტექსტების რედაქტირებისთვის.

მასალების ამ სერიაში ჩვენ ვაჩვენეთ bash სკრიპტების ძალიან მარტივი აპლიკაციები, რომლებიც შეიქმნა სიტყვასიტყვით რამდენიმე რიგში. შემდეგ ჯერზე უფრო დეტალურად განვიხილავთ.

შანოვნი მკითხველო! განიცდით რეგულარულ გამონათქვამებს ბრძანების ხაზის სკრიპტებში ტექსტების დამუშავებისას?

grep ნიშნავს "გლობალური რეგულარული გამოხატვის პრინტერს". grep ამოჭრის სტრიქონებს, რომლებიც გჭირდებათ ტექსტური ფაილებიდან ტექსტის ჩასანაცვლებლად.

grep შეიძლება გაერთიანდეს ორ გზასთან - თავისთავად ან ნაკადებთან ერთად.

grep ძალიან მდიდარია ფუნქციონალობით, მასში მხარდაჭერილი მრავალი ვარიანტის გამო, როგორიცაა: მოძებნა რეგულარული შაბლონის ვიკიდან ან RegExp რეგულარული გამონათქვამების შაბლონიდან ან პერლზე დაფუძნებული რეგულარული გამონათქვამები და ა.შ.

თავისი სხვადასხვა ფუნქციური შესაძლებლობების წყალობით, grep ინსტრუმენტს აქვს მრავალი ვარიანტი, მათ შორის egrep (გაფართოებული GREP), fgrep (ფიქსირებული GREP), pgrep (პროცესი GREP), rgrep (რეკურსიული GREP)და ა.შ. თუმცა, ამ ვარიანტებს შეიძლება ჰქონდეს მცირე განსხვავებები ორიგინალური grep-ისგან.

grep პარამეტრები

$ grep -V grep (GNU grep) 2.10 საავტორო უფლება (C) 2011 Free Software Foundation, Inc. ლიცენზია GPLv3+

არსებობს grep უტილიტის მოდიფიკაციები: egrep (რეგულარული გამონათქვამების გაფართოებით), fgrep ($*^|()\ სიმბოლოებს განიხილავს როგორც ლიტერალებს, ასე რომ სიტყვასიტყვით), rgrep (რეკურსიული ძიების ჩართვის შემთხვევაში).

egrep იგივეა, რაც grep -E

fgrep იგივეა, რაც grep -F

rgrep იგივეა, რაც grep -r

grep [-b] [-c] [-i] [-l] [-n] [-s] [-v] boundaries_regular_viraz_BRE [ფაილი ...]

grep ბრძანება ქმნის გამომავალი ფაილების რიგებს regular_virus-ის მიერ მითითებული ნიმუშის გამოყენებით. თუ ფაილები არ არის მითითებული, გამოყენებული იქნება სტანდარტული ჩანაწერი. გთხოვთ გაითვალისწინოთ, რომ წარმატებით შექმნილი მწკრივი დაკოპირებულია სტანდარტულ განლაგებაზე; თუ გამომავალი ფაილების რაოდენობაა, ფაილების სახელები გამოჩნდება ზედიზედ, სანამ იპოვით. grep-ს აქვს კომპაქტური არადეტერმინიზმის ალგორითმი. შაბლონების დამუშავება მოიცავს რეგულარულ გამონათქვამებს (გამონათქვამებს, რომლებსაც აქვთ სიმბოლოების საკუთარი მნიშვნელობა და ვიკორისტებენ ალფანუმერული და სპეციალური სიმბოლოების საზღვრებს). სუნი იგივე შეგრძნების სუნია, რასაც რეგულარულად გამოხატავს.

$, *, , ^, |, () სიმბოლოებისგან თავის დაღწევა და shell-ის ინტერპრეტაციის მიხედვით, ყველაზე მარტივია რეგულარული გამონათქვამები ცალკეულ ჩანართებში ჩასმა.

Პარამეტრები:

B კანის მწკრივს წინ უძღვის იმ ბლოკის ნომერი, რომელშიც ის აღმოჩნდა. ეს შეიძლება სასარგებლო იყოს ბლოკების კონტექსტის მიხედვით ძიებისას (ბლოკები დანომრილია 0-დან). -c ძალიან ბევრი მწკრივია სურათის შესაქმნელად. -h ხელს უშლის ფაილის სახელის ჩვენებას, რათა მწკრივი განთავსდეს მიმდინარე მწკრივის წინ. Vikorist მრავალი ფაილის ძიებისას. - i იგნორირებას უკეთებს სიმბოლოების ასოებს განახლებისას. -l აჩვენებს მხოლოდ ფაილების სახელებს, ასე რომ თქვენ შეგიძლიათ მოაწყოთ თქვენს მიერ შექმნილი რიგები, თითო მწკრივზე. თუ სიმბოლო გვხვდება ფაილის ბევრ სტრიქონში, ფაილის სახელი არ მეორდება. -n აჩვენებს ფაილის ნომერს თითოეული მწკრივის წინ (სტრიქონები დანომრილია 1-დან). -s აყენებს ხედს, რათა შეგატყობინოთ შეუსაბამო ან წაუკითხავი ფაილების შესახებ. -v ხედავს ყველა რიგს, სიმბოლოების რიგების უკან. -w ჟღერს სიტყვას, ის გამძაფრებულია მეტახასიათებით \< и \>.

grep --დახმარება

Vikoristannya: grep [OPTION]… თარგი [FILE]… მოძებნეთ PATTERN სკინში FILE ან სტანდარტული შეყვანა. გასაგებად რომ ვთქვათ, PATTERN არის რეგულარული გამოხატულება (BRE). მაგალითი: grep -i "hello world" menu.h main.c აირჩიეთ ჩვეულებრივი ვირუსის ტიპი და მისი ინტერპრეტაცია: -E, --extended-regexp PATTERN - გაფართოებული რეგულარული ვირუსი (ERE) -F, --fixed-regexp PATTERN - სტრიქონების ფიქსირებული თარიღი, გამოყოფილი ახალი მწკრივის სიმბოლოთი -G, --basic-regexp TEMPLATE - მარტივი რეგულარული გამოხატულება (BRE) -P, --perl-regexp TEMPLATE - Perl ენის რეგულარული გამოხატულება -e, -- regexp=TEMPLATE vikorystuvati TEMPLATE საძიებლად - f, --file=FILE ძმა PATTERN FILE -i, --ignore-case ignore register -w, --word-regexp PATTERN უნდა ემთხვეოდეს ყველა სიტყვას -x, --line-regexp PATTERN უნდა შეესაბამებოდეს ყველა მწკრივს -z, --null-მონაცემთა რიგები გამოყოფილია ბაიტით ნულოვანი მნიშვნელობებით და არა მწკრივის ბოლოს სიმბოლოთი. -ვერსია გვაწვდის ინფორმაციას ვერსიისა და გასვლის შესახებ -დაეხმარეთ ამ გამომავალი გამოტანის ჩვენებას და სამუშაოს დასრულებას -mmap დაბრუნების მნიშვნელობისთვის, იგნორირებულია ვერსიის კონტროლი: -m, --max-count=ACID შეიყვანება მითითებული რაოდენობის რეციუმების შემდეგ ігів - b, --byte- ოფსეტი გამოყავით მწკრივის ნომერი გასასვლელი რიგებიდან ბაიტებით -n, --line-number გადაიტანეთ მწკრივის ნომერი გასასვლელი რიგებიდან --line-buffered ამოიღეთ ბუფერი კანის მწკრივის შემდეგ -H, -- with-filename გადაიტანეთ ფაილის სახელი კანის მწკრივისთვის -h , --no-filename არ დაიწყოთ ფაილის სახელის ჩვენება --label=MITKA vikoristavayut LABEL როგორც ფაილის სახელი სტანდარტული ჩანაწერისთვის -o, --მხოლოდ -matching მწკრივის მხოლოდ ნაწილის ჩვენება, რომელიც ემთხვევა PATTERN -q, - -quiet, - -silent ჩახშობა მთელი პირველადი ფაილის --binary-files=TYPE გაითვალისწინეთ, რომ ორობითი ფაილის ტიპია: ორობითი, ტექსტური ან შეუსაბამო. -a, --text იგივეა რაც --binary-files=text -მე იგივეა რაც --binary-files=შესაბამისად -d, --directories=DIY ), რეკურსი (რეკურსიულად) და გამოტოვება (გამოტოვება ). -D, --devices=DIY მოწყობილობების დასამუშავებლად, FIFO-ების და სოკეტების წაკითხვა ან გამოტოვება -R, -r, --რეკურსიული იგივეა, რაც --directories=recurse --include=F_TEMPLATE ამუშავებს მხოლოდ ფაილებს, რომლებიც მიეკუთვნება F_TEMPLATE -- exclude=F_TEMPLATE ფაილების და დირექტორიების გამოტოვება, რომლებიც მიეკუთვნება F_TEMPLATE --exclude-from=FILE ფაილების გამოტოვება, რომლებიც მიეკუთვნება ფაილის შაბლონს FILE-დან --exclude-dir=TEMPLATE დირექტორიები, რომლებიც მიეკუთვნება ID PATTERN-ს, გამოტოვებული იქნება -L, - -files- შეუსაბამოდ ემთხვევა მხოლოდ FILE სახელები გაქცევის გარეშე -l, --files-with-Maches ემთხვევა მხოლოდ FILE სახელებს escapes-ით -c, --count ემთხვევა მხოლოდ იმ სტრიქონების რაოდენობას, რომლებიც ემთხვევა FILE -T, --Initial-tab დამოწმებული ტაბულა (საჭიროებისამებრ) -Z, --null დაამატეთ ბაიტი 0 ფაილის სახელის შემდეგ კონტექსტის მართვა: -B, --before-context=სტრიქონების რაოდენობა კონტექსტის წინ -A, --after-context= NUMBER მინიჭებულია მწკრივების NUMBER მიმდინარე კონტექსტში -C, --context[=NUMBER] ენიჭება მწკრივების NUMBER კონტექსტში -NUMBER იგივეა, რაც i --context=QUALITY --color[=WHEN], - -colour[=WHEN] სტრიქონების არჩევის მარკერები აცილებულია; როდესაც შეგიძლიათ ყოველთვის, არასდროს, ან ავტომატური -U, --ორობითი არ წაშალოთ CR სიმბოლოები მწკრივის ბოლოს (MSDOS) -u, --unix-byte-offsets არ წაშალოთ ოფსეტები CR- ів (MSDOS) გარეშე. "egrep"-ის ნაცვლად, გაუშვით "grep-E". "fgrep"-ის ნაცვლად ის გადადის "grep-F"-ზე. სირბილი სახელებით "egrep" ან "fgrep" უმჯობესია არ დატოვოთ. თუ არ არის FILE ამოცანები, ან თუ არის FILE, მაშინ იკითხება სტანდარტული ჩანაწერი. თუ მითითებულია ორზე ნაკლები ფაილი, გადაიტანეთ -h. გაქცევის აღმოჩენის შემთხვევაში, პროგრამის დასრულების კოდი იქნება 0 და 1, ან არც ერთი. თუ ამორტიზაცია არასწორია, ან -q პარამეტრი არ არის მითითებული, გასასვლელი კოდი იქნება 2. აცნობეთ მისამართს ამორტიზაციის შესახებ. გადაცემის დროს შეწყალების შესახებ, გთხოვთ, მიუთითოთ მისამართი GNU Grep მთავარი გვერდი: რჩევა GNU პროგრამებთან მუშაობის შესახებ:

Bash shell-ის რეგულარული გამონათქვამები მოწოდებულია, როგორც ერთ-ერთი მთავარი ინსტრუმენტი, რომელიც იძლევა კომუნიკაციის საშუალებას ჰოსტსა და ოპერაციულ სისტემას შორის. ჭურვის საშუალებით შეგიძლიათ მართოთ აპარატის ფაილურ სისტემაში არსებული ფაილები და დირექტორიები, დამუშავოთ ისინი და ჩამოტვირთოთ სხვა პროგრამები, თქვენი ტერმინალის კლავიატურა, როგორც შეყვანის ბლოკი და ტერმინალის ალფანუმერული ეკრანი, როგორც თქვენი დღის მოწყობილობა.

რეგულარული Bash გამონათქვამები შეიქმნა ბრაიან ფოქსის მიერ GNU პროექტისთვის, როგორც ალტერნატიული პროგრამული ცვლილება Bourne shell-ისთვის. ბრძანების ენა დაინერგა 1989 წელს და მასიურად გაფართოვდა, როგორც ლინუქსისა და MacOS დისტრიბუციებისთვის Apple-ის მეშვეობით (OS X-ზე). ვერსია ასევე ხელმისაწვდომია Windows 10-ისთვის და არის სტანდარტული გარსი Solaris 11-ისთვის.

Bash არის ინსტრუქციული პროცესორი, რომელიც ტრადიციულად მუშაობს ტექსტურ ტერმინალში, სადაც პროგრამისტი აწარმოებს ბრძანებებს, რომლებიც ასრულებენ მოქმედებებს. რეგულარული Bash განცხადებები იკითხება და შედგენილია ფაილში, რომელსაც ეწოდება shell script. Unix-თან ერთად ის ცნობს ფაილების სახელებს (გასწორება), პროტოკოლებს, დოკუმენტებს, დირექტივის ჩანაცვლებას და ბირთვის სტრუქტურას ტესტირების კრიტერიუმებისთვის. სათაური სიტყვებით, სინტაქსი და ენის სხვა ძირითადი მახასიათებლები იქმნება csh-დან და ksh-დან. Bash არ არის POSIX ჭურვი, მაგრამ მას აქვს მრავალი გაფართოება. ჭურვის სახელი შემოკლებულია

ბრაიან ფოქსმა დაიწყო "ბაშას" წერა 1988 წლის 10 სექტემბერს მას შემდეგ, რაც რიჩარდ სტალმანი უკმაყოფილო დარჩა ჭურვისაგან თავისუფალი ჭურვის შემუშავებაში პროგრესის ნაკლებობით, რომელსაც შეეძლო სხვა სცენარების გაშვება. Fox-მა გამოუშვა Bash ბეტა ვერსიის სახით 1989 წლის 8 ივნისს და დაკარგა პროექტის მთავარი დისტრიბუტორი 1992 წლის შუა რიცხვებიდან 1994 წლის შუა რიცხვებამდე, რის შემდეგაც მან დატოვა FSF და მისი ადგილი დაიკავა ჩეტ რამიმ.

ამ პერიოდის განმავლობაში, Bash იყო ყველაზე პოპულარული პროგრამა Linux-ის მომხმარებლებში, გახდა ინტერაქტიული გარსი ამ ოპერაციული სისტემის სხვადასხვა დისტრიბუციისთვის, ისევე როგორც MacOS Apple-ისგან. Bash ასევე შედიოდა Microsoft Win-ში Cygwin-თან ერთად, DOS-ში DJGPP პროექტით და Android-ში სხვადასხვა ტერმინალის ემულაციის დანამატებით.

2014 წლის გაზაფხულის დასაწყისში 1989 წელს გამოშვებული „ბაშას“ 1.03 ვერსიაში აღმოჩენილი იქნა უსაფრთხოების მნიშვნელოვანი დარღვევა, რომელსაც ეწოდა Shellshock, რამაც გამოიწვია ინტერნეტში თავდასხმების სრულიად მცირე რაოდენობა. დასახლება სერიოზულად მიიღეს, დაიწყო ბაშის ვიკის ფრაგმენტების დენა, რამაც შესაძლებელი გახადა ბევრი კოდის შეფუთვა. შეცდომების გამოსწორების პატჩები ხელმისაწვდომი გახდა მათი იდენტიფიცირებისთანავე, მაგრამ ყველა კომპიუტერი არ განახლდა.

ჭურვის სინტაქსის მახასიათებლები

Bash აღჭურვილია ბრძანებებით Bourne shell-ისთვის და ფრჩხილების vikory გაფართოებისთვის, ბრძანების ხაზის დასრულება, ძირითადი გაუმჯობესება და პრობლემების დამუშავება პასტადან სხვა ფუნქციებთან ერთად. Bourne shell სკრიპტების უმეტესობა მნიშვნელოვანია ცვლილებების გარეშე, გარდა სკრიპტებისა, რომლებსაც აქვთ განსხვავებული ინტერპრეტაციები და შექმნილია სისტემის ბრძანების გასაშვებად. Bash grep-ის რეგულარული გამონათქვამები, ისევე როგორც GNU ინსტრუმენტები, იყენებენ ეფექტურ გზას შეცდომების სკანირებისთვის და გამოსავლის სტატუსის დასაყენებლად, რაც საშუალებას აძლევს ძაფებს გადავიდნენ ტრადიციულ ტერმინალურ წერტილებამდე.

როდესაც დეველოპერი დააჭერს tab ღილაკს ბრძანების გარსში, Bash ავტომატურად ჩერდება ბრძანების ხაზის ბოლოს, რათა დაემთხვეს პროგრამების, ფაილების და მოდიფიკაციების ტიპებს. ბრძანების ხაზის სისტემა წარმოუდგენლად მარტივია და ხშირად შედგება ფუნქციებისგან, რომლებიც ინახავს არგუმენტებს და ფაილების სახელებს კონკრეტული პროგრამებისთვის. Bash სინტაქსი საკმაოდ ფართოა, მათ შორის Bourne shell-ში.

რეგულარული Bash გამონათქვამები: არითმეტიკული შეფასების სრული განყოფილებების შემოღება, ((...)) ბრძანება და $ ((...)) არგუმენტი სინტაქსში, რაც გაამარტივებს შეყვანის-გამოსვლის გადამისამართებას. მაგალითად, შესაძლებელია კავშირების (stdout) და წარუმატებლობის (stderr) გადამისამართება სინქრონულად ოპერატორის მხარდაჭერასთან. უფრო ადვილია Bourne shell-ის ქვედა ეკვივალენტის შეყვანა "command > file 2>&1".

Bash ანაცვლებს პროცესის ჩანაცვლებას, ხოლო ინარჩუნებს Linux-ის რეგულარული ვირუსების სინტაქსს და ცვლის ბრძანების გამომავალს (შეყვანას), რომელიც ტრადიციულად აჩერებს ფაილის სახელს. როდესაც საკვანძო სიტყვა "ფუნქცია" ამოღებულია, ბაშის დაბუჟება აბსურდულია Bourne და Korn სკრიპტებით, რადგან კორნის გარსს აქვს იგივე პრობლემა სტატიკურ "ფუნქციასთან", მაგრამ ის იღებს ფუნქციის დაბუჟების იგივე სინტაქსს, რომელსაც ენიჭება გარსი. POSIX-გიჟად ყოფნა.

ამ სხვა ასპექტებიდან გამომდინარე, სკრიპტები იშვიათად სრულდება ბორნისა და კორნის თარჯიმნების მიერ, რადგან ისინი სპეციალურად არ იყო დაწერილი იმ სირთულის გაგებით, რომელიც გასათვალისწინებელია No რობოტების დაგეგმვისას რეგულარული Bash ვირუსებით. ასოციაციური მასივები იძლევა ინდექსირებული მასივების მარცვლოვან მხარდაჭერას, AWK-ის მსგავსი. Bash 4.x არ იქნება ინტეგრირებული MacOS-ის ახალ ვერსიაში ლიცენზიის გაცვლის მეშვეობით. ასოციაციური მასივის კონდახი.

ჭურვი აქვს ორი რეჟიმი და ბრძანება: სურათების და პარალელური. სურათების რეჟიმში ბრძანებები გამოყოფილია სიმბოლოთი ";". რეგულარული Bash გამონათქვამები, მაგალითად:

• ბრძანება 1;
• ბრძანება 2.

ამ აპლიკაციაში, თუ ბრძანება 1 დასრულებულია, ბრძანება 2 წყდება და ასე რომ თქვენ შეგიძლიათ შეწყვიტოთ ფონის ბრძანება 1 შეწყვეტის ბოლოს დამატებითი (სიმბოლო &) გამოყენებით, პროცესი შეწყდება ფონზე გარსის შემობრუნებით. კონტროლი და დაშვება გთხოვთ პატივი სცეს გამარჯვებულ გუნდებს.

1-ლი და მე-2 გუნდების ერთსაათიანი გამარჯვებისთვის ისინი დამნაშავენი არიან ობოლეცში გამარჯვებაში მომავალი რიგით:

• ბრძანება1 და ბრძანება2.

ამ შემთხვევაში, ბრძანება 1 მოთავსებულია ფონზე და სიმბოლო, რომელიც აბრუნებს საკონტროლო გარსს, რადგან ბრძანება 2 მოთავსებულია წინა პლანზე. Bash grep-ის რეგულარული გამონათქვამების გამოტოვება და როტაცია შესაძლებელია Ctrl+z-ის აკრეფით, სანამ პროცესი წინა პლანზეა. ყველა პროცესის სია, როგორც ფონურ რეჟიმში, ასევე ლოდინის რეჟიმში, რომელთა მიღწევაც შესაძლებელია სამუშაოების გაშვებით.

პროცესის ეტაპი შეიძლება შეიცვალოს სხვადასხვა ბრძანებების გამოყენებით. "fg" ბრძანება მოაქვს პროცესს წინა პლანზე, ხოლო "bg" ბრძანება აყენებს პროცესს უკანა პლანზე. Bg" და "fg" შეუძლიათ მიიღონ სამუშაოს იდენტიფიკატორი, როგორც მათი პირველი არგუმენტი, რათა მიუთითონ, თუ რომელი პროცესი მიმდინარეობს. პროცესი დასრულებულია მასზე სიგნალის გაგზავნამდე. სამუშაოს იდენტიფიკატორი პასუხისმგებელია შემდეგ ინსტრუქციებზე:

• kill -s SIGKILL%1 ან kill-9%.

Bash აწესებს „ჭკვიან კონვენციას“ ბრძანებების გამყოფებზე, რომელიც არის „კონტიგენტური“ ბრძანებების მინიჭება პრეცედენტის ბრძანებით დადგენილ გასასვლელ კოდზე. გარე ბრძანება, სახელწოდებით "bashbug", იუწყება shellac-ის გამოსწორების შესახებ. როდესაც ბრძანება გამოიძახება, ის იწყებს რედაქტორს დასრულებული ფორმის კორესპონდენტისთვის აქციებისთვის. ფორმა გამოიყენება Bash პარტიებზე ან შესაძლოა სხვა ელფოსტის მისამართებზე, რაც უზრუნველყოფს Bash-ის რეგულარული გამონათქვამების გლობალურ ჩანაცვლებას.

როდესაც Bash იწყებს დამუშავებას, ის გარდაქმნის სხვადასხვა წერტილოვან ფაილებს. მოძებნეთ მსგავსი სკრიპტის ბრძანებები, რომლებსაც შეუძლიათ თარჯიმნის კონფიგურაცია და შეკვეთა, მაგალითად:

• #!/bin/bash.

ინიციალიზაციის ფაილები, რომლებიც შექმნილია Bash ვირუსების მიერ დავალებით, არაფერს შეიცავს. ფაილის შეკვეთა:

1. როდესაც ჭურვი იწყება, ის კითხულობს და წერს /etc/profile როგორც აკეთებს.
2. ეს ფაილი ახდენს /etc/bash.bashrc ინიციალიზებას.
3. მითითებული ფაილის შემდეგ მოძებნეთ ~/.bash_profile, წაკითხული და დამთავრებული პირველი, ბოლო და წაკითხული.
4. ვინაიდან ჭურვი იწერება -ზე, ეს ნიშნავს, რომ ის ჩაიწერება ~/.bash_logout-ზე.
5. როდესაც მას დაიწყებთ როგორც ჭურვი, ის იქნება /etc/bash.bashrc და შემდეგ ~/.bashrc.
6. არჩევა შესაძლებელია "--norc" ოფციის საშუალებით.
7. "--rcfile" ფაილის ვარიანტი ცვლის Bash-ის წაკითხვისა და დეინსტალაციის უნარს.
8. Bourne shell-ისა და csh startup-ის ინსტალაცია მოდის Bourne shell-დან და csh-დან. ისინი საშუალებას გაძლევთ ითამაშოთ დამალული ფაილები Bourne-დან და ნებას რთავთ სხვა გაშვების ფუნქციებზე წვდომას csh მომხმარებლებს.

Bash-ის დაწკაპუნებით -posix ოფციით ან მითითებული set -o posix სკრიპტში ცვლის ჩვეულებრივ Bash სკრინინგს ზუსტად POSIX 1003.2 სტანდარტთან შესაბამისობაში. Shell სკრიპტებმა, რომლებიც განკუთვნილია პორტაბელურობისთვის, შეიძლება მიიღონ Bourne shell, თუ ისინი აპირებენ მის შეცვლას. ბაშს აქვს სიმღერის ფუნქციები, რომლებსაც ტრადიციული ბორნის ჭურვი არ უზრუნველყოფს. მათთვის გასაგებია:

1. დაწკაპუნების გაფართოებული პარამეტრები.
2. ბრძანებების ჩანაცვლება პოპულარული $() აღნიშვნის გამოყენებით. ეს ფუნქცია არის POSIX 1003.2-ის ნაწილი.
3. მკლავების გაფართოება.
4. ოპერაციები მასივებითა და ასოციაციური მასივებით.
5. საცდელი სტრუქტურის გაფართოება შეკიდული მკლავებით.
6. რეგულარული Bash გამონათქვამების არითმეტიკულ-შეფასებითი კონსტრუქცია „თუ“-ით.
7. სხვადასხვა მანიპულირების ოპერაციები ზედიზედ მიმდინარეობს.
8. პროცესის ჩანაცვლება.
9. ოპერატორი ჩვეულებრივი ვირუსის მსგავსია.
10. "ბაშ" - Coprocesses-ის კონკრეტული განხორციელება.

Bash-ის არითმეტიკული გამონათქვამები იყენებენ „წაკითხვის ხაზს“ მალსახმობების ღილაკების მინიჭებისთვის და ბრძანების სტრიქონის რედაქტირებისთვის კლავიშების სხვადასხვა შეკვრით (Emacs). "set -o vi"-ის გაშვებისას შეიძლება ჩართოთ Vi bindings.

მკლავების ჩასმა, რომელსაც ასევე უწოდებენ უჯრას, არის ფუნქცია, რომელიც კოპირებულია "C" გარსიდან. მოგება ქმნის ალტერნატიული კომბინაციების კომპლექტს. გენერირებული შედეგები არ საჭიროებს ფაილების სახით შენახვას. კანის გაფართოებული რიგის შედეგები არ არის დალაგებული და შენახული მარჯვენა თანმიმდევრობით. მოთამაშეების ბრალი არ არის მკლავების გაფართოების შეცვლა პორტატული ჭურვის სცენარებში, რადგან ბორნის ჭურვი არ ერევა ჩარჩოში.

როდესაც გაფართოებული მკლავები შერწყმულია ბუნებრივ ბარათებთან, მკლავები თავდაპირველად გაფართოვდება, შემდეგ კი ჩანაცვლდება შემცველი ველური ბარათები. ნახატის გარდა, ფრჩხილის გაფართოება შეიძლება გამოყენებულ იქნას შემდგომი დიაპაზონებისთვის ორ მთელ რიცხვს ან სიმბოლოებს შორის, რომლებიც იყოფა დაქვემდებარებული წერტილებით. ჩვეულებრივი Bash ენების უფრო ახალი ვერსიები მესამე მთელი რიცხვის გაზრდის საშუალებას იძლევა.

თუ სამაგრის გაფართოება გაფართოების ცვლილებასთან არის შერწყმული, იგი ფორმდება სამაგრის გაფართოების შემდეგ, რათა ზოგიერთ შემთხვევაში შეძლოთ ჩასმული „ევალის“ მოშორება შემდეგნაირად:

• $დაწყება = 1;
• დასასრული = 10 $ ექო ($ დაწყება.. $ დასასრული) # ვერ გაფართოვდება შეფასების ბრძანებით (1..10);
• $ eval echo ( $ start .. $ end ) # ცვლადის გაფართოება ფასდება, ამიტომ მიღებული მწკრივი ფასდება: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10.

ფილმ "ბაშას" სინტაქსური ასპექტები

Shell-ის სკრიპტები უნდა იყოს შენახული ASCII ტექსტურ ფაილში, რომელიც შექმნილ იქნა დამატებითი რედაქტორის პროგრამის მიერ, რათა არ შეიტანოს დამატებითი სიმბოლოები ან თანმიმდევრობები ტექსტის ფორმატირებისთვის. მაგალითად, რედაქტორები, რომლებიც შესაფერისია shell სკრიპტების შესაქმნელად, მოიცავს პროგრამებს, როგორიცაა Emacs, ხელმისაწვდომია UNIX/Linux-ზე და პროგრამები, როგორიცაა Notepad, TextEdit და UltraEdit Microsoft Windows-ზე.

კარგი პრაქტიკაა კანის Bash სკრიპტის პირველ რიგში ჩასმა რეგულარული თანმიმდევრობა „#! /Bin/bash”, რომელიც აჩვენებს პროგრამების აბსოლუტურ გზას აპარატის ფაილურ სისტემაზე, რომელსაც სჭირდება სკრიპტის გაშვება. ამ გზით, თქვენ შეგიძლიათ გაუშვათ იგი პირდაპირ ბრძანების სტრიქონში, ფაილის სახელის არგუმენტად bash ბრძანების არგუმენტის გარეშე.

პროგრამა-თარგმანის ჩასმა, რომელიც არის თარგმანის ოპერაციული სისტემა და სკრიპტის წერილობითი ინსტრუქციები, მოთავსებულია თავად სკრიპტის პირველ რიგში, სიმბოლოების თანმიმდევრობის შემდეგ დაუყოვნებლივ „#!“. მნიშვნელოვანია, რომ კომპილირებული თარჯიმანი ფაილი განთავსდეს /bin დირექტორიაში, მაგრამ სხვა სისტემებზე ის შეიძლება დაინსტალირდეს სხვა დირექტორიაში, მაგალითად:

• "/usr/bin", "/usr/local/bin".

პირდაპირი ფორმით, # სიმბოლო საშუალებას გაძლევთ შეიყვანოთ კომენტარი სკრიპტში. სკრიპტის ნებისმიერი სიმბოლო "#" სიმბოლოს შემდეგ იგნორირებულია ბრძანების თარჯიმანი. სინამდვილეში, ის ხშირად გამოიყენება სკრიპტში კომენტარების ჩასართავად მისი მოქმედების აღსაწერად ან კონკრეტული ბრძანებების ნაკადის ასახსნელად. როგორც ინტერაქტიულ რეჟიმში ბრძანებების ჩასმისას, დაშიფრულ სკრიპტში, თითოეული პროგრამის ინსტრუქცია შეიძლება დაიწეროს ერთ მწკრივზე ან დაიყოს რამდენიმე რიგად და დასრულდეს თითოეული მწკრივი დარჩენილი სიმბოლოთი „\“. დამატებითი ინდექსები შეიძლება ნაჩვენები იყოს იმავე რიგში, vikorista ";".

პროგრამის ინსტრუქციები შეიძლება იყოს "ზედმეტად" რათა გამომავალი კოდი უფრო ადვილად იკითხებოდეს, ვიდრე შეცდომების გამოტოვება. Bash-ის თარჯიმანი უფრო „თავისუფალია“, ვიდრე სხვა თარჯიმნები ან შემდგენელები, და ზოგიერთ შემთხვევაში დაუშვებელია ზედმეტად დიდი სივრცის ჩასმა წევრებს შორის, რომლებიც ქმნიან ინსტრუქციებს, სხვა შემთხვევაში სივრცე შეზღუდულია, შესაძლოა მნიშვნელოვანი იყოს ინსტრუქციების სწორი ინტერპრეტაციისთვის.

არ არსებობს საკონტროლო სტრუქტურაში ჩასმული ინსტრუქციების ბლოკების განცალკევების საერთო სიმბოლოები, მაგალითად, რომლებიც შეიძლება განმეორდეს განმეორებით საკონტროლო სტრუქტურაში. მეორეს მხრივ, არის მსგავსი საკვანძო სიტყვები, რომლებიც საშუალებას გაძლევთ სწორად ამოიცნოთ ბლოკის დასაწყისი და დასასრული. ეს საკვანძო სიტყვები საგულდაგულოდ არის ახსნილი ინსტრუქციებში, რომლებიც გამოიყენება პროგრამების ნაკადის ნავიგაციისთვის. რეგულარული Bash გამონათქვამების „მატჩის“ სინტაქსში, გარკვეულ სიმბოლოებს აქვთ განსაკუთრებული მნიშვნელობა, ასე რომ, თუ ისინი წარმოდგენილია სიმბოლოების რიგში ან როგორც ბრძანების არგუმენტი, მაშინ იქმნება კონკრეტული ფუნქცია.

მინიმალური სიმარტივით შეგვიძლია ვთქვათ, რომ shell არის პროგრამა, რომელიც ინტერაქტიულად ამთავრებს იგივე ოპერაციას. შემდეგ ის აფასებს ბრძანების შეყვანას, როგორც შეყვანას, აფასებს მას, რათა შეამოწმოს, რომ ბრძანება სინტაქსურად სწორია და ახვევს მას, შემდეგ ბრუნავს შემდეგი ბრძანების შესამოწმებლად. ეს პროცესი მთავრდება, როდესაც ჭურვი მიიღებს სიგნალს, რომელიც მიუთითებს, რომ შესვლა დასრულებულია და მას სხვა ბრძანებები არ გაეგზავნება. ამ მომენტში, ჭურვის პროგრამა მთავრდება, მეხსიერების და ოპერაციული სისტემისთვის ხელმისაწვდომი სხვა მანქანური რესურსების დაზოგვა.

სკრიპტი ავტომატურად გაშვებულია ოპერაციული სისტემის მიერ, თუ მომხმარებელი თავად შედის სისტემაში, მაშინ ის შეიძლება შესრულდეს ღია გარსზე მითითებული დამატებითი ბრძანებების გამოყენებით, ან სპეციალური გრაფიკული საშუალებების გამოყენებით, რომლებიც მუშაობენ სისტემასთან კორესპონდენტის გრაფიკული ინტერფეისით. . მაგალითად, Apple Macintosh კომპიუტერზე, რომელიც მუშაობს Mac OS X-ზე, შეგიძლიათ წვდომა ბრძანების გარსზე Terminal utility-ის გაშვებით, რომელიც მდებარეობს Utility-ში დანამატების საქაღალდეში.

Linux-ის სამუშაო სადგურზე გრაფიკული დესკტოპის მენეჯერით, როგორიცაა GNOME ან KDE, შეგიძლიათ გახსნათ ბრძანების გარსი „ტერმინალის“ პროგრამის არჩევით „პროგრამები → აქსესუარები“ მენიუდან. ბრძანების გარსის გააქტიურების შემდეგ, შეგიძლიათ ნახოთ ჭურვის სახელი, რომელიც გამოყენებული იქნება შემდეგი ბრძანების გაცემისას:

• $ეხო;
• $SHELL /bin/bash.

ვინაიდან სტანდარტული გარსი არ არის Bash, შეგიძლიათ შეამოწმოთ რა არის სისტემაში PATH-ის შუაში მდებარე ერთ-ერთ დირექტორიაში, ბრძანების "რომელი" გამოყენებით და დამატებითი "bash" ბრძანების შემდეგ:

• $ echo $SHELL /bin/tcsh $ რომელი bash /bin/bash $ bash bash-2.03$.

ამრიგად, ჭურვი მუშაობს ინტერაქტიულ რეჟიმში, იღებს შეყვანის მონაცემებს კანის ბრძანებისა და ბრძანების სტრიქონში მითითებულ პარამეტრებზე და მთავრდება თავად ბრძანებით. ხატულა ნაჩვენებია იმავე ტერმინალის ფანჯარაში. კანის ბრძანება, რომელიც გადაეცემა გარსს, მთავრდება Invio/Enter ღილაკის დაჭერით. თქვენ შეგიძლიათ გასცეთ რამდენიმე ბრძანება ერთ მწკრივში, გამოყოფთ მათ ყველა სიმბოლოს ";". თქვენ ასევე შეგიძლიათ გაყოთ ბრძანების ჩასმა ორ ან მეტ მწკრივად, თითოეული მწკრივის დასრულებით "\" სიმბოლოთი.

დარწმუნდით, რომ ჩანართები დაპროგრამებულია და დასაკეცი ჩანართები გამოიყენება რიგების გასასაზღვრავად, ხოლო ამა თუ იმ სიმბოლოს ჩანაცვლება ეფუძნება სკრიპტის მიერ მიღებულ სინტაქსს. ჩვენს სცენარებში ფეხების და ჭიშკრის გადახვევა კიდევ უფრო მნიშვნელოვანია და ბაშის ბრალი არ არის.

ერთი ფეხი გამოიყენება სიმბოლოების რიგების გამოსაყოფად. თარჯიმანი არ შედის მწკრივის ადგილას და უბრალოდ ვიკორისტა სიმბოლოების თანმიმდევრობით გამოყოფილი ფეხებით. ამრიგად, სიმბოლოები, რომლებიც სხვაგვარად სხვა მნიშვნელობას იძენენ, ასევე შეიძლება იყოს სერიის ნაწილი. ერთადერთი სიმბოლო, რომელიც არ შეიძლება განთავსდეს თათებით გარშემორტყმულ რიგში, არის თავად თათები. ასეთი რიგის დასასრულებლად აუცილებელია მისი თათების გამოყოფა.

სტრიქონების გასასაზღვრავად გამოიყენება შემდეგი ჩანართები, როგორც კი სტრიქონი ამ სიმბოლოს ჩაერთვება, თარჯიმანი ასრულებს ე.წ. ფაქტობრივად, თუ დასაკეცი ფეხებში მოთავსებული მწკრივი იგზავნება შესაცვლელად, მაშინ ცვლილების სახელის მწკრივი იცვლება მისი მნიშვნელობებით. სიმბოლოების ჩასართავად, როგორიცაა ფეხის ან დოლარის სიმბოლოები, რომლებიც სხვაგვარად იქნება ინტერპრეტირებული და მიიღებენ სხვადასხვა მნიშვნელობას, აუცილებელია მათი კანის პრეფიქსის დაყენება საპირისპირო ირიბის სიმბოლოთი " ". ბრინჯის ხვეულის სიმბოლოს გადაკვეთისთვის დაკეცილი თათებით გარშემორტყმულ რიგში, თქვენ უნდა მოაბრუნოთ ბრინჯის ორი ხვეული.

შემობრუნების ბუნება არის ჩვენი სცენარისთვის დამახასიათებელი ყველაზე დამახასიათებელი ქცევა და ყოველდღიური მაღალი დონის პროგრამირება მთავარ ენაზე. ფეხი საშუალებას გაძლევთ გამოყოთ მწკრივი, რომელიც განიმარტება Bash-ის მიერ, როგორც ბრძანება და პასუხისმგებელია ბრუნვაზე, ბრუნავს როგორც გამომავალი მონაცემების მნიშვნელობები გამომავალი სტანდარტის იმავე პროდუქტის არხზე.

აუცილებელია ჭურვის დაყენება ისე, რომ მან წარმოქმნას ბრძანებების თანმიმდევრობა, როგორც ნაჩვენებია ASCII ტექსტურ ფაილში:

• $pwd;
• ექო $SHELL;
• hostaname /home/marco /bin/bash aquilante $ echo \ > $SHELL /bin/bash.

თუ თქვენ გჭირდებათ ფაილის მომზადება სახელწოდებით "script.sh", რომელიც შენახულია თქვენს მთავარ დირექტორიაში, ფაილის ნაცვლად შეგიძლიათ გამოიყენოთ:

• echo -n "Oggi e" il " 2 თარიღი +%d/%m/%Y.

გაუშვით ეს ძალიან მარტივი სკრიპტი ბრძანების სტრიქონში ფაილის სახელის მითითებით, საიდანაც გარსი ეწოდება:

• $ bash script.sh Oggi e"il 10/6/2011.

გარსს შეუძლია მიიღოს ბრძანებების თანმიმდევრობა გამოსასვლელად მილის მეშვეობით, რომელიც გადამისამართებს სხვა ბრძანებების გამომავალს Bash-ის სტანდარტულ გამომავალზე:

• $ cat script.sh | ბაშ ოგი“ 10/6/2011.

თქვენ შეგიძლიათ ნახოთ Bash პროგრამების რეგულარული გამონათქვამები "#!" სიმბოლოების გამოყენებით. სკრიპტისთვის თარჯიმანის გამოყენების აბსოლუტური გზაა მისი უშუალოდ გაშვება OS-ის გარეშე Bash-ის გაშვებით და სკრიპტის შეყვანაში გადაცემით:

• $ cat script.sh #!/bin/bash echo -n "Oggi e" il " date +%d/%m/%Y $ chmod 755 script.sh $ ls -l script.sh -rwxr-xr-x 1 marco users 49 18 Apr 23:58 script.sh $ ./script.sh Oggi e" il 10/6/2011.

წინა ნაწილის დარჩენილ ბრძანებაში, რომელიც პირდაპირ უწოდებს სკრიპტს, რომელიც ინახება ფაილში „script.sh“, რომელიც მდებარეობს სტრიმინგის კატალოგში, ფაილის სახელამდე შეიყვანეთ სახელი „./“. აუცილებელია მიუთითოთ ბილიკი დირექტორიაში, რომელშიც მდებარეობს სკრიპტი, რომელიც შედგენილია, რადგან ხშირად უსაფრთხოების მიზეზების გამო, მიმდინარე დირექტორია შედის დირექტორიების სიაში, რომლებშიც გარსი პასუხისმგებელია შედგენილი გარე ბრძანებების გამოვლენაზე. . ასეთი დირექტორიების სია ინახება Bash-ის სხვადასხვა რეგულარულ ვერსიებში.

ოპერაციული სისტემის უპირატესობები Bash-თან ერთად

ეს არის ყველაზე ეფექტური ენა shell სკრიპტებისთვის. ეს გაძლევთ მარტივ გზას რობოტის ავტომატიზაციისთვის, როგორც უკვე იცით ჭურვის ინტერაქტიულ რეჟიმში გაშვებიდან. როგორც დეველოპერი აპროგრამებს სისტემებს, ის პასუხისმგებელია იმის ცოდნაზე, თუ როგორ მუშაობს ჭურვი.

თუ შევადარებთ სკრიპტებს სხვადასხვა კონფიგურაციით ან ავტომატიზაციის სისტემებით "yaml" ან "json", ისინი ძალიან უნივერსალურია. Bash სკრიპტები მარტივია, რადგან სკრიპტი ასრულებს მუშაობას.

Bash მარტივი ენაა და ის მოუწოდებს დეველოპერებს, ყურადღება გაამახვილონ სისტემის სხვა სირთულეებზე. ბეში შესანიშნავ საქმეს აკეთებს ქავერს ამბის წერაში. ყველაფერი დანარჩენი მნიშვნელოვანია, ან ვიკორის ჭურვი გუნდებისთვის, ან საკუთარი ჭურვის გაყიდვა, მისგან კარგი ნაწილების კოპირება. გარდა ამისა, არსებობს კარგი კონსტრუქტორები რეგულარული Bash გამონათქვამებისთვის, რომლებიც აადვილებენ ჭურვთან მუშაობას.

Bash-ის დახმარებით დეველოპერებს შეუძლიათ ყოველგვარი შეფერხების გარეშე გამოიყენონ ინტერაქტიული ვებზე დაფუძნებული ინფორმაცია, ცალკე Linux-ის ბრძანების ხაზის ინფორმაცია. ამ მიზნით, წესები არ არის საჭირო და მომხმარებლებს შეუძლიათ ერთი დაწკაპუნებით უარი თქვან წვდომაზე დამოწმებულ სამუშაო სადგურზე, რომელიც შეიცავს რესურსებს და Azure ბირთვს, თუ ისინი გაიმარჯვებენ More Azure პროგრამები, Azure Portal და Azure Documentation.

ტრადიციული შუა ბრძანების ხაზის ნაცვლად, სამუშაოს დაწყებამდე არ არის საჭირო ინსტრუმენტების ინსტალაცია და შერჩევა და შეგიძლიათ დაზოგოთ დიდი ძალისხმევა Bash-ის გამოყენებით. ყველა CLI ხელსაწყოზე, როგორიცაა ტექსტი, ასამბლეები, კონტეინერები და გამომავალი, რომლებიც ხელმისაწვდომია Bash-ში, შესაძლებელია წვდომა უსაფრთხო და მარტივი ხელსაწყოს ავთენტიფიკაციით არჩევითი CLI 2.0-ის გამოყენებით.

ჩვენ გადავხედეთ ჩვეულებრივი Bash ვირუსების კონდახებს. წარმატებებს გისურვებთ ოსტატობაში!

რეგულარული ვირაზი- ტექსტის შაბლონი, რომელიც შედგება ასოების, რიცხვებისა და სპეციალური სიმბოლოების კომბინაციისგან, რომელიც ცნობილია მეტანიშვნების სახელით. ჩვეულებრივი ვირუსების ახლო ნათესავები არიან ვირუსები, რომლებიც ხშირად გვხვდება ბირთვის ფაილებში. რეგულარული გამონათქვამები ვიკორიზებულია ძირითადად ტექსტის გასწორებისა და ძიების მიზნით. ფართოდ გამოიყენება სინტაქსის ანალიზისთვის.

UNIX-ის მომხმარებლები იცნობენ ჩვეულებრივ ვირუსებს, როგორიცაა grep, sed, awk (ან gawk) და ed. ამ პროგრამების ან მათი ანალოგების გამოყენებით, შეგიძლიათ სცადოთ და შეამოწმოთ ქვემოთ მოცემული ინსტრუქცია. ტექსტური რედაქტორები, როგორიცაა (X)Emacs და Vi, ასევე აქტიურად უწყობენ ხელს რეგულარულ გამონათქვამებს. შესაძლებელია, რომ რეგულარული ვირუსების ყველაზე დიდი მრავალფეროვნება ადგილი ჰქონდეს პერლის ენას. მნიშვნელოვანია პროგრამული უზრუნველყოფის დეველოპერებისთვის და სისტემის ადმინისტრატორებისთვის, თავიდან აიცილონ რეგულარული ვირუსების ცოდნა.

მეტახასიათები

ასევე, რიგები შეიძლება შედგებოდეს ასოებით, რიცხვებით და მეტასიმბოლოებით. მეტაგმირები:

\ | () { } ^ $ * + ? . < >

მეტახასიათებს შეუძლიათ შეასრულონ შემდეგი როლები რეგულარული გამოყენებისას:

რაოდენობრივი მაჩვენებელი

გამკვრივება;

ჯგუფის ნიშანი;

ალტერნატივა;

თანმიმდევრობის ნიშანი

რაოდენობები

მეტანიშანი * (ვარსკვლავი) ცვლის 0-ს ან რამდენიმე სიმბოლოს. მეტახასიათი + (პლუს) ცვლის 1 ან მეტ სიმბოლოს. მეტახასიათი. (წერტილი) ცვლის ზუსტად 1 დამატებით სიმბოლოს. მეტახასიათი? (მთავრული სიმბოლო) ცვლის 0 ან 1 სიმბოლოს. Vіdminnіst in vikoristanna * ta + taka, რომელიც ითხოვს სტრიქონს *-ით, რათა მისცეს ნებისმიერი მწკრივი, მათ შორის ცარიელი, და ითხოვს + - დამატებითი სტრიქონებით, რომ შეცვალოს სიმბოლო.

ცარიელი რიგები განლაგებულია იმავე თანმიმდევრობით, როგორც შემდეგი მწკრივი: ცარიელი მწკრივის გვერდით უნდა განთავსდეს ერთი ან მეტი ცარიელი მწკრივი; ცარიელ რიგში, ცარიელი რიგები მოთავსებულია კანის სიმბოლოს წინ, ასევე რიგის ბოლოს.

რეგულარულ გამონათქვამებს ასევე აქვთ იგივე კონსტრუქცია (n, m), რაც იმას ნიშნავს, რომ კონსტრუქციაზე წინ მყოფი სიმბოლო ზედიზედ ჩნდება n-დან m-მდე. რიცხვის m გამოტოვება განპირობებულია უწყვეტობის პატივისცემით. ტობტო. მშენებლობის კერძო ტიპები მოიცავს შემდეგ ჩანაწერებს: (0,), (1,) და (0,1). პირველი ვარაუდობს *, მეორე - მეტასიმბოლო +, ხოლო მესამე -? . ამ ბალანსის შენარჩუნება მარტივია სხვადასხვა ტიპის რაოდენობების გამოყენებით. გარდა ამისა, კონსტრუქცია (n) ნიშნავს, რომ სიმბოლო ზუსტად n-ჯერ არის გამძაფრებული.

ვიკარებთან დაკავშირებით, როგორც სხვადასხვა გამყოფი ნიშნების მეტასიმბოლოებისა და მათემატიკური სიმბოლოების, შემოტანილია დამატებითი მეტასიმბოლო \ (უკუღმა), რომელიც მეტასიმბოლამდე დაწერისას დანარჩენს თავდაპირველ სიმბოლოდ გარდაქმნის. ტობტო. ? - ეს რაოდენობრივი მაჩვენებელია და \? - კვების ნიშანი.

ჯგუფური

რაოდენობების აღწერილობები, როგორც აღინიშნა, მოქმედებს მათთან ყველაზე ახლოს მარცხენა სიმბოლოზე (დარჩენილი წინა სიმბოლო). გარდა ამისა, შესაძლებელია ჯგუფების გვერდის ავლით, რომლებშიც გამოიყენება მეტახასიათები (i). ეს სიმბოლოები წარმოადგენს ქვეგამოხატვას, რომელიც გაერთიანებულია ჯგუფში, რომელიც შემდეგ ქმნის რაოდენობრივ მაჩვენებელს.

კონდახი:

ნიშნავს (ან ცვლის თავის თავს)

ჰო ჰო ჰო ჰო ჰო ჰოჰო

შესაძლებელია ქვეგამოთქმების ბუდე, მაშინ. ქვეგამოთქმებიდან შეგიძლიათ ნახოთ უმცირესობის ქვეგამოთქმები.

ალტერნატივები

ისინი იმალებიან დამატებითი მეტასიმბოლის მიღმა (ვერტიკალური მახასიათებელი), რაც უფრო ლოგიკურად ნიშნავს "ან".

კონდახი: ბირთვების რეგულარული გამოხატულება (a|i|e|y|oh|oh)? აყენებს სიტყვა "ძროხის" ყველა შესაძლო ცვლილებას ერთმანეთის მიყოლებით.

ტვერჟენნია

ხილულია მეტასიმბოლოები, რომლებიც მიუთითებენ სპეციალურ ობიექტებზე - ნულოვანი დოვჟინის რიგები, რომლებიც ემსახურება წინა და წინა ტექსტის დანიშნულ ადგილს. ასეთ ობიექტებს სიმაგრეებს უწოდებენ. რეგულარულ გამონათქვამებს აქვთ შემდეგი დადასტურებები:

კონდახი: რეგულარული გამოხატულება $The საშუალებას გაძლევთ იცოდეთ მწკრივი, რომელიც იწყება The-ით.

შენიშვნა: პირველადი სიმბოლოები შეიძლება ჩაითვალოს გამაგრებულად არანულოვანი მნიშვნელობით.

მიმდევრობები

სპეციალური დიზაინი, რომელიც მოთავსებულია მეტასიმბოლოებში [i] (სწორი მშვილდოსნები), საშუალებას გაძლევთ გადაწეროთ სიმბოლოების ვარიანტები, რომლებიც შეიძლება გამოჩნდეს რეგულარულ გამოხატულებაში მოცემულ ადგილას და დასახელებულია თანმიმდევრობით. მართკუთხა მკლავების შუაში ყველა მეტასიმბოლო განიხილება, როგორც მარტივი სიმბოლო, ხოლო სიმბოლოები - (მინუს) და ^ იძენენ ახალ მნიშვნელობას: პირველი საშუალებას გაძლევთ მიუთითოთ სიმბოლოების უწყვეტი თანმიმდევრობა ორ მითითებას შორის, ხოლო მეორე იძლევა უფრო მეტს. ლოგიკური "არა" (ჯაჭვი). ყველაზე მარტივი გზა ამ კონდახის დასათვალიერებლად:

პატარა ლათინური ასოებიდან:

ლათინური ალფაციფრული სიმბოლო (a-დან z-მდე, A-დან Z-მდე და 0-დან 9-მდე):

სიმბოლო, რომელიც არ არის ლათინური ანბანური:

[^a-zA-Z0-9]

იყოს სიტყვა (დეფისების, მათემატიკური სიმბოლოების და რიცხვების გარეშე):

<+>

თანმიმდევრულობისა და სიმარტივისთვის შემოღებულია შემდეგი აბრევიატურები:

დაკავშირება wildcards-თან

ცოდნის ჯგუფური სიმბოლოებით, mabut, kozhen koristuvach. wildcard სიმბოლოს მაგალითია *.jpg ჩანაწერი, რაც ნიშნავს ყველა ფაილს jpg გაფართოებით. რა არის ჯგუფური სიმბოლოების რეგულარული გამოხატულება? შედეგები შეიძლება მივაწეროთ სამ წესს ველური ბარათებით საკმარისი ვირუსის ჩვეულებრივ ვირუსად გადაქცევისთვის:

Შეცვლა.*

ჩანაცვლება? ზე.

შეცვალეთ ყველა სიმბოლო, რომელიც გაურბოდა მეტახასიათებს მათი გაუფერულებული ვარიანტებით.

მართალია, რეგულარულად ნაჩვენები ჩანაწერი * არ არის ფერადი და იძლევა ცარიელ რიგს, რადგან ნიშნავს, რომ ცარიელი რიგი მეორდება წელიწადში რამდენჯერმე. და ღერძი.* (გაიმეორეთ დამატებითი სიმბოლო რაც შეიძლება ბევრჯერ, მათ შორის 0) უბრალოდ თავიდან აიცილებთ სიმბოლოს * შეცვლით ველური ბარათების არარსებობის შემთხვევაში.

რეგულარული გამოხატულება, რომელიც არის *.jpg, ასე გამოიყურება: .*\.jpg. და, მაგალითად, ez*.pp ჯგუფის სიმბოლოების თანმიმდევრობა მითითებულია ორი ექვივალენტური რეგულარული გამოსახულებით - ez.*\.pp და ez.*\.(cpp|hpp) .

გამოიყენეთ რეგულარული ვირუსები

ელფოსტის ფორმატი [ელფოსტა დაცულია]

+(\.+)*@+(\.+)+

ელ.ფოსტა ფორმატში "ივან ივანოვი" "

("?+"?[\t]*)+\<+(\.+)*@+(\.+)+\>

ვებ პროტოკოლის შემოწმება URL-ში (http://, ftp:// ან https://)

+://

ბრძანებების მოქმედებები და C/C++ დირექტივები:

^#შეიცავს[ \t]+[<"][^>"]+[">] - შეიცავდეს დირექტივას

//.+$ - კომენტარი ერთ მწკრივზე

/\*[^*]*\*/ - კომენტარი დეკალის რიგებზე

-?+\.+ - რიცხვი მცურავი წერტილით

0x+ არის რიცხვი მეთექვსმეტე რიცხვთა სისტემაში.

და ღერძი, მაგალითად, არის პროგრამა სიტყვის ძროხის მოსაძებნად:

აქ ვარიანტი E გამოიყენება რეგულარული გამონათქვამების გაფართოებული სინტაქსის მხარდაჭერის გასააქტიურებლად.

ტექსტი ეფუძნება იან ბორსოდის სტატიას ფაილიდან HOWTO-regexps.htm

რეგულარული გამონათქვამები ძალიან სასარგებლო ინსტრუმენტია ტექსტის ნიმუშის მოსაძებნად, დამუშავებისა და რიგების შესაცვლელად, რომელიც შეიძლება შეიკრიბოს ამოცანის მეტი სიზუსტისთვის. მთავარი ღერძი არის:

• შეყვანილი ტექსტის შემოწმება;
• მოძებნეთ ფაილში ტექსტის შემცვლელი;
• სერიული ფაილის გადარქმევა;
• ურთიერთქმედება სერვისებთან, როგორიცაა Apache;
• სტრიქონის შემოწმება შაბლონთან შესაბამისობის უზრუნველსაყოფად.

ეს არ არის სრული სია რეგულარული ჩანაწერების საშუალებას გაძლევთ ბევრად მეტი იმუშაოთ. თუმცა, ახალი კორისტუვაჩებისთვის, სუნები შეიძლება იყოს ძალიან დასაკეცი, მათი ჩამოსხმის ფრაგმენტები ექვემდებარება სპეციალურ ენას. ნებისმიერი სამედიცინო პრობლემის შემთხვევაში, რეგულარული Linux ვირუსები უნდა იყოს ცნობილი და გათვალისწინებული სისტემის ადმინისტრატორის მიერ.

ეს სტატია განიხილავს რეგულარულ ბაშის გამონათქვამებს დამწყებთათვის, ასე რომ თქვენ შეგიძლიათ შეისწავლოთ ამ ხელსაწყოს სრული შესაძლებლობები.

რეგულარულ გამონათქვამებს შეიძლება ჰქონდეს ორი ტიპის სიმბოლო:

• ორიგინალური ასოები;
• მეტაპერსონაჟები.

პირველადი სიმბოლოებია ასოები, რიცხვები და გამყოფი ნიშნები, საიდანაც წარმოიქმნება ნებისმიერი სტრიქონი. ყველა ტექსტი შედგება ასოებით და მათი გამოყენება რეგულარულად შეგიძლიათ ტექსტში სასურველი პოზიციის მოსაძებნად.

მეტასიმბოლოები სხვა რამეა, ისინი თავად აძლევენ ძალას რეგულარულ გამონათქვამებს. მეტასიმბოლოების დახმარებით თქვენ შეგიძლიათ მიიღოთ ბევრად მეტი ერთი სიმბოლოს ძიების გარეშე. შეგიძლიათ მოძებნოთ სიმბოლოების კომბინაციები, დაარეგულიროთ მათი დინამიური სიძლიერე და აირჩიოთ დიაპაზონები. ყველა სპეციალური სიმბოლო შეიძლება დაიყოს ორ ტიპად: შემცვლელი სიმბოლოები, რომლებიც ცვლის ძირითად სიმბოლოებს და ოპერატორები, რომლებიც მიუთითებენ რამდენჯერ შეიძლება განმეორდეს სიმბოლო. რეგულარული virazu vigladatime-ის სინტაქსი ასეთია:

პირველადი_პერსონაჟი სპეციალური ხასიათი_ოპერატორი

სპეციალური_პერსონაჟის_ჩანაცვლება სპეციალური ხასიათი_ოპერატორი

• \ - სპეციალური სიმბოლოების ასოები იწყება საპირისპირო გვერდითი სკირით და ასევე გამოიყენება როგორც სპეციალური სიმბოლო ნებისმიერი სექციური ნიშნის გამოჩენაში;
• ^ - მიუთითებს რიგის ყურზე;
• $ - მიუთითებს მწკრივის დასასრულს;
• * - მიუთითებს, რომ წამყვანი სიმბოლო შეიძლება განმეორდეს 0 ან მეტჯერ;
• + - მიუთითებს, რომ წამყვანი პერსონაჟი შეიძლება განმეორდეს ერთზე მეტჯერ ან მეტჯერ;
• ? - წამყვანი სიმბოლო შეიძლება აღინიშნოს ნულოვანი ან ერთხელ;
• (n)- მიუთითებს რამდენჯერ (n) უნდა განმეორდეს წამყვანი სიმბოლო;
• (N,n)- წამყვანი სიმბოლო შეიძლება განმეორდეს N-დან n-ჯერ;
• . - ნებისმიერი სიმბოლო მწკრივის შემობრუნების გვერდით;
• - იყოს რაიმე სახის სიმბოლო, მინიშნება ტაძრებზე;
• x|y- სიმბოლო x ან სიმბოლო y;
• [^az]- იყოს ერთგვარი სიმბოლო, გარდა ტაძრებში ნაჩვენებისა;
• - ნებისმიერი სიმბოლო მინიჭებული დიაპაზონიდან;
• [^a-z]- ნებისმიერი სიმბოლო, რომელიც დიაპაზონს არ აქვს;
• \ბ- მიუთითებს სიტყვებს შორის უფსკრულით;
• \ ბ- ნიშნავს, რომ პერსონაჟი სიტყვის შუაშია, მაგალითად, ux არის გაქცეული uxb-დან ან tuxedo-დან, მაგრამ არ არის გამოქცეული Linux-დან;
• \ დ- ნიშნავს, რომ სიმბოლო არის რიცხვი;
• \დ- არაციფრული სიმბოლო;
• \n- მწკრივის უკუქცევის სიმბოლო;
• \ ს- ერთ-ერთი სიმბოლო, სივრცე, სივრცე, ჩანართი და ა.შ.;
• \ ს- ნებისმიერი სიმბოლო უფსკრული;
• \ ტ- ჩანართის სიმბოლო;
• \v- ვერტიკალური ჩანართის სიმბოლო;
• \w- ნებისმიერი ასო სიმბოლო, სავარძლის ჩათვლით;
• \ვ- იყოს რაღაც ასო სიმბოლო, სავარძლის კრემი;
• \uXXX- Unicdoe სიმბოლო.

მნიშვნელოვანია, რომ ასოების სპეციალურ სიმბოლოებამდე თქვენ უნდა ჩასვათ ლენტები ასოებს შორის, რათა მიუთითოთ, რომ სპეციალური სიმბოლო მოდის. ეს ასეა, და თუ გსურთ დაამატოთ სპეციალური სიმბოლო, რომელიც შედის დახრილობის გარეშე, როგორც პირველადი სიმბოლო, მაშინ უნდა დაამატოთ ხაზის ხაზი.

მაგალითად, გსურთ იცოდეთ ტექსტის მწკრივი 1+2=3. თუ ამ სტრიქონს რეგულარულ გამოხატულებად ხედავთ, ვერაფერს იპოვით, რადგან სისტემა განმარტავს პლუსს, როგორც სპეციალურ სიმბოლოს, რაც მიუთითებს, რომ წინა ერთეული შეიძლება განმეორდეს ერთხელ ან მეტჯერ. აქედან გამომდინარე, აუცილებელია ეკრანიზაცია: 1 \+ 2 = 3. ეკრანის გარეშე, ჩვენი რეგულარული გამოხატულება აჩვენებს ან სტრიქონს 11=3 ან 111=3 ან სხვა რამეს. არ არის საჭირო ბრინჯის დადება ერთის წინ, რადგან ეს არ არის განსაკუთრებული სიმბოლო.

გამოიყენეთ რეგულარული ვირუსები

ახლა, როდესაც ჩვენ გადავხედეთ საფუძვლებს და თქვენ იცით, როგორ მუშაობს ყველაფერი, აღარ არის შესაძლებელი ცოდნის კონსოლიდაცია პრაქტიკაში რეგულარული ლინუქსის grep გამონათქვამების შესახებ. ორი ძალიან ყავისფერი სპეციალური სიმბოლო - tse ^ და $, რომლებიც მიუთითებენ მწკრივის დასაწყისსა და დასასრულს. მაგალითად, ჩვენ გვინდა წავშალოთ ჩვენს სისტემაში რეგისტრირებული ყველა ანგარიში, რომელთა სახელები იწყება s-ით. შემდეგ შეგიძლიათ გამოიყენოთ ჩვეულებრივი ვირუსი "^s". შეგიძლიათ გამოიყენოთ egrep ბრძანება:

egrep "^s" /etc/passwd

თუ გვინდა ავირჩიოთ რიგები მწკრივში დარჩენილი სიმბოლოს შემდეგ, მაშინ ამისთვის შეგვიძლია გამოვიყენოთ $. მაგალითად, თუ ჩვენ ვირჩევთ სისტემის ყველა ანგარიშს, ჭურვის გარეშე, ჩანაწერები ასეთი ანგარიშების შესახებ დასრულდება ყალბი:

egrep "false$" /etc/passwd

კორისტუვაჩების სახელების სანახავად, რომლებიც იწყება s ან d-ით, გამოიყენეთ შემდეგი გამოთქმა:

egrep "^" /etc/passwd

იგივე შედეგი შეიძლება წაიშალოს ვიკორისტის სიმბოლოს "|" გამოყენებით. პირველი ვარიანტი უფრო შესაფერისია დიაპაზონებისთვის, ხოლო მეორე უფრო ხშირად გამოიყენება ძირითადი მიზნებისთვის:

egrep "^" /etc/passwd

ახლა ავირჩიოთ ყველა კორისტუვაჩი, რომელთა სახელები გახდება სამზე მეტი სიმბოლო. კორისტუვაჩის სახელი ორმაგი ქუდით მთავრდება. შეიძლება ითქვას, რომ შეიძლება იყოს ნებისმიერი ასო სიმბოლო, რომელიც შეიძლება სამჯერ განმეორდეს ორმაგამდე:

egrep "^\w(3):" /etc/passwd

ვისნოვკი

ამ სტატიაში ჩვენ განვიხილეთ Linux-ის რეგულარული ვერსიები, მაგრამ ისინი აღარ იყო ფუნდამენტური. თუ ცოტა ჩაღრმავდებით, აღმოაჩენთ, რომ ამ ხელსაწყოს დახმარებით შეგიძლიათ კიდევ ბევრი სასარგებლო გამოსვლების წარმოება. რეგულარული გამონათქვამების ათვისებაზე დახარჯული საათი ნამდვილად იქნება განსხვავება.

Yandex-ის ლექციის დასასრულს რეგულარული გამონათქვამების შესახებ: