Poradnik Perla
Co to jest Perl?
Perl jest wysokopoziomowym, uniwersalnym, interpretowanym, dynamicznym językiem programowania. Perl to termin oznaczający „Practical Extraction and Reporting Language”, chociaż nie ma akronimu dla Perla. Został wprowadzony przez Larry'ego Walla w 1987 roku. Język Perl został specjalnie zaprojektowany do edycji tekstu. Ale teraz jest szeroko stosowany do różnych celów, w tym administracji systemem Linux, programowania sieciowego, tworzenia stron internetowych itp.
Ujmijmy to w prosty sposób. Chociaż komputery rozumieją tylko zera i jedynki (język binarny/język maszynowy/[język niskiego poziomu]), dla nas, ludzi, bardzo trudno jest programować w języku binarnym. Perl to język programowania, który wykorzystuje elementy języka naturalnego, czyli słowa używane w powszechnym języku angielskim, dzięki czemu jest łatwiejszy do zrozumienia przez ludzi [język wysokiego poziomu] Teraz pojawił się problem; komputery nie rozumieją języków wysokiego poziomu, które my, ludzie, możemy łatwo zrozumieć. W tym celu potrzebujemy czegoś, co przetłumaczy język wysokiego poziomu na język niskiego poziomu. Tutaj z pomocą przychodzi nam tłumacz. Interpreter to oprogramowanie, które konwertuje program napisany w języku wysokiego poziomu na język niskiego poziomu, aby komputer mógł zrozumieć i wykonać instrukcje zapisane w programie. Dlatego Perl jest interpretowany język programowania.
Gdzie używany jest Perl?
Moc języka skryptowego Perl można wykorzystać w wielu dziedzinach. Perl jest najczęściej używany w rozwoju sieci Web. Perl jest również używany do automatyzacji wielu zadań na serwerach sieci Web i innych zadań administracyjnych, może automatycznie generować wiadomości e-mail i czyścić systemy. Perl jest nadal używany do swojego pierwotnego celu, tj. wyodrębniania danych i generowania raportów. Może generować raporty dotyczące wykorzystania zasobów i sprawdzać problemy z bezpieczeństwem w sieci. Z tego powodu Perl stał się popularnym językiem używanym w rozwoju sieci Web, sieciach i bioinformatyce. Oprócz tego wszystkiego perl może być również używany do programowania CGI.
Perl może być również wykorzystywany do tworzenia i manipulacji obrazami. Oprócz tego sieciowanie przez telnet, FTP itp., tworzenie graficznego interfejsu użytkownika, elektronika VLSI i tworzenie filtrów poczty w celu zmniejszenia praktyk spamowania to niektóre przypadki użycia Perla.
Perl jest również znany z implementacji praktyk OOP (programowania obiektowego) i obsługuje wszystkie formy dziedziczenia (proste, wielokrotne i diamentowe), polimorfizm i hermetyzację. Perl jest wystarczająco elastyczny, aby obsługiwać praktyki proceduralne i OOP jednocześnie. Perl ma również dodatkowe moduły, które pozwalają pisać lub używać/ponownie używać kodu napisanego w Python, PHP, PDL, TCL, Oktawa, Java, C, C++, Basic, Ruby i Lua w skrypcie Perla. Oznacza to, że możesz łączyć Perla z tymi dodatkami języki programowania raczej przepisanie istniejącego kodu.
Zastosowania języka programowania Perl
Dlaczego warto używać Perla?
Prawdą jest, że istnieją inne języki programowania, których można użyć do wykonania wszystkich czynności opisanych powyżej, więc dlaczego miałbyś używać Perla? Perla jest bardzo łatwo się nauczyć, zwłaszcza jeśli masz doświadczenie w programowaniu komputerowym. Perl został zaprojektowany tak, aby ułatwić ludziom pisanie i zrozumienie, a nie ułatwiać przetwarzanie przez komputery. Używa wyrażeń regularnych. Jego naturalny styl języka różni się od innych języków programowania, które wykorzystują specyficzną gramatykę i składnię; dlatego Perl jest bardzo elastyczny i nie narzuca ci żadnego konkretnego sposobu myślenia o rozwiązaniu lub problemie. Perl jest niezwykle przenośny. Może działać na każdym systemie operacyjnym, który ma zainstalowany interpreter Perla, więc jest niezależny od platformy. Wszystkie systemy Linux OperaSystemy ting są wyposażone w Perl, więc możesz od razu zacząć kodować w Perlu w Linuksie. Jest to inne niż w przypadku skryptów powłoki, gdzie kod zmienia się w zależności od używanej dystrybucji Linuksa, co sprawia, że jest on coraz mniej przenośny Małe, specyficzne zadania w Perlu stają się bardzo łatwe i szybkie. W tym samouczku Perla dla początkujących dowiesz się, jak kodować małe, szybkie programy do określonych zadań. Weźmy prosty przykład klasycznego programu Hello World, który służy do rozpoczęcia nauki dowolnego języka programowania mającego korzenie w systemie UNIX:
Przykład: Perl, witaj świecie
#!/usr/bin/perl print "Hello, world!";
Wyjście:
Witaj świecie!
Powyższe dwie linie kodu zostaną wydrukowane Witaj, świecie! Czy nie było to zbyt proste i szybkie? Studenci ze znajomością języka C, C++ będzie wiedział, że uzyskanie tego samego wyniku w tych językach wymaga znacznie większej liczby linii kodu.
Możesz się zastanawiać, dlaczego Perl jest tak znany w sieci. Jest to proste, ponieważ większość rzeczy, które dzieją się w sieci, ma charakter TEKSTOWY, a Perl jest bardzo dobry w przetwarzaniu tekstu. Jeśli porównamy Perla z którymkolwiek z języków, to Perl będzie najlepszym językiem, który jest dobry w obsłudze plików, przetwarzaniu tekstu i raportowaniu wyników
Jedną z najlepszych zalet Perla jest to, że tak jest swobodnie korzystać
Społeczność Perl jest głęboko przekonana, że oprogramowanie powinno być swobodnie dostępne, swobodnie modyfikowalne i swobodnie dystrybuowane. Kilku wolontariuszy ze społeczności Perl stara się, aby język programowania był jak najlepszy.
Zalety i wady Perla
Plusy: | Wady: |
---|---|
|
|
|
|
Zacznijmy
Mając wystarczającą wiedzę na temat historii Perla i podstawowych pojęć programowania komputerowego wymaganych do kodowania w Perlu, nadszedł czas, aby zanurzyć się i zacząć z Perlem. Następny rozdział nauczy Cię, jak skonfigurować Perla w swoim systemie i przygotować się do podróży kodowania w Perlu. Ten samouczek skryptowania w Perlu będzie traktował Linuksa jako system operacyjny, którego uczniowie będą używać do kodowania w Perlu.
Pobierz i zainstaluj Perla – Windows, Mac i Linux
Jak zdobyć Perla?
Dobre wieści prawdopodobnie to masz!
Jeśli jednak nie możesz znaleźć go już w swoim systemie, nadal możesz pobrać go za darmo.
Aby dowiedzieć się, czy masz już zainstalowany Perl, przejdź do wiersza poleceń i wpisz: perl -v
Polecenie wyświetli wersję Perla, jeśli jest zainstalowany. W tym przypadku wersja to v5.14.2. Ale jeśli nie… nie panikuj…
Unix |
Już zainstalowane Jest fabrycznie zainstalowany w języku Perl, jednak może być konieczna aktualizacja do najnowszej wersji. |
Mac OS |
Już zainstalowane OSX ma preinstalowany Perl, chociaż może być konieczna jego aktualizacja do najnowszej wersji |
Windows |
Trzeba zainstalować Dostępne są dwie opcje
|
Aktualizowanie Perla w systemie Linux:
Jeśli chcesz zaktualizować wersję Perla, po prostu wpisz jedną linię poleceń
sudo apt-get zainstaluj perl
i wyluzuj. Resztą się zajmiemy. Upewnij się tylko, że masz aktywne połączenie z Internetem.
Zainstaluj Perla dla Windows:
Najpierw pobierz z tego aktywnego Perla link. Wykonaj poniższe kroki, aby zainstalować ActivePerl Windows system. Zobacz poniższe zrzuty ekranu, aby zobaczyć to samo.
Krok 1: Po pobraniu instalatora i rozpoczęciu instalacji zobaczysz poniższe okno. Kliknij Dalej, aby kontynuować.
Krok 2: Zaakceptuj umowę licencyjną, aby kontynuować instalację.
Krok 3: Poniżej znajdują się różne pakiety, które zostaną zainstalowane. Domyślnie wybrane zostaną wszystkie. Jedyną różnicą jest PPM (menedżer pakietów Perla). Jest to narzędzie dostarczane przez Active Perl do instalowania zewnętrznych modułów lub bibliotek Perla w twoim systemie. Kliknij Dalej, aby kontynuować.
Krok 4: Są to różne typy rozszerzeń Perla, których można używać w Perlu. Przeważnie będziemy używać .Pl, .Plx i .Pm dla Perla. Moduły Perla zasadniczo używają .Pm jako rozszerzenia pliku w odniesieniu do pliku biblioteki. Zaznacz wszystkie opcje i kliknij przycisk Dalej.
Krok 5: Kliknij przycisk Instaluj, aby kontynuować instalację.
Krok 6: Po zainstalowaniu wykonaj polecenie „Perl –v”, aby sprawdzić, czy Perl został pomyślnie zainstalowany w twoim systemie.
Jest wiele rzeczy, które należy omówić w celu ustawienia środowiska Perla zarówno w systemie Linux, jak i Windows, ponieważ w tej instalacji nie będzie wielu plików bibliotek. Musisz je zainstalować ręcznie. Można je zainstalować ręcznie za pomocą CPAN (Comprehensive Perl Archive Network) lub PPM, który działa tylko dla okien Perl. Jednak te pliki nie są obowiązkowe, aby rozpocząć kodowanie w Perl.
Oprócz tej konfiguracji systemu Windows możesz użyć Windows Nowa funkcja podsystemu Linux w systemie Windows 10 i możliwość jej wykorzystania do uruchamiania kodu Perl
Pierwszy program w Perlu
Hello world!
Przykład Perla: Witaj świecie
#!/usr/bin/perl -w #this is just a comment… print "Hello World";
Nie martw się, jeśli nie rozumiesz tego tekstu. Wszystko wkrótce się wyjaśni. Chodź i spójrz na to według linii:
#!/usr/bin/perl
To mówi Operating System, aby wykonał ten plik z programem znajdującym się w /usr/bin/perl. Niektóre IDE nie potrzebują tej linii. Jeśli jest to konieczne, musisz wpisać tutaj ścieżkę do swojego tłumacza. Pamiętać! Ta specjalna linia musi znajdować się na początku programu i musi zaczynać się od #! używaj ostrzeżeń; Jest to kolejne specjalne polecenie, które każe interpreterowi wyświetlić wszelkie ostrzeżenia, np. -w, które globalnie aktywuje ostrzeżenia.
print "Hello World";
Instrukcja drukowania zapisuje tekst na ekranie. Średnik na końcu linii informuje interpretera Perla, że instrukcja została zakończona. Na końcu każdej instrukcji w kodzie Perla należy umieścić średnik. Zwróć uwagę na cudzysłów („). Jest to konieczne do wydrukowania instrukcji. Zapisz powyższy skrypt jako Firstprog.pl
On Windows
Jeśli masz zainstalowany Strawberry, możesz po prostu kliknąć Uruchom. Możesz także uruchomić interfejs wiersza poleceń i napisać na konsoli:
C:\> perl path\firstprog.pl
lub, jeśli na Twojej ścieżce nie ma pliku perl.exe:
C:\> c:\perl\bin\perl.exe firstprog.pl
Na Linuksie/Unixie
Wystarczy otworzyć terminal i napisać:
perl firstprog.pl
Jeśli nie możesz uruchomić programu, upewnij się, że masz uprawnienia do jego uruchomienia. Wpisz w Terminalu:
chmod +x firstprog.pl
Twój program jest teraz wykonywalny i gotowy do uruchomienia. Aby wykonać napisz:
./firstprog
Zainstaluj moduły cpan minus
Moduły to zestawy kodów, które służą do wykonywania zadań, które wykonują typowe operacje w kilku programach. Jeśli używasz modułów perl, nie musisz przepisywać kodów, aby wykonać tę samą operację. Perl może korzystać z takich zewnętrznych bibliotek kodów. Jedną z najlepszych bibliotek jest CPAN. Skrót ten oznacza Comprehensive Perl Archive Network i zawiera ogromną liczbę modułów Perl do wykorzystania. Jest to społeczność lub sieć dużej liczby programistów, którzy dostarczają takie moduły. Instalując obsługę modułów CPAN w swoim module Perl, możesz korzystać z modułów CPAN i ułatwić sobie pracę. Większość modułów Perl jest napisana w Perl, niektóre używają XS (są napisane w C), więc wymagają kompilatora C (łatwo jest to skonfigurować – nie panikuj). Moduły mogą mieć zależności od innych modułów (prawie zawsze w CPAN) i nie można ich zainstalować bez nich (lub bez określonej wersji). Warto dokładnie przeczytać dokumentację dotyczącą poniższych opcji. Wiele modułów w CPAN wymaga teraz najnowszej wersji Perl (wersja 5.8 lub nowsza). Zainstaluj cpanminus skrypt do pobierania, rozpakowywania, budowania i instalowania modułów z CPAN, aby ułatwić instalowanie innych modułów (później nam podziękujesz). Aby zainstalować Aplikacja cpanminus modułów perla, w wierszu poleceń wpisz:
cpan App::cpanminus
cpan App::cpanminus Upewnij się, że masz połączenie z Internetem podczas pobierania i instalowania modułów Perla.
Teraz zainstaluj dowolny moduł:
cpan –i <Module_Name>.
Zobaczmy przykład instalacji modułu File::Data (jest to interfejs umożliwiający dostęp do danych pliku).
Zmienna Perla
Teraz porozmawiamy o zmiennych. Możesz sobie wyobrazić zmienny rodzaj kontenera, który przechowuje jedną lub więcej wartości. Po zdefiniowaniu nazwa zmiennej pozostaje taka sama, ale wartość lub wartości zmieniają się w kółko.
Istnieją 3 typy zmiennych:
Rodzaje zmiennych w Perlu
Najłatwiejsze są skalary i to jest nasz dzisiejszy temat
Zmienna skalarna
Ten typ zmiennej przechowuje pojedynczą wartość.
Jej nazwa zaczyna się od znaku dolara i identyfikatora Perla (to nazwa naszej zmiennej).
Zmienna skalarna w Perlu
Konwencja nazewnictwa
Jeśli znasz inne języki programowania, wiesz, że istnieją pewne zasady dotyczące nazewnictwa zmiennych. Podobnie Perl ma trzy zasady nazewnictwa skalarów.
- Wszystkie nazwy skalarne będą zaczynać się od znaku $. Łatwo jest pamiętać o poprzedzeniu każdej nazwy znakiem $. Pomyśl o tym jak o $skalarze.
- Podobnie jak PHP. po pierwszym znaku $, który jest specjalny w Perlu, dozwolone są znaki alfanumeryczne, tj. od a do z, od A do Z i od 0 do 9. Dozwolony jest także znak podkreślenia. Użyj podkreślenia, aby podzielić nazwy zmiennych na dwa słowa. „Ale pierwszy znak nie może być liczbą”
- Mimo że liczby mogą być częścią nazwy, nie mogą występować bezpośrednio po $. Oznacza to, że pierwszy znak po $ będzie albo alfabetem, albo podkreśleniem. Te pochodzące z C/C++ tło powinno być w stanie natychmiast rozpoznać podobieństwo. Przykłady
Przykład Perla:
$var; $Var32; $vaRRR43; $name_underscore_23;
Nie są to jednak dozwolone nazwy zmiennych skalarnych.
mohohoh # $ character is missing $ # must be at least one letter $47x # second character must be a letter $variable! # you can't have a ! in a variable name
Ogólna zasada mówi, że jeśli Perl ma tylko jedno z czegoś, jest to skalar. Skalary można odczytywać z urządzeń i możemy je wykorzystywać w naszych programach.
Dwa typy skalarnych typów danych
- Numbers
- Smyczki
Numbers:
W tego typu danych skalarnych możemy określić:
- liczby całkowite, po prostu liczby całkowite, takie jak 2, 0, 534
- liczby zmiennoprzecinkowe, to liczby rzeczywiste, takie jak 3.14, 6.74, 0.333
Uwaga: Generalnie interpreter Perla widzi liczby całkowite jak liczby zmiennoprzecinkowe. Na przykład, jeśli napiszesz 2 w swoich programach, Perl zobaczy to jako 2.0000
Literały całkowite:
Składa się z jednej lub większej liczby cyfr, opcjonalnie poprzedzonych plusem lub minusem i zawierających podkreślenia.
Przykłady Perla:
0; -2542; 4865415484645 #this also can be written with underscores (for clarity) : 4_865_415_484_645
Jak widać – nie jest to nic specjalnego. Ale uwierz mi, jest to najpopularniejszy rodzaj skalarów. Są wszędzie.
Literały zmiennoprzecinkowe:
Składa się z cyfr, opcjonalnie minusa, kropki dziesiętnej i wykładnika.
Przykłady Perla:
3.14; 255.000; 3.6e20; # it's 3.6 times 10 to the 20th -3.6e20; # same as above, but negative -3.6e-20; #it's negative 3.6 times 10 to the -20th -3.6E-20; #we also can use E – this means the same the lowercase version -3.6e-20
Reprezentacja ósemkowa, szesnastkowa i binarna:
Jest to alternatywa dla systemu dziesiętnego. Pozwól, że pokażę ci reprezentację ósemkową, szesnastkową i binarną. Krótka tabelka przedstawia wszystkie ważne informacje na temat tych dziwnych stylów:
Reprezentacja | Baza | Kontynuowano |
---|---|---|
Oktal | 8 | 0 (zero) |
Szesnastkowy | 16 | 0x |
Binarna | 2 | 0b |
Przykłady Perla:
255; # 255 in decimal notation 0377; # 255 in octal notation 0xff; # 255 in hexadecimal notation 0b11111111; # 255 in binary notation
Wszystkie te wartości dla Perla oznaczają to samo. Perl nie przechowuje wartości w tym samym formacie. Wewnętrznie przekonwertuje te wartości szesnastkowe, binarne i ósemkowe na dziesiętne.
Przypisanie jest najczęstszą operacją na skalarze i jest bardzo proste. Perl używa do tego znaku równości. Pobiera wartość wyrażenia z prawej strony i umieszcza tę wartość w naszej zmiennej.
Spójrzmy na przykłady:
$size=15; # give $size value of 15 $y = -7.78; # give $y value of -7.78
Co więcej, do zmiennej możesz wstawić nie tylko liczbę, ale także wyrażenie.
$z = 6 + 12 # give $z value of 18
Smyczki
Struny: Jest to również bardzo prosty typ skalara.
Maksymalna długość ciągu w Perlu zależy od ilości pamięci, jaką posiada komputer. Nie ma ograniczeń co do rozmiaru ciągu, ciągi mogą składać się z dowolnej liczby znaków, symboli lub słów. Najkrótszy ciąg nie zawiera znaków. Najdłuższy może zapełnić całą pamięć systemu. Programy w języku Perl można pisać w całości przy użyciu 7-bitowego zestawu znaków ASCII. Perl pozwala także na dodanie dowolnego 8-bitowego lub 16-bitowego zestawu znaków, tzw. znaki inne niż ASCII w literałach łańcuchowych. Perl dodał także obsługę Unicode UTF-8.
Podobnie jak w przypadku liczb, istnieją dwa rodzaje ciągów znaków:
- Literały ciągu z pojedynczym cudzysłowem
- Double cytuje literały łańcuchowe
Literały ciągu w pojedynczym cudzysłowie
Pojedyncze cudzysłowy służą do ujęcia danych, które należy rozumieć dosłownie. Krótki przykład i wszystko powinno być jasne:
Przykłady Perla:
#!/usr/bin/perl $num = 7; $txt = 'it is $num'; print $txt;
Wyjście:
to jest liczba dolarów
Tutaj ze względu na pojedynczy cudzysłów wartość $num nie została pobrana, a dosłowne znaki „$”, „n”, „u” i „m” są dodawane do wartości $txt
Double-cytowane literały ciągu
Double cudzysłowy są używane do ujmowania danych, które muszą zostać interpolowane przed przetworzeniem. Oznacza to, że znaki ucieczki i zmienne nie są po prostu dosłownie wstawiane do późniejszych operacji, ale są oceniane na miejscu. Znaki ucieczki mogą być używane do wstawiania nowych linii, tabulatorów itp.
Przykłady Perla:
$num = 7; $txt = "it is $num"; print $txt;
Wyjście:
to jest 7
Tutaj ze względu na podwójne cudzysłowy wartość $num jest dodawana do wartości $txt
Double-cudzysłowy interpolują zmienne skalarne i tablicowe, ale nie hasze. Z drugiej strony, możesz użyć cudzysłowów, aby interpolować wycinki zarówno tablic, jak i haszy.
Tajemniczy \n
Rozważ następujący program
Przykłady Perla:
print "hello \n";
Wyjście:
cześć
Perl nie wyświetla tylko „cześć\n”, ale tylko „witaj”. Dlaczego? Ponieważ '\n' jest znakiem specjalnym i oznacza, że podczas wyświetlania tekstu w programie chcesz przejść do nowej linii. wydrukuj „witaj\n nową linię”; Następne pytanie – czy są jakieś inne znaki specjalne? Tak, oni są! Ale nie martw się – tylko kilka. Sprawdź poniższą tabelę
Skonstruować | Opisy Konstrukcyjne |
---|---|
\n | Nowa linia |
\r | powrót |
\t | Zakładka |
\f | podawanie kształtowe |
\b | Backspace |
\a | dzwon |
\e | uciec |
\007 | dowolna ósemkowa wartość ASCII (tutaj 007 = dzwonek) |
\x7f | dowolna wartość szesnastkowa (tutaj 7f = usuń) |
\\ | ukośnik wsteczny |
\ ” | cudzysłów |
\l | następna litera z małej litery |
\L | małe litery wszystkie następujące po sobie aż do \E |
\u | wielka następna litera |
\U | wielkie litery wszystkie następujące po sobie aż do \E |
\E | Zakończ \L, \U |
Wiem, że nie ma „tylko kilku”… Ale uwierz mi, musisz to wiedzieć
Zmienna ciągów
To ta sama operacja, którą widzimy w przypisywaniu liczb. Perl pobiera nasz ciąg z prawej strony znaku równości i umieszcza ten ciąg w zmiennej.
Przykłady Perla:
$string = 'tutorial'; # give $string the eight-character string 'tutorial' print $string; $string = $size + 3 ; # give $string the current value of $size plus 3 print $string; $string = $ string * 5; # multiplied $string by 5 print $string;
Wyjście:
samouczek315
Jak widać, można umieścić liczby i ciągi znaków w tych samych zmiennych. Nie ma klasy zmiennych.
Łączenie ciągów (kropka):
Operator konkatenacji „.” łączy dwa lub więcej ciągów znaków. Pamiętaj! Jeśli ciąg znaków zawiera cudzysłowy, znaki powrotu karetki, ukośniki odwrotne, wszystkie te znaki specjalne muszą zostać poprzedzone ukośnikiem odwrotnym.
Zmienna Perla „” Przykłady:
#!/usr/bin/perl $a = "Tom is"; $b = "favorite cat"; $c = $a ." mother's ". $b; print $c;
Wyjście:
Tomek jest ulubionym kotem mamy
Sznurki
„$a”, „$b” są łączone i przechowywane w „$c” za pomocą operatora „.”
Na końcu…
Konwersja pomiędzy Numbers i ciągi:
Jak wiesz, Perl automatycznie konwertuje liczby na ciągi znaków, gdy jest to potrzebne. Skąd Perl wie, czego potrzebujemy w danej chwili? To proste — wszystko zależy od operatora (później porozmawiamy o operatorach, teraz zaakceptujmy, że jest ich wiele, różnych dla liczb i ciągów znaków). Jeśli operator oczekuje liczby, Perl użyje wartości jako liczby. Jeśli operator oczekuje ciągu znaków, Perl użyje wartości jako ciągu znaków. Innymi słowy — nie musisz się martwić o tego typu konwersję. Krótki przykład i wszystko powinno być jasne:
Przykłady Perla:
$string = "43"; $number = 28; $result = $string + $number; print $result;
Wyjście:
71
wartość $string jest konwertowana na liczbę całkowitą i dodawana do wartości $number.
Wynik dodania, 71, jest przypisywany do $result.
Zasięg zmiennej – Modyfikatory dostępu
Skalar możemy zadeklarować w dowolnym miejscu programu. Ale musisz określić modyfikator dostępu
Istnieją 3 rodzaje modyfikatorów
- my
- miejscowy
- ludzkiej,
My: Za pomocą tego możesz zadeklarować dowolną zmienną, która jest specyficzna w bloku. tj. w nawiasach klamrowych.
#!/usr/bin/perl my $var=5; if(1) { my $var_2 =$var; } print $var_2;
Brak wyjścia
Wynik programu nie będzie niczym!
W powyższym przykładzie zobaczysz, że zadeklarowano dwie zmienne, jedna znajduje się wewnątrz bloku if ($var_2), a druga znajduje się poza blokiem If ($var). Zmienna zadeklarowana poza blokiem będzie dostępna dla bloku if, natomiast zmienna zadeklarowana wewnątrz bloku if nie będzie dostępna dla programu zewnętrznego.
Lokalnie: Używając tego, możemy faktycznie zamaskować te same wartości zmiennych do różnych wartości bez faktycznej zmiany pierwotnej wartości zmiennej. Załóżmy, że mamy zmienną $a, której wartość jest przypisana 5. W rzeczywistości możesz zmienić wartość tej zmiennej poprzez ponowna deklaracja tej samej zmiennej przy użyciu słowa kluczowego local bez zmiany pierwotnej wartości zmiennej, która wynosi 5. Zobaczmy, jak to działa na przykładzie.
#!/usr/bin/perl $var = 5; { local $var = 3; print "local,\$var = $var \n"; } print "global,\$var = $var \n";
Dane wyjściowe powyższego programu będą wyglądać w ten sposób.
lokalny, $zmienna = 3
globalny, $zmienna = 5
W ten sposób możemy zmienić wartość zmiennej bez wpływu na wartość pierwotną.
Our: Po zadeklarowaniu zmiennej z modyfikatorem dostępu „nasz” można jej używać w całym pakiecie. Załóżmy, że masz moduł Perla lub pakiet test.pm, który ma zadeklarowaną zmienną o zasięgu nasz. Dostęp do tej zmiennej można uzyskać w dowolnym skrypcie, który będzie korzystał z tego pakietu.
Jeśli poważnie myślisz o programowaniu w Perlu, powinieneś zacząć swój program od
#!/usr/local/bin/perl
używaj ścisłego;
Pomoże Ci to pisać lepszy i czystszy kod. „użyj ścisłego” włącza ścisłą pragmę, która sprawi, że zadeklarujesz zmienne za pomocą mojego słowa kluczowego.
Jest to dobra praktyka programistyczna
#!/usr/local/bin/perl use strict; $var = 10; print "$var";
Wynik: błąd
#!/usr/local/bin/perl use strict; my $var = 10; print "$var";
Wyjście:
10
Tablica Perla
Co to jest tablica Perla?
Tablica to specjalny typ zmiennej, który przechowuje dane w formie listy; do każdego elementu można uzyskać dostęp za pomocą numeru indeksu, który będzie unikalny dla każdego elementu. W tablicy można przechowywać liczby, ciągi znaków, wartości zmiennoprzecinkowe itp. Wygląda to świetnie. Jak więc utworzyć tablicę w Perlu? W Perlu można zdefiniować tablicę za pomocą znaku „@”, po którym następuje nazwa, którą chcesz nadać. Rozważmy zdefiniowanie tablicy w Perlu.
moja @tablica;
Oto jak definiujemy tablicę w Perlu; być może zastanawiasz się, w jaki sposób musimy przechowywać w nim dane. Istnieją różne sposoby przechowywania danych w tablicy. To zależy od tego, jak będziesz go używać.
my @array=(a,b,c,d); print @array;
Wyjście:
abcd
To jest tablica zawierająca 4 elementy.
Indeks tablicy zaczyna się od 0 i kończy do maksymalnego zadeklarowanego rozmiaru, w tym przypadku maksymalny rozmiar indeksu wynosi 3.
Przykład tablicy Perla
Możesz także zadeklarować tablicę w powyższy sposób; jedyna różnica polega na tym, że przechowuje dane w tablicy, uznając białą spację za ogranicznik. Tutaj qw() oznacza słowo cudzysłowu. Znaczenie tej funkcji polega na wygenerowaniu listy słów. Możesz użyć qw na wiele sposobów, aby zadeklarować tablicę.
@array1=qw/a b c d/; @array2= qw' p q r s'; @array3=qw { v x y z}; print @array1; print @array2; print @array3;
Wyjście:
abcdpqrsvxyz
Załóżmy, że chcesz przypisać wartość do 5th element tablicy, jak to zrobimy.
$tablica [4] ='e';
Układ sekwencyjny
Tablice sekwencyjne to takie, w których przechowujesz dane sekwencyjnie. Załóżmy, że chcesz przechowywać 1-10 liczb lub liter alfabetu az w tablicy. Zamiast wpisywać wszystkie litery, możesz spróbować czegoś takiego jak poniżej –
@numbers= (1..10); print @numbers; #Prints numbers from 1 to 10;
Wyjście:
12345678910
Rozmiar tablicy Perla
Mamy tablicę, która jest już dostępna i nie wiesz, jaki jest rozmiar tej tablicy, więc jaki jest możliwy sposób jej znalezienia.
@array= qw/a b c d e/; print $size=scalar (@array);
Czy możemy uzyskać rozmiar tablicy bez użycia funkcji? Tak możemy.
@array= qw/a b c d e/; print $size=scalar (@array); print "\n"; print $size=$#array + 1; # $#array will print the Max Index of the array, which is 5 in this case
Wyjście:
5
5
Tablica dynamiczna
Powyższa metoda deklarowania tablicy nazywa się tablice statyczne, gdzie znasz rozmiar tablicy.
Co to jest tablica dynamiczna?
Tablice dynamiczne to te, które deklarujesz bez podawania żadnej wartości. Kiedy więc dokładnie przechowujemy wartości w tej tablicy? To proste, przechowujemy je w czasie wykonywania. Oto prosty program do tego.
Do wykonania tego zadania będziemy używać wbudowanych funkcji Perla.
my $string="This is a kind of dynamic array"; my @array; @array=split('a',$string); foreach(@array) { print "$_ \n”; # This is a special variable which stores the current value. }
Wyjście:
To jest
rodzaj dynu
mic
rr
y
Funkcja split dzieli zawartość ciągu na tablicę w oparciu o dostarczony ogranicznik. Ta funkcja usunie również ogranicznik z ciągu, w tym przypadku jest to „a”;
Push, Pop, shift, unshift dla tablic Perl:
Tych funkcji można używać w Perlu do dodawania/usuwania elementów tablicy.
- Perl Push: dodaje element tablicy na końcu istniejącej tablicy.
- Perl Pop: usuwa ostatni element z tablicy.
- Perl Shift: usuwa pierwszy element z tablicy.
- Perl Unshift: dodaje element na początku tablicy.
Zobaczmy przykład, w którym możemy skorzystać z poniższych funkcji.
@days = ("Mon","Tue","Wed"); print "1st : @days\n"; push(@days, "Thu"); # adds one element at the end of an array print "2nd when push : @days\n"; unshift(@days, "Fri"); # adds one element at the beginning of an array print "3rd when unshift : @days\n"; pop(@days); print "4th when pop : @days\n"; # remove one element from the last of an array. shift(@days); # remove one element from the beginning of an array. print "5th when shift : @days\n";
Wyjście:
1.: pon. wt. śr
2. po naciśnięciu: pon. wt. śr. czw
3. przy zmianie biegów: Pt Pon Wt Śr Czw
4. kiedy pop: piątek pon. wt. śr
5. kiedy zmiana: Pon Wt Śr
Hashe Perla
Dlaczego potrzebujemy Hasha?
O skalarach i tablicach dowiedzieliśmy się już w poprzednich sekcjach.
Co dokładnie robią skalary? Przechowuje tylko liczby całkowite i ciągi znaków.
Co dokładnie robią tablice? Jest to zbiór skalarów, w którym dostęp do każdego elementu tablicy można uzyskać za pomocą indeksów. Ale czy dobrym pomysłem jest użycie tablicy, gdy masz setki i tysiące rekordów? Zapomnimy, który indeks ma jaką wartość. Aby przezwyciężyć tę sytuację, mamy coś w rodzaju skrótu Perla.
Co to są hashe?
Hash może również zawierać tyle skalarów, ile może pomieścić tablica. Jedyna różnica polega na tym, że nie mamy żadnego indeksu, mamy raczej klucze i wartości. Można zadeklarować skrót, zaczynając od %, po którym następuje nazwa skrótu. Zobaczmy przykład, jak możemy zdefiniować hash Perla i jak możemy odróżnić go od tablicy
Rozważmy przykład trzech osób, a ich wiek przedstawiono w tablicy.
@array=('Sainath',23,'Krishna',24,'Shruthi',25); #This is how an array looks. print @array;
Wyjście:
Sainath33Krishna24Śruti25
W ten sposób trudno jest określić wiek poszczególnych osób, gdyż musimy pamiętać zarówno lokalizację indeksu imion, jak i wiek wszystkich osób. Może to być proste, gdy masz 3 nazwiska, ale gdy masz 1000 lub więcej? Znasz odpowiedź.
Możemy to pokonać za pomocą skrótu.
Przykład skrótu:
print %hash=( 'Sainath' => 23, 'Krishna' => 24, 'Shruthi' => 25); # This is how we create a hash. print %hash=('Sainath',23,'Krishna',24,'Shruthi',25);# This way of assigning is called list.
Wyjście:
Sainath33Krishna24Shruthi25Sainath33Krishna24Śruti25
Zadeklarowaliśmy teraz skrót, świetnie!! Ale jak uzyskać do niego dostęp lub go wydrukować? Do każdego elementu w haszu należy uzyskać dostęp za pomocą powiązanego z nim klucza, do którego zostanie przypisana wartość. Zatem istnieje odwzorowanie typu „jeden jeden” pomiędzy każdym kluczem i wartością w haszu.
Aby wydrukować wiek dowolnej osoby, wystarczy zapamiętać imię tej osoby.
print $hash{'Krishna'}; # This how we should access a hash. Key enclosed within {}.
Być może zastanawiałeś się, dlaczego użyłem $hash{KeyName}, pamiętaj, że hash to znowu zbiór skalarów. Możemy więc użyć $, który reprezentuje skalar, aby uzyskać dostęp do każdego elementu skrótu.
Uwaga: każdy klucz w hashu powinien być unikalny, w przeciwnym razie nadpisze twoją wartość, która została wcześniej przypisana.
Jak możemy przypisać skrót do innego skrótu? Prosty, taki sam sposób jak my
Możemy również wydrukować cały skrót.
%hash=( 'Tom' => 23); %newHash=%hash; # Assigning hash to a new hashprint %newHash; print %newHash;
Wyjście:
Tom23
Dodaj skróty Perla
Jak widać, mamy już hash %newHash, a teraz musimy dodać do niego więcej wpisów.
$newHash{'Jim'}=25; $newHash{'John'}=26; $newHash{'Harry'}=27; print %newHash;
Wyjście:
Jim25John26Harry27
Perl Usuń klucz
Możesz chcieć usunąć wpis ze skrótu. W ten sposób możemy to zrobić.
delete $newHash{'Jim'};#This will delete an entry from the hash.
Usuń jest wbudowaną funkcją Perla. Tutaj zobaczymy przykład przypisania skrótu do tablicy.
@array=%newHash; print "@array";
Uwaga: za każdym razem, gdy drukujesz skrót lub przechowujesz skrót w tablicy. Kolejność zawsze może się różnić. Nie zawsze jest tak samo.
Do tablicy możemy przypisać tylko klucze lub wartości skrótu.
@arraykeys= keys(%newHash); @arrayvalues=values(%newHash); print "@arraykeys\n"; print "@arrayvalues\n"; # \n to print new line.
Aby usunąć wszystkie wpisy w hashu, możemy bezpośrednio przypisać hash do wartości null.
%newHash=();# Spowoduje to przedefiniowanie skrótu bez wpisów.
Instrukcje warunkowe Perla
W Perlu możemy używać instrukcji warunkowych. Czym zatem są instrukcje warunkowe? Instrukcje warunkowe to takie, w przypadku których faktycznie sprawdzasz, czy w kodzie są spełnione pewne okoliczności.
Pomyśl o przykładzie: kupujesz owoce i nie podoba Ci się cena przekraczająca 100 dolarów. Zatem tutaj obowiązuje zasada 100 dolców.
Perl obsługuje dwa typy instrukcji warunkowych; są jeśli i chyba że.
Perl Jeśli
Jeśli zostanie wykonany blok kodu, gdy warunek jest spełniony.
my $a=5; if($a==5) { print "The value is $a"; }
Wyjście:
5
Perl, jeśli jest inaczej
To wygląda dobrze. Pomyślmy o sytuacji, w której $a nie wynosi 5.
my $a=10; if($a==5) { print "The values is $a ---PASS"; } else { print "The value is $a ---FAIL"; }
Wyjście:
Wartość wynosi 10 — FAIL
W ten sposób możemy kontrolować tylko jeden warunek na raz. Czy to ograniczenie? Nie, możesz także kontrolować różne warunki za pomocą if… elsif… else.
Perl Inaczej jeśli
my $a=5; if($a==6) { print "Executed If block -- The value is $a"; } elsif($a==5) { print "Executed elsif block --The value is $a"; } else { print "Executed else block – The value is $a"; }
Wyjście:
Wykonany blok elsif – wartość wynosi 5
W powyższym przypadku blok elsif zostanie wykonany, ponieważ $a jest równe 5.
Mogą zaistnieć sytuacje, w których zawiodą zarówno bloki kodu if, jak i elsif. W tym scenariuszu zostanie wykonany blok kodu else. W rzeczywistości możesz wyeliminować sprawdzanie kodu else, jeśli nie chcesz go dołączać.
Perl zagnieżdżony jeśli
W takim przypadku możesz użyć bloku kodu if w jeszcze jednym bloku kodu if.
my $a=11; #Change values to 11,2,5 and observe output if($a<10){ print "Inside 1st if block"; if($a<5){ print "Inside 2nd if block --- The value is $a"; } else{ print " Inside 2nd else block --- The value is $a"; } } else{ print "Inside 1st else block – The value is $a"; }
Wyjście:
Wewnątrz pierwszego bloku else — wartość wynosi 1
Wykonaj ten sam kod, zmieniając wartość $a; reszty możesz się dowiedzieć.
Perl Chyba, że
Masz już pomysł, co się stanie, jeśli (jeśli warunek jest prawdziwy, wykona blok kodu). Chyba że jest przeciwieństwem if, chyba że blok kodu zostanie wykonany, jeśli warunek jest fałszywy.
my $a=5; unless($a==5) { print "Inside the unless block --- The value is $a"; } else { print "Inside else block--- The value is $a"; }
Wyjście:
Wewnątrz pierwszego bloku else — wartość wynosi 1
Zgadnij, jaki będzie wynik. Masz rację!!!!!. Wynikiem będzie instrukcja print bloku else. Ze względu na warunek w chyba, że blok kodu jest prawdziwy, pamiętaj, że blok chyba nie zostanie wykonany tylko wtedy, gdy warunek jest fałszywy. Zmień wartość $a i wykonaj kod, zobaczysz różnicę.
Perl Używanie if
$a= " This is Perl"; if($a eq "SASSDSS"){ print "Inside If Block"; } else { print "Inside else block" }
Wyjście:
Wewnątrz innego bloku
Używanie, chyba że
$a= " This is Perl"; unless($a eq "SASSDSS"){ print "Inside unless Block"; } else { print "Inside else block" }
Wyjście:
Wewnątrz, chyba że Block
Pętle Perla – Struktury sterujące
Perl obsługuje struktury kontrolne podobne do innych języków programowania. Perl obsługuje cztery typy struktur kontrolnych for, fore, while i Until. Używamy tych instrukcji do wielokrotnego wykonywania jakiegoś kodu.
Dla pętli Perl
Dla bloku kodu będzie wykonywany dopóki warunek nie zostanie spełniony. Weźmy przykład, jak Perl zapętla tablicę.
my @array=(1..10); for(my $count=0;$count<10;$count++) { print "The array index $count value is $array[$count]"; print "\n"; }
Wyjście:
Wartość indeksu tablicy 0 wynosi 1
Wartość indeksu tablicy 1 wynosi 2
Wartość indeksu tablicy 2 wynosi 3
Wartość indeksu tablicy 3 wynosi 4
Wartość indeksu tablicy 4 wynosi 5
Wartość indeksu tablicy 5 wynosi 6
Wartość indeksu tablicy 6 wynosi 7
Wartość indeksu tablicy 7 wynosi 8
Wartość indeksu tablicy 8 wynosi 9
Wartość indeksu tablicy 9 wynosi 10
Tutaj, w wyrażeniu for (), zawartych jest wiele instrukcji. Każde z nich ma swoje znaczenie.
for (inicjalizacja; warunek; inkrementacja)
Oto inny sposób użycia for.
for(1..10) { print "$_ n"; print "\n"; }
Wyjście:
1n
2n
3n
4n
5n
6n
7n
8n
9n
10n
Perl Foreach
Instrukcja for each może być używana w taki sam sposób jak for; główna różnica polega na tym, że nie mamy w tym przypadku żadnej kontroli stanu ani inkrementacji.
Weźmy ten sam przykład z foreach Perl.
my @array=(1..10); foreach my $value (@array) { print " The value is $value\n"; }
Wyjście:
Wartość wynosi 1
Wartość wynosi 2
Wartość wynosi 3
Wartość wynosi 4
Wartość wynosi 5
Wartość wynosi 6
Wartość wynosi 7
Wartość wynosi 8
Wartość wynosi 9
Wartość wynosi 10
Foreach pobiera każdy element tablicy i przypisuje tę wartość do $var przy każdej iteracji. Możemy również użyć $_ do tego samego.
my @array=(1..10); foreach(@array) { print " The value is $_ \n"; # This is same as the above code. }
Wyjście:
Wartość wynosi 1
Wartość wynosi 2
Wartość wynosi 3
Wartość wynosi 4
Wartość wynosi 5
Wartość wynosi 6
Wartość wynosi 7
Wartość wynosi 8
Wartość wynosi 9
Wartość wynosi 10
Wygląda to dobrze w przypadku dostępu do tablic. A co z hashami, jak możemy uzyskać klucze skrótu i wartości za pomocą foreach?
Możemy użyć foreach, aby uzyskać dostęp do kluczy i wartości skrótu, zapętlając go.
my %hash=( 'Tom' => 23, 'Jerry' => 24, 'Mickey' => 25); foreach my $key (keys %hash) { print "$key \n"; }
Wyjście:
Mickey
Tomek
Nocnik
Być może zastanawiasz się, dlaczego użyliśmy klawiszy w funkcji foreach(). Klucze to wbudowana funkcja Perla, dzięki której możemy szybko uzyskać dostęp do kluczy skrótu. A co z wartościami? Możemy użyć funkcji wartości, aby uzyskać dostęp do wartości skrótu.
my %hash=( 'Tom' => 23, 'Jerry' => 24, 'Mickey' => 25); foreach my $value(values %hash) # This will push each value of the key to $value { print " the value is $value \n"; }
Wyjście:
wartość wynosi 24
wartość wynosi 23
wartość wynosi 25
Perl Podczas
Pętla While w Perlu jest strukturą kontrolną, w której blok kodu będzie wykonywany, dopóki warunek nie zostanie spełniony.
Blok kodu zakończy działanie tylko wtedy, gdy warunek będzie fałszywy.
Weźmy przykład pętli Perl While.
Oto problem, który będzie wymagał wprowadzenia danych przez użytkownika i nie zakończy się, dopóki liczba nie zostanie podana jako „7”.
#!/usr/bin/perl $guru99 = 0; $luckynum = 7; print "Guess a Number Between 1 and 10\n"; $guru99 = <STDIN>; while ($guru99 != $luckynum) { print "Guess a Number Between 1 and 10 \n "; $guru99 = <STDIN>; } print "You guessed the lucky number 7"
Wyjście:
Odgadnij liczbę od 1 do 10
9
Odgadnij liczbę od 1 do 10
5
Odgadnij liczbę od 1 do 10
7
Zgadłeś szczęśliwą liczbę 7
W powyższym przykładzie warunek while nie będzie spełniony, jeżeli wprowadzimy dane inne niż '7'.
Jeśli zobaczysz, jak działa while, blok kodu zostanie wykonany tylko wtedy, gdy warunek za chwilę będzie prawdziwy.
Perl do-while
Pętla Do while wykona się co najmniej raz, nawet jeśli warunek w sekcji while jest fałszywy.
Weźmy ten sam przykład, używając do while.
$guru99 = 10; do { print "$guru99 \n"; $guru99--; } while ($guru99 >= 1); print "Now value is less than 1";
Wyjście:
10
9
8
7
6
5
4
3
2
1
Teraz wartość jest mniejsza niż 1
Perł do
Dopóki blok kodu nie jest podobny do chyba w instrukcji warunkowej. W tym przypadku blok kodu zostanie wykonany tylko wtedy, gdy warunek w bloku dopóki nie będzie fałszywy.
Weźmy ten sam przykład, którego użyliśmy w przypadku chwilę.
Oto problem, który będzie wymagał wprowadzenia danych przez użytkownika i nie zakończy się, dopóki nie zostanie podana nazwa inna niż „sai”.
print "Enter any name \n"; my $name=<STDIN>; chomp($name); until($name ne 'sai') { print "Enter any name \n"; $name=<STDIN>; chomp($name); }
Wyjście:
Wpisz dowolną nazwę Sai
Perl do-aż:
Funkcji Do Until można użyć tylko wtedy, gdy warunek ma być fałszywy i powinien zostać wykonany co najmniej raz.
print "Enter any name \n"; my $name=<STDIN>; chomp($name); do { print "Enter any name \n"; $name=<STDIN>; chomp($name); }until($name ne 'sai');
Wyjście:
Wpisz dowolne imię Howard
Wpisz dowolne imię Sheldon
Wpisz dowolną nazwę Sai
Wykonaj przykładowe kody while, do-while, before i do-until, aby zobaczyć różnicę.
Perl OperaTor
Czym jest Operasłup?
Operatory w języku komputerowym oznaczają akcję, którą można wykonać na pewnym zestawie zmiennych lub wartościach zrozumiałych dla komputera. Perl włączył większość Operators z języka C. Perl ma wiele operatorów w porównaniu z innymi językami programowania. OperaOperatory te dzielimy na operatory arytmetyczne, logiczne, relacyjne i przypisania.
Arytmetyka Operatory:
Operatorzy arytmetyczni to operatory, których można używać do wykonywania podstawowych operacji matematycznych. Te operatory arytmetyczne to operatory binarne, w przypadku których potrzebujemy dwóch argumentów, aby wykonać podstawową operację. Możemy również używać operatorów jednoargumentowych do innych podstawowych operacji; różnicę można zobaczyć w poniższych przykładach.
OperaTor | Opisy Konstrukcyjne | Przykład |
---|---|---|
+ |
Operacja dodawania służąca do dodawania dwóch wartości lub zmiennych trzymając wartości |
$x=5+6; # Lub $y=6; $z=$x+$y; |
- |
Operator odejmowania używany do odejmowania dwóch wartości lub zmiennych zawierających wartości |
$x=6-5; # Lub $y=6; $z=$x-$y; |
* |
Operator mnożenia używany do mnożenia dwóch wartości lub zmiennych zawierających wartości |
$x=6*5; # Lub $y=6; $z=$x*$y; |
/ |
Operator dzielenia używany do dzielenia dwóch wartości lub zmiennych zawierających wartości |
$x=36/6; # Lub $y=6; $z=$x/$y; |
** |
Operator wykładniczy używany do podania wykładnika i pobrania jego wartości. Np.: 22 = 43 = 27 |
$x=5**5; # Lub $x=4; $y=2; $z=$x**$y; |
% |
Operator modulo używany do uzyskania przypomnienia podczas dzielenia dwóch wartości lub zmiennych zawierających wartości |
$x=5%2; # Lub $x=10; $y=2; $z=$x% $y; |
++ |
Operator dodawania unarnego zwiększający wartość zmiennej o 1 |
$x=5; $x++; Or ++$x; |
- |
Operator odejmowania unarnego zmniejszający wartość zmiennej o 1 |
$x=5; $x–; # zmniejszenie liczby postów Or –$x;# wstępne zmniejszenie |
Przykład wykonania wszystkich powyższych operacji.
my $x=10; my $y=2; my $z; $z=$x+$y; print ("Add of $x and $y is $z \n"); $z=$x-$y; print ("Sub of $x and $y is $z \n"); $z=$x*$y; print ("Mul of $x and $y is $z \n"); $z=$x/$y; print ("Div of $x and $y is $z \n"); $z=$x**$y; print ("Exp of $x and $y is $z \n"); $z=$x%$y; print ("Mod of $x and $y is $z \n");
Wyjście:
Dodanie 10 i 2 daje 12
Pod liczbą 10 i 2 jest 8
Mul 10 i 2 równa się 20
Dzielnik 10 i 2 równa się 5
Exp 10 i 2 to 100
Mod 10 i 2 to 0
Cesja Operatory:
Operatorzy przypisania po prostu przypisują wartości zmiennym, ale jest jeszcze jedna rzecz, o której musimy pamiętać – operatorzy przypisania wykonują również operacje arytmetyczne i przypisują nową wartość tej samej zmiennej, na której przeprowadzana jest operacja.
OperaTor | Opisy Konstrukcyjne | Przykład |
---|---|---|
+= |
Operator dodawania służący do dodawania i przypisywania wartości tej samej zmiennej |
$x=4; $x+=10; |
-= |
Operator odejmowania służący do odejmowania i przypisywania wartości tej samej zmiennej |
$x=4; $x-=10; |
*= |
Operator mnożenia służący do dodawania i przypisywania wartości tej samej zmiennej |
$x=4; $x*=10; |
/= |
Operator dzielenia używany do dzielenia i przypisywania wartości tej samej zmiennej |
$x=4; $x/=10; |
** = |
Operator wykładniczy używany do uzyskania wykładnika i przypisania wartości do tej samej zmiennej |
$x=4; $x**=10; |
%= |
Operator modulo używany do uzyskania przypomnienia podczas dzielenia i przypisania wartości do tej samej zmiennej |
$x=10; $x%=4; |
Przykład wykonania wszystkich powyższych operacji.
my $x=10; $x+=5; print("Add = $x\n"); $x-=5; print("Sub= $x\n"); $x*=5; print("Mul = $x\n"); $x/=5; print("Div = $x\n");
Wyjście:
Dodaj = 15
Sub= 10
Mul = 50
Dział = 10
Logiczne i relacyjne Operatory:
Perl używa operatorów logicznych do porównywania liczb i ciągów znaków. Najczęściej operatory logiczne są używane w instrukcjach warunkowych.
Logiczne i relacyjne Operatory w Perlu
OperaTor | Opisy Konstrukcyjne |
---|---|
==lub równ |
OperaTor służy do sprawdzania, czy obie zmienne są równe |
!=Albo nie |
OperaTor służy do sprawdzania, czy obie zmienne nie są równe |
> lub gt |
OperaTor używany do sprawdzania, czy A jest większe niż B |
<or lt |
OperaTor używany do sprawdzania, czy A jest mniejsze niż B. |
>=lub ge |
OperaTor używany do sprawdzania, czy A jest większe lub równe B |
<=lub le |
OperaTor używany do sprawdzania, czy A jest mniejsze lub równe B |
|| albo albo |
OperaTor używany do sprawdzania, czy A lub B trzyma wartość |
&&albo i |
OperaTor używany do sprawdzania, czy A i B trzymają wartość |
Weźmy przykład, w którym możemy wyjaśnić wszystkie scenariusze.
my $x=5; my $y=5; if($x == $y){ print ("True -- equal $x and $y \n"); } else{ print ("False -- not equal $x and $y\n"); } $x=6; $y=7; if($x != $y){ print ("True -- not equal $x and $y\n"); } else{ print ("False -- equal $x and $y\n"); } if($y > $x){ print ("True -- $y greater than $x\n"); } else{ print ("False -- $y greater than $x\n"); } if($x < $y){ print ("True -- $x less than $y\n"); } else{ print ("False -- $x less than $y\n"); } if($x <= $y){ print ("True -- $x less than $y\n"); } else{ print ("False -- $x less than $y\n"); } if($y >= $x){ print ("True -- $y greater than $x\n"); } else{ print ("False -- $y greater than $x\n"); }
Wyjście:
Prawda — równa się 5 i 5
Prawda — nie równa się 6 i 7
To prawda — 7 jest większe niż 6
To prawda – 6 mniej niż 7
To prawda – 6 mniej niż 7
To prawda — 7 jest większe niż 6
Przykłady operatorów logicznych można znaleźć w dalszych sekcjach.
Specjalne zmienne Perla
Co to są zmienne specjalne Perla?
Zmienne specjalne w Perlu to te, które mają pewne z góry określone znaczenie. Zmienne te są oznaczone prawdziwymi nazwami lub symbolami interpunkcyjnymi. Mamy specjalną zmienną dla wszystkich zmiennych obsługiwanych przez Perl, taką jak specjalne zmienne skalarne, specjalne zmienne Array, specjalne zmienne mieszające. Większość zmiennych specjalnych, których używamy, ma charakter skalarny.
Kiedy chcemy użyć specjalnej zmiennej z jej nazwą, musimy załadować moduł Perla „use English”, aby wyraźnie powiedzieć interpreterowi Perla, że będziemy używać specjalnych zmiennych, używając jej nazwy.
Skalarne zmienne specjalne
Zmienna | Opisy Konstrukcyjne |
---|---|
$_$ARG |
Jest to domyślna zmienna przechowująca bieżące wartości. |
0 USD lub $PROGRAM_NAME |
Przechowuje nazwę pliku skryptu Perla. |
$/ |
Separator rekordów wejściowych, ma domyślną wartość „\n”, która jest znakiem nowej linii |
$. |
Przechowuje bieżący numer linii odczytywanego pliku |
$, |
Separator pola wyjściowego, używany głównie przez instrukcję print(). Domyślnie wartość tej zmiennej jest ustawiona na 0, możemy zmienić wartość tej zmiennej. |
$\ |
Wyprowadź separator rekordów, wartość tej zmiennej będzie pusta; możemy do tego przypisać dowolną wartość, która będzie używana przez instrukcję print() podczas drukowania wyniku. |
$# |
Ta zmienna jest używana do określenia formatu wyjściowego podczas drukowania liczb. |
$%$FORMAT_PAGE_NUMBER |
Przechowuje bieżący numer strony przeczytanego pliku. |
$=$FORMAT_LINES_PER_PAGE |
Zatrzyma bieżącą długość strony odczytanego pliku. |
$-$FORMAT_LINES_LEFT |
Przechowuje wartość liczby wierszy pozostałych do wydrukowania ze strony. |
$~$FORMAT_NAME |
Nazwa formatu: Domyślnie przechowuje format aktualnie wybranego wyjścia jako nazwę uchwytu pliku. |
$^$FORMAT_TOP_NAME |
Przechowuje wartość formatu nagłówka procedury obsługi pliku, domyślnie wartością będzie _TOP, po której następuje nazwa uchwytu pliku. |
$|$WYJŚCIE_AUTOFLUSH |
Wartość domyślna wynosi zero; służy ona do opróżniania bufora wyjściowego po każdym zapisie (write) lub wydruku (print). |
$$ |
Będzie przechowywać numer uruchomionego procesu interpretera Perla. |
$? |
Kod stanu: Potok i wywołanie systemowe. Status powrotu wykonanego polecenia. |
DOPASOWANIE $&$ |
Używany w wyrażeniach regularnych, przechowuje ciąg ostatniego pomyślnego dopasowania wzorca. |
$`$PREMEC |
Używane w wyrażeniach regularnych, przechowuje ciąg znaków poprzedzony ostatnim pomyślnym dopasowaniem wzorca. |
$'$POMECZ |
Używane w wyrażeniach regularnych, przechowuje ciąg znaków, po którym następuje ostatnie pomyślne dopasowanie wzorca. |
$+$LAST_PAREN_MATCH |
Przechowuje ciąg ostatniego nawiasu pasującego podczas ostatniego wyszukiwania wzorca. |
$ |
1 dolar, 2 dolar, 3 dolary…. Przechowuje wartości wzorca dopasowanego w kolejności. |
$[ |
Pierwszy indeks: Array, podciąg. |
$] |
Wersja Perla. |
$” |
Separator używany dla elementów listy, domyślnie jest to spacja. |
$; |
Separator indeksu dolnego używany w tablicach wielowymiarowych |
$! |
W kontekście numerycznym drukuje numer błędu. W kontekście ciągu znaków wypisz błąd. |
$@ |
Przechowuje informacje o błędach składniowych, używane podczas używania funkcji eval(). |
$< |
Przechowuje prawdziwy UID (identyfikator użytkownika) procesu uruchamiającego skrypt. |
$> |
Przechowuje efektywny UID procesu uruchamiającego skrypt. |
$( |
Przechowuje prawdziwy GID (identyfikator grupy) procesu uruchamiającego skrypt. |
$) |
Przechowuje efektywny GID procesu uruchamiającego skrypt. |
$^D$DEBUGOWANIE |
Przechowuje bieżącą wartość flag debugowania. |
$^C |
Przechowuje bieżącą wartość flagi, gdy używany jest przełącznik wiersza poleceń –c. |
$^F |
Maksymalny deskryptor pliku systemowego domyślnie jest ustawiony na 2 |
$^I$INPLACE_EDIT |
Przechowuje wartość –i przełącznika wiersza poleceń. |
$^M |
Specjalnej puli pamięci można użyć, gdy skrypt Perla umiera z powodu błędu braku pamięci. |
$^O$OSNAZWA |
OperaInformacje o systemie są przechowywane. „Linux” dla systemów Linux, „mswin32” dla Windows systemy. |
$^T$CZAS PODSTAWOWY |
Czas działania skryptów w sekundach. |
$^W$OSTRZEŻENIE |
Bieżąca wartość przełącznika –w wiersza poleceń. Przełącznik ostrzegawczy. |
$ARGV |
Nazwa bieżącego pliku, jeśli użyto <>. |
Specjalne zmienne tablicowe:
Zmienna | Opisy Konstrukcyjne |
---|---|
@INC |
Przechowuje listę ścieżek, gdzie można przeglądać moduły biblioteki Perla lub skrypty podczas wykonywania bieżącego skryptu. To @INC jest używane przez użycie i wymaga instrukcji sprawdzających te ścieżki dla modułów bibliotecznych. |
@agawa |
Przechowuje przekazane argumenty wiersza poleceń. |
@_ |
Stosowany w podprogramach, podczas przekazywania parametrów do podprogramów. |
@F |
Jest to tablica, w której przechowywane są linie wejściowe podczas automatycznego podziału –a (używany jest przełącznik wiersza poleceń). |
Hashowe zmienne specjalne:
Zmienna | Opisy Konstrukcyjne |
---|---|
%INC |
Nazwa pliku będzie kluczem; wartości będą ścieżką do tych plików. Używane przez do, use i require. |
%ENW |
Zmienne środowiskowe systemu. |
%SYG |
Signalopiekun. |
Wyrażenie regularne Perla
Co to jest wyrażenie regularne?
Wyrażenie regularne Perla jest wystarczająco silne, aby dopasować wzorce ciągu w obrębie instrukcji lub grupy instrukcji. Wyrażenia regularne są najczęściej używane w analizie tekstu, dopasowywaniu wzorców i wielu innych czynnościach w zależności od wymagań. Mamy pewne operatory, które są specjalnie używane przez wiązanie wzorców wyrażeń regularnych =~ i !~, Są to operatory testowe i przypisania.
Wyrażenie regularne Operatorsy
Wyrażenie regularne Operatory w Perlu
- Perłowy mecz — m//
- Substytut Perla – s///
- Transliteracja Perla – tr///
Zanim przejdziemy dalej, musimy wiedzieć kilka rzeczy o wyrażeniach regularnych; istnieją pewne rzeczy, takie jak znaki Meta, symbole wieloznaczne w składni Perl Regex.
Zwęglać | Znaczenie |
---|---|
\ |
Specjalne lub cytat |
* |
Dopasuj 0 lub więcej znaków |
+ |
Dopasuj 1 lub więcej znaków |
? |
Dopasuj 0 lub 1 znak |
| |
Można go wykorzystać do dopasowania alternatywnych wzorów |
() |
Służy do przechowywania dopasowanego wzoru |
[] |
Można przekazać zestaw znaków. Stosowany szczególnie do cyfr i alfabetów. |
{} |
Służy do podawania liczby czasu, przez jaki można przeprowadzić mecz. |
^ |
Początek ciągu |
$ |
Koniec sznurka |
\w |
Służy do dopasowywania pojedynczego znaku lub słowa, które może być alfanumeryczne, w tym „_” |
\W |
Dopasowuje wszystko inne niż alfanumeryczne |
\s |
Służy do dopasowywania białych znaków |
\S |
Dopasowuje wszystko inne niż białe znaki |
\d |
Dopasuj liczby. Nie wartości dziesiętne i wartości ujemne |
\D |
Dopasuj wszystko oprócz liczb. |
\t |
Dopasuj przestrzeń tabulacji |
\n |
Dopasuj nową linię |
Powyższy zestaw znaków może zostać użyty podczas dopasowywania wzorca.
Zobaczmy kilka przykładów.
Rozważmy sytuację, w której użytkownik wprowadza jakieś dane podczas wykonywania skryptu i chcemy sprawdzić, czy użytkownik wprowadził jakąś nazwę jako dane wejściowe, czy nie. Musimy napisać składnię wyrażenia regularnego, aby wyodrębnić Twoje imię i nazwisko i wydrukować je.
my $userinput="Guru99 Rocks"; if($userinput=~m/.*(Guru99).*/) { print "Found Pattern"; } else { print "unable to find the pattern"; }
Wyjście:
Znaleziono wzór
Tutaj zapisaliśmy wyrażenie regularne jako /.*(Guru99).*/.* dopasowuje wszystkie znaki w ciągu. A '.' w Perlu dopasowanie regularne odnosi się do dowolnego znaku, łącznie ze spacją.
Zobaczmy, jak dokładnie możemy skonstruować wyrażenie regularne.
Rozważmy przykład ciągu wielu słów i cyfr oraz symboli specjalnych, takich jak ten „Witam wszystkich, to jest mój numer: +91-99298373639”;
Regex : /^\w+\s\w+\s\w+\s\w+\s\w+\s\w+\:\+\d+\-\d+/i
spacja słowa spacja słowa spacja słowa spacja słowa spacja słowa spacja znak specjalny : spacja znak specjalny+cyfry znak specjalny –cyfry.
Mecz Perla Operatorsy
Operatory dopasowania służą do dopasowania ciągu znaków w obrębie pewnego polecenia lub zmiennej.
my $var="Hello this is perl"; if($var=~m/perl/) { print "true"; } else { print "False"; }
Wyjście:
prawdziwy
Ten mały kod wydrukuje 'true', ponieważ dopasowanie wzorca perl identyfikuje ciąg w zmiennej. Zasadniczo Perl przeszukuje tekst podany w // w całym ciągu, nawet jeśli znajdzie go w jednym miejscu, zwróci 'true'. Wzorzec może znajdować się w dowolnym miejscu zmiennej. Możemy spróbować zastąpić =~ przez !~, aby zobaczyć różnicę między tymi dwoma operatorami.
Substytucja Perla OperaTor
Tego operatora można używać do wyszukiwania i zastępowania dowolnego znaku znakiem null lub innym znakiem.
my $a="Hello how are you"; $a=~s/hello/cello/gi; print $a;
Wyjście:
wiolonczela, jak się masz
Uwaga: Możemy użyć dowolnego ciągu dopasowania wzorca, tak jak zrobiliśmy to wcześniej w tym operatorze podstawiania. Tutaj użyliśmy 'gi', g-globally, i-ignore case.
Tłumaczenie Perla OperaTor
Jest to podobne do Podstawiania, ale nie używa żadnych wyrażeń regularnych Perla, zamiast tego możemy bezpośrednio przekazać wartość lub słowo, które chcemy zastąpić.
my $a="Hello how are you"; $a=~tr/hello/cello/; print $a;
Wyjście:
Cześć, krowo, jesteś
We/wy pliku Perla
Perl został zaprojektowany do efektywnego manipulowania plikami i operacjami wejścia/wyjścia. Główną zaletą Perla jest parsowanie plików i obsługa plików. Istnieje wiele wbudowanych funkcji i operatorów używanych podczas obsługi plików w Perlu.
Zasadniczo operacje na plikach wykonywane za pomocą Perla są wykonywane przy użyciu FILEHANDLE. Musimy zdefiniować ten FILEHANDLE podczas otwierania pliku do odczytu lub zapisu.
W tym samouczku dotyczącym skryptu Perla dowiesz się:
Perl Otwórz plik
Plik możemy otworzyć korzystając z funkcji open() dostępnej w Perlu.
open(FILEHANDLE, "filename or complete path of the file");
Teraz otworzyliśmy plik i teraz pojawia się pytanie. Czy to do czytania czy do pisania?
Perl Odczyt pliku i Perl Zapis pliku
Perl ma pewne tryby, których należy użyć do odczytu, zapisu lub dołączenia pliku.
Read – open(my $fh,"<filename or complete path of the file"); Write – open(my $fh,">filename or complete path of the file"); Append – open(my $fh,">>filename or complete path of the file");
Kilka przykładów odczytu pliku:
Załóżmy, że mamy plik Perla o nazwie file.txt i zawiera on kilka linii tekstu. Musimy otworzyć ten plik i wydrukować go.
open(FH,"<file.txt"); while(<FH>) # Looping the file contents using the FH as a filehandle. { print "$_"; } close FH;
or
open(FH,"<file.txt"); my @content=<FH>; # specifying the input of the array is FH. foreach(@content) { print "$_"; } close FH;
Spowoduje to wydrukowanie zawartości pliku na ekranie wyjściowym.
Teraz napiszemy program do tworzenia i zapisywania danych do pliku Perla.
open(FH,">test.txt"); my $var=<>; print FH $var; close FH;
Spowoduje to zapisanie danych wejściowych dostarczonych w czasie wykonywania i utworzenie pliku test.txt, który będzie zawierał dane wejściowe.
Powyższy sposób zawsze będzie polegał na utworzeniu pliku o nazwie test.txt i zapisaniu danych wejściowych do pliku; napiszemy to samo, aby dołączyć plik.
open(FH,">>test.txt"); my $var=<>; print FH $var; close FH;
Tryby pracy | Opisy Konstrukcyjne |
---|---|
< |
Czytaj |
+< |
Czyta i pisze |
> |
Tworzy, pisze i obcina |
+> |
Czytaj, pisz, twórz i wycinaj |
>> |
Pisze, dołącza i tworzy |
+>> |
Czytaj, pisz, dołączaj i twórz |
Teraz musimy zobaczyć, jak czytać, zapisywać i dołączać pliki, korzystając z podstawowych przykładów.
Zobaczymy jeszcze kilka przykładów i innych funkcji, które pomogą lepiej zrozumieć pliki.
Perl Powiedz
Ta metoda zwróci bieżącą pozycję FILEHANDLER w bajtach, jeśli określono inaczej, za pozycję uzna ostatnią linię.
open(FH, "test.pl"); while(<FH>) { $a=tell FH; print "$a"; }
Poszukiwanie Perla
Funkcja wyszukiwania jest podobna do wywołania systemowego fseek. Ta metoda służy do umieszczania wskaźnika pliku w określonej lokalizacji poprzez określenie bajtów, po których następuje początek lub koniec wskaźnika pliku.
seek FH, bytes, WHENCE;
WHENCE to pozycja wskaźnika pliku, od którego należy rozpocząć. Zero ustawi to od początku pliku.
Przykład: Niech plik input.txt zawiera pewne dane, takie jak „Witam, to jest mój świat”.
open FH, '+<','input.txt'; seek FH, 5, 0; # This will start reading data after 5 bytes. $/ = undef; $out = <FH>; print $out; close FH;
Wyjście:
to jest mój świat
Odłączenie Perla
Odłączenie służy do usunięcia pliku.
unlink("filename or complete file path");
Obsługa katalogów:
Możemy także obsługiwać katalogi, poprzez które możemy obsługiwać wiele plików.
zobaczmy, jak otworzyć katalog. Możemy użyć metod opendir i readdir.
opendir(DIR,"C:\\Program Files\\"); #DIR is the directory handler. while(readdir(DIR)) # loop through the output of readdir to print the directory contents. { print "$_\n"; } closedir(DIR); #used to close the directory handler.
or
opendir(DIR,"C:\\Program Files\\"); @content=readdir(DIR); foreach(@content) { print "$_\n"; } closedir(DIR);
Spowoduje to wydrukowanie wszystkich dostępnych plików w tym katalogu.
Testy plików Perla i ich znaczenie
-r |
Aby sprawdzić, czy plik/katalog jest czytelny dla bieżącego użytkownika/grupy |
-w |
Aby sprawdzić, czy bieżący użytkownik/grupa może zapisać plik/katalog |
-x |
Aby sprawdzić, czy plik/katalog jest wykonywalny przez bieżącego użytkownika/grupę |
-o |
Aby sprawdzić, czy plik/katalog jest własnością bieżącego użytkownika |
-R |
Aby sprawdzić, czy plik/katalog jest czytelny dla tego rzeczywistego użytkownika/grupy |
-W |
Aby sprawdzić, czy plik/katalog może być zapisywany przez tego prawdziwego użytkownika/grupę |
-X |
Aby sprawdzić, czy plik/katalog jest wykonywalny przez tego prawdziwego użytkownika/grupę |
-O |
Aby sprawdzić, czy plik/katalog jest własnością tego prawdziwego użytkownika |
-e |
Aby sprawdzić, czy istnieje nazwa pliku/katalogu |
-z |
Aby sprawdzić, czy plik istnieje i ma zerowy rozmiar (zawsze false dla katalogów) |
-f |
Aby sprawdzić, czy Entry jest zwykłym plikiem |
-d |
Aby sprawdzić, czy Entry jest katalogiem |
-l |
Aby sprawdzić, czy Entry jest dowiązaniem symbolicznym |
-S |
Aby sprawdzić, czy Entry jest gniazdem |
-p |
Aby sprawdzić, czy Wejście jest nazwanym potokiem („FIFO”) |
-b |
Aby sprawdzić, czy wpis jest specjalnym plikiem blokowym (jak dysk do montażu) |
-c |
Aby sprawdzić, czy wpis jest specjalnym plikiem znakowym (jak urządzenie we/wy) |
-u |
Aby sprawdzić, czy plik lub katalog ma ustawioną wartość setuid |
-g |
Aby sprawdzić, czy plik lub katalog ma setgid |
-k |
Aby sprawdzić, czy plik lub katalog ma ustawiony bit sticky |
-t |
Podany uchwyt pliku to TTY (ponieważ w przypadku funkcji systemowej isatty() w tym teście nie można przetestować nazw plików) |
-T |
Aby sprawdzić, czy plik wygląda jak plik „tekstowy”. |
-B |
Aby sprawdzić, czy plik wygląda jak plik „binarny”. |
-M |
Aby sprawdzić wiek modyfikacji (mierzony w dniach) pliku |
-A |
Aby sprawdzić wiek dostępu (mierzony w dniach) do pliku |
-C |
Aby sprawdzić wiek modyfikacji i-węzła (mierzony w dniach) pliku |
Podprogram Perla
Co to jest podprogram?
Podprogramy są podobne do funkcji w innych językach programowania. Korzystaliśmy już z niektórych wbudowanych funkcji, takich jak print, chomp, chop itp. Możemy pisać własne podprogramy w Perlu. Podprogramy te można zapisać w dowolnym miejscu programu; lepiej jest umieścić podprogramy na początku lub na końcu kodu.
Przykład podprogramów
sub subroutine_name { Statements…; # this is how typical subroutines look like. }
Skoro już wiemy, jak napisać podprogram, jak uzyskać do niego dostęp?
Musimy uzyskać dostęp do podprogramu lub go wywołać, używając nazwy podprogramu poprzedzonej symbolem „&”.
sub display { print "this is a subroutine"; } display(); # This is how we call a subroutine
Przekazywanie parametrów i argumentów Perla
Podprogramy lub funkcja Perla są pisane w celu umieszczenia w nich kodu wielokrotnego użytku. Większość kodu wielokrotnego użytku wymaga przekazania parametrów do podprogramu. Tutaj dowiemy się, jak przekazywać argumenty do podprogramu.
sub display { my $var=@_; # @_ is a special variable which stores the list of arguments passed. print "$var is the value passed"; } display(2,3,4); #this is how we need to pass the arguments.
Wyjście:
3 to przekazana wartość
@_ to specjalna zmienna tablicowa, w której przechowywane są argumenty przekazane do podprogramów.
Perl Shift
Możemy również użyć słowa kluczowego „shift”, które przesuwa jeden parametr na raz do zmiennej lub $_[0],$_[1]…, która jest pojedynczym elementem tablicy @_
sub display { my $var=shift; print "$var is passed"; } display("hello");
Wyjście:
cześć, minęło
Podprogramy są zwykle używane w programowaniu obiektowym, a także w miejscach, w których można umieścić więcej kodu wielokrotnego użytku.
Główną funkcjonalnością podprogramów jest wykonanie jakiegoś zadania i zwrócenie wyniku kodu wielokrotnego użytku.
Możemy zwrócić wartość z podprogramu za pomocą słowa kluczowego return.
sub add { my $a=shift; my $b=shift; return($a+$b); } my $result=add(5,6); print $result;
Wyjście:
11
$result będzie zawierał wartość dodanych $a i $b.
Możemy także przekazać skróty i tablicę bezpośrednio do podprogramu.
sub hash { my %hash=@_; print %hash; } %value= ( 1=>'a', 2=>'b'); &hash(%value);
Wyjście:
1a2b
Możemy również zwrócić hash lub tablicę.
sub hashArray { my %hash=@_; print "Inside Sub-routine"; print %hash; return(%hash); } %hash=(1=>'a', 2=>'b'); my(@ret)=hashArray(%hash); print "After Sub-routine call"; print @ret;
Wyjście:
Wewnątrz podprogramu 2b1a Po wywołaniu podprogramu 2b1a
Format Perla
Perl ma mechanizm, za pomocą którego możemy generować raporty. Używając tej funkcji, możemy tworzyć raporty dokładnie tak, jak chcemy, podczas drukowania na ekranie wyjściowym lub w pliku. Prosty format można zapisać za pomocą funkcji printf lub sprintf dostępnych w Perlu.
printf "%05d\n", 30;
Spowoduje to dodanie zer na początku liczby 30, co spowoduje, że łączna liczba cyfr wyniesie 5. Tę samą zasadę można zastosować w przypadku funkcji sprintf.
sprintf "%05d\n", 30; # This will print the same as printf.
Używając printf i sprintf, możemy uzyskać większość formatów Perla. W przypadku raportów będzie to trudne do zaimplementowania.
================================================== =========================
Imię Adres Wiek Telefon
================================================== =========================
Krishna Chennai 24 929309242
Shruthi Chennai 24 929309232
Powyżej znajduje się przykład raportów, które musimy wydrukować w ten sam sposób w Perlu. Można to osiągnąć, używając perl printf i perl sprintf. Można to skutecznie zaimplementować, używając format.
Format można zadeklarować w poniższy sposób.
format FORMATNAME=FORMATLIST.
Tutaj użyjemy określonej metody zapisu, aby wydrukować dane na ekranie wyjściowym lub w pliku.
symbol | Opisy Konstrukcyjne |
---|---|
@ |
Używany do reprezentowania początku posiadacza pola |
> |
Prawidłowe wyrównanie tekstu |
< |
Wyrównanie tekstu do lewej |
| |
Wyśrodkowanie |
# |
Numeryczne, jeśli podano wiele #. Przyjmuje się jako komentarz, jeśli podano pojedynczy # |
. |
Kropka dziesiętna |
^ |
Początek uchwytu pola może być również użyty do multilinii, a także do zawijania słów |
~ |
Linia powinna być pusta, jeśli zmienna jest pusta |
@* |
Wiele linii. |
($name,$addr,$age,$phone)=("krishna","chennai","24","929309242"); write; ($name,$addr,$age,$phone)=("shruthi","chennai","24","929309232"); write; format STDOUT_TOP= =============================================================== NAME ADDRESS AGE PHONE =============================================================== . format STDOUT= @<<<<<<<<<<<<< @<<<<<<<<<<<<<<<<<<<<< @<<< @<<<<<<<<<< $name, $addr, $age, $phone .
Wykonaj kod, aby zobaczyć wynik.
Używamy symbolu @, aby określić początek posiadacza pola lub ciągu znaków, „<” każdego znaku.
Używamy STDOUT do drukowania na standardowym wyjściu. Możemy to zmienić na obsługę plików, której używamy do zapisywania danych do pliku.
open(REPORT,">test.txt"); ($name,$addr,$age,$phone)=("krishna","chennai","24","929309232"); write REPORT; ($name,$addr,$age,$phone)=("shruthi","chennai","24","929309232"); write REPORT; format REPORT_TOP= =============================================================== NAME ADDRESS AGE PHONE =============================================================== . format REPORT= @<<<<<<<<<<<<< @<<<<<<<<<<<<<<<<<<<<< @<<< @<<<<<<<<<< $name, $addr, $age, $phone
Możemy zamienić „<” na „>” lub „|” aby zmienić wyrównanie tekstu. STDOUT_TOP służy do projektowania nagłówka formatu. Możemy również użyć tego samego z procedurą obsługi plików za pomocą FH_TOP (FH jest procedurą obsługi pliku). Spowoduje to przesłanie formatu do pliku, nad którym pracujemy NA.
Standardy kodowania Perla
Każdy programista będzie miał własne poczucie pisania kodu przy użyciu określonych standardów; standardy te powinny być na tyle znane, aby inny programista mógł zrozumieć i właściwie obsługiwać kod.
Standardy kodowania w Perlu
Pisanie kodu jest proste i łatwe. Problem pojawia się, gdy trzeba go utrzymać na późniejszych etapach. Podczas pisania kodu należy przestrzegać właściwych wytycznych i standardów kodowania. Perl definiuje również pewne standardy, które będą przydatne dla programistów podczas pisania kodu. Zaleca się ładowanie modułów „strict” i „warnings module” podczas pisania kodu. Każdy z tych modułów ma swoje własne znaczenie. Strict sprawi, że zadeklarujemy zmienną przed użyciem, a także poinformuje, czy w kodzie występuje jakieś puste słowo. Modułu ostrzeżeń można alternatywnie użyć, przekazując opcję „-w” do interpretera Perla w Shebangu. Ostrzeżenia zostaną wyświetlone na ekranie wyjściowym.
#!/usr/bin/perl –w
Poniżej znajduje się kilka list standardów.
- Użyj modułu „ścisłe” i „ostrzeżenia”.
- Usuń zmienną, która nie jest używana.
- Nazwy zmiennych powinny być zrozumiałe dla innych użytkowników. Np.: $name, @fileData itp.
- Podczas kodowania skryptu wymagana jest dokumentacja.
- Nie koduj na stałe żadnych wartości, raczej spróbuj pobrać je dynamicznie lub poproś użytkownika o wprowadzenie w czasie wykonywania. (Ścieżka pliku, Nazwy plików).
- Maksymalizuj ponowne wykorzystanie kodu. Spróbuj umieścić kod wielokrotnego użytku w podprogramach.
- Oznacza to, że podprogramom należy podawać pełne nazwy.
- Podprogramy muszą być napisane z odpowiednimi komentarzami i dokumentacją.
- Zawsze inicjuj zmienne.
- Zawsze sprawdzaj kody powrotu wywołań systemowych. Otwarcie pliku może nastąpić lub nie, kod powrotu wyświetli status błędu, jeśli plik nie istnieje.
Np.: otwarty (FH,
- Podprogram powinien zawsze zwracać wartość.
- Otwórz kręcone w tej samej linii.
- Pojedynczą linię BLOK można umieścić w jednej linii z kręconymi.
- Używaj etykiet podczas PĘTLI, łatwo będzie wyjść z pętli, gdy zajdzie taka potrzeba.
- Użyj podkreślenia, gdy długie frazy słowne są zapisywane jako nazwa zmiennej lub podprogram.
- Spróbuj użyć prostego wyrażenia regularnego podczas kodowania.
Doskonały przykład ze standardami kodowania:
####################################################################### Program to read the file content # Date: 22-2-2013 # Author : Guru99 ######################################################################## #!/usr/bin/perl use strict; use warnings; my $line; open FR, "file.txt" || die("Cannot open the file $!"); while ($line=<FR>) { print $line; } # Looping file handler to print data
Obsługa błędów Perla
Co to jest wyjątek?
Wyjątek to zdarzenie, które ma miejsce podczas wykonywania programu i powoduje zawieszenie lub zakończenie programu.
Obsługa błędów
Obsługa błędów to taka, o którą każdy programista musi zadbać podczas programowania. Perl udostępnia także techniki obsługi błędów, dzięki którym możemy przechwycić błąd i odpowiednio sobie z nim poradzić.
Obsługa błędów w Perlu
Istnieje wiele sposobów sprawdzania błędów w programie. Musimy sprawdzić kody powrotu funkcji, której używamy. Jeśli potrafimy poprawnie obsłużyć te kody powrotu, większość błędów można obsłużyć.
Co zwróci w przypadku wywołań systemowych?
W przypadku wywołań systemowych status powrotu zostanie zapisany w dwóch specjalnych zmiennych $? I $!
$! – Spowoduje to przechwycenie numeru błędu lub numeru błędu powiązanego z komunikatem o błędzie.
$? – Spowoduje to zatrzymanie funkcji system() statusu powrotu.
Używanie operatora Perl lub operatora logicznego
Podczas korzystania z wywołań systemowych do obsługi błędów można używać operatorów logicznych lub operatorów.
ex:
open(FH,"<test.txt");
Spowoduje to otwarcie pliku w trybie odczytu, jeśli plik istnieje.
Co się stanie, jeśli brakuje pliku?
open(FH,"<test.txt") or die("File not exists $!"); # This will perl exit the program if the file not exists. open(FH,"<test.txt") or warn ("File not exists $!"); # This will print a warning message on STDERR
Perla Ewa
Funkcja Eval radzi sobie z błędami krytycznymi, błędami czasu kompilacji, błędami wykonania i tymi błędami, które w pewnym momencie kończą kod.
Funkcja Perl Eval może mieć blok kodu lub wyrażenie. Evals uważa wszystko, co jest w nim umieszczone, za ciąg znaków.
Rozważmy sytuację wywołania podprogramu, który nie jest zdefiniowany w skrypcie. W tej sytuacji skrypt kończy się stwierdzeniem „niezdefiniowany podprogram &XYZ, błąd ten można obsłużyć w funkcji eval.
Blok evals ma wiele zastosowań; jednym z nich jest potrzeba załadowania modułu specyficznego dla systemu operacyjnego w czasie wykonywania.
Przykład: dzielenie przez zero powoduje błąd krytyczny; aby sobie z tym poradzić, możemy umieścić kod w bloku evals.
$a=5; $b=0; eval { '$result=$a/$b'; } if($@) { print "$@"; # All the error codes returned by evals will get stored in $@. }
Wyjście:
błąd składniowy w C:\Users\XYZ\Text.pl linia 8, obok „)
{“
Wykonywanie C:\Users\XYZ\Text.pl zostało przerwane z powodu błędów kompilacji.
Przykład: eval przy użyciu instrukcji die w Perlu.
sub test { die "Dieing in sub test \n"; } eval { test(); }; print "Caught : $@\n";
Wyjście:
Złapany: Śmierć w podteście
Korzystanie z Perla Spróbuj
Perl nie obsługuje bloków try, catch i wreszcie kodu, tak jak inne języki programowania. Nadal możemy z nich korzystać, ładując zewnętrzny moduł Perla.
użyj Try::Tiny;
Dzięki temu możemy umieścić Twój kod w bloku try i wychwycić błąd w bloku ostrzegawczym.
Zamiast $@ użytego w eval Try::Tiny używa $_.
# obsłuż błędy za pomocą modułu obsługi catch
try { die "Die now"; } catch { warn "caught error: $_"; # not $@ };
Wreszcie używam.
my $y; try { die 'foo' } finally { $y = 'bar' }; try { die 'Die now' } catch { warn "Returned from die: $_" } finally { $y = 'gone' };
Wyjście:
foo w C:\Users\XYZ\Text.pl linia 4.
W ten sposób możemy użyć try, catch i wreszcie.
spróbuj { # instrukcja }
złapać {# instrukcja }
w końcu { # instrukcja };
Or
try { # statement } finally { # statement };
Wyjście:
Or
try { # statement } finally { # statement } catch { # statement };
Wyjście:
Programowanie za pomocą gniazd Perl
Co to jest gniazdo?
Gniazdo to medium, za pośrednictwem którego dwa komputery mogą współdziałać w sieci przy użyciu adresu sieciowego i portów.
Załóżmy, że A (serwer) i B (klient) to dwa systemy, które muszą współdziałać ze sobą za pomocą gniazd w celu uruchomienia niektórych programów.
Aby to zaimplementować, musimy utworzyć gniazda zarówno w A (serwerze), jak i B (kliencie), A będzie w stanie odbierającym, a B będzie w stanie wysyłającym.
Serwer):
Tutaj serwer chce otrzymać połączenie od B (Klienta) i wykonać pewne zadania, a następnie odesłać wynik do B (Klienta). Gdy wykonujemy kod, system operacyjny w A próbuje utworzyć gniazdo i wiąże jeden port z tym gniazdem. Następnie będzie nasłuchiwał od nadawcy, którym jest B.
B. (Klient).
Tutaj klient chce wysłać jakiś program ze swojego systemu do A (Serwera) w celu przetworzenia. Kiedy wykonujemy kod, system operacyjny w B próbuje utworzyć gniazdo do komunikacji z A (Serwerem), B musi określić adres IP i numer portu A, do którego B chce się połączyć.
Jeśli wszystko pójdzie dobrze, oba systemy będą współdziałać w celu wymiany informacji przez jeden port. Perl obsługuje także programowanie za pomocą gniazd.
Perl ma natywny interfejs API, za pomocą którego można implementować gniazda. Aby to ułatwić, istnieje wiele modułów CPAN, za pomocą których piszemy programy gniazdowe.
Operacje serwerowe:
- Utwórz gniazdo
- Powiąż gniazdo z adresem i portem
- Nasłuchuj gniazda na tym adresie portu
- Zaakceptuj połączenia klienta, który próbuje połączyć się przy użyciu portu i adresu IP serwera
- Wykonaj operacje
klientem Operacje:
- Utwórz gniazdo
- Połącz się z serwerem, używając jego adresu portu
- Wykonaj operacje
Gniazdo.io
Jest to jeden moduł do programowania gniazd, który opiera się na programowaniu obiektowym. Moduł ten nie obsługuje typu sieci INET stosowanego w sieciach.
I/O::Socket::INET:
Moduł ten obsługuje domenę INET i jest zbudowany na IO::Sockets. Wszystkie metody dostępne w IO::Sockets są dziedziczone w module INET.
Klient i serwer korzystający z protokołu TCP:
TCP jest protokołem zorientowanym na połączenie; będziemy używać tego protokołu do programowania gniazd.
Zanim przejdziemy dalej, zobaczmy jak możemy utworzyć obiekt dla modułu IO::Socket::INET i utworzyć gniazdo.
$socket = IO::Socket::INET->new(PeerPort => 45787, PeerAddr => inet_ntoa(INADDR_BROADCAST), Proto => udp,LocalAddr => 'localhost',Broadcast => 1 ) or die "Can't create socket and bind it : $@n";
Nowa metoda w module IO::Socket::INET akceptuje hash jako parametr wejściowy podprogramu. Ten skrót jest predefiniowany i musimy jedynie podać wartości kluczom, których chcemy użyć. Istnieje lista kluczy używanych przez ten skrót.
Adres równorzędny |
Adres hosta zdalnego |
Host równorzędny |
Synonim adresu równorzędnego |
Port równorzędny |
Zdalny port lub usługa |
Adres lokalny |
Adres powiązania hosta lokalnego |
localhost |
Synonim adresu lokalnego |
Port lokalny |
Port powiązania hosta lokalnego |
Proto |
Nazwa protokołu (lub numer) |
Typ |
Typ gniazda |
Słuchaj |
Rozmiar kolejki do odsłuchania |
Użyj ponownie adresu |
Ustaw SO_REUSEADDR przed powiązaniem |
Ponowne użycie |
Ustaw SO_REUSEADDR przed powiązaniem |
Użyj ponownie portu |
Ustaw SO_REUSEPORT przed powiązaniem |
Nadawanie |
Ustaw SO_BROADCAST przed powiązaniem |
Timeout |
Wartość limitu czasu dla różnych operacji |
Wielodomowy |
Wypróbuj wszystkie adresy dla hostów wieloadresowych |
Blokowanie |
Określ, czy połączenie będzie w trybie blokowania |
Serwer.pl
use IO::Socket; use strict; use warnings; my $socket = new IO::Socket::INET ( LocalHost => 'localhost', LocalPort => '45655', Proto => 'tcp', Listen => 1, Reuse => 1, ); die "Could not create socket: $!n" unless $socket; print "Waiting for the client to send datan"; my $new_socket = $socket->accept(); while(<$new_socket>) { print $_; } close($socket);
Klient.pl
use strict; use warnings; use IO::Socket; my $socket = new IO::Socket::INET ( PeerAddr => 'localhost', PeerPort => '45655', Proto => 'tcp', ); die "Could not create socket: $!n" unless $socket; print $socket "Hello this is socket connection!n"; close($socket);
Uwaga:
W programowaniu gniazd będziemy musieli najpierw uruchomić Server.pl, a następnie Client.pl indywidualnie w różnych wierszach poleceń, jeśli działamy na hoście lokalnym.
Co to są moduły i pakiety Perla
Moduły i Pakiety są ze sobą ściśle powiązane i niezależne. Pakiet: Pakiet Perla jest również nazywany przestrzenią nazw i zawiera wszystkie używane unikalne zmienne, takie jak skróty, tablice, skalary i podprogramy. Moduł: Moduł to zbiór kodu wielokrotnego użytku, w którym piszemy podprogramy. Moduły te można załadować do programów w języku Perl, aby wykorzystać podprogramy zapisane w tych modułach.
Czym są moduły Perla?
Standardowe moduły zostaną zainstalowane podczas instalacji Perla w dowolnym systemie. CPAN: Kompleksowy Perl Archive Network – globalne repozytorium modułów Perla. Nasze własne, dostosowane moduły Perla, które mogą być napisane przez nas. Zasadniczo moduł załadowany do dowolnego skryptu wyeksportuje wszystkie swoje zmienne globalne i podprogramy. Podprogramy te można bezpośrednio wywoływać tak, jakby były zadeklarowane w samym skrypcie. Moduły Perla można pisać z rozszerzeniem .pm do nazwy pliku Ex: Foo.pm. Moduł można napisać, używając na początku programu polecenia „pakiet Foo”.
Podstawowy moduł Perla:
#!/usr/bin/perl package Arithmetic; sub add { my $a=$_[0]; my $b=$_[1]; return ($a+$b); } sub subtract { my $a=$_[0]; my $b=$_[1]; return ($a-$b); } 1;
Brak wyjścia
Aby skorzystać z tego modułu Perla, musimy umieścić go w aktualnie działającym katalogu.
Możemy załadować moduł Perla za pomocą require lub use w dowolnym miejscu kodu. Główną różnicą między wymaganiem a użyciem jest wymaganie załadowanego modułu w czasie wykonywania i używanie ładowań w czasie kompilacji.
#!/usr/bin/perl require Arithmetic; print Arithmetic::add(5,6); print Arithmetic:: subtract (5,6);
Tutaj, w powyższym przykładzie, dostęp do podprogramów uzyskujemy przy użyciu pełnej nazwy modułu.
Dostęp do pakietu możemy również uzyskać za pomocą „użyj arytmetyki”.
Eksporter:
Moduł ten posiada domyślną funkcjonalność importowania metod.
#!/usr/bin/perl package Arithmetic; require Exporter; @ISA= qw(Exporter); # This is basically for implementing inheritance. @EXPORT = qw(add); @EXPORT_OK = qw(subtract); sub add { my $a=$_[0]; my $b=$_[1]; return ($a+$b); } sub subtract { my $a=$_[0]; my $b=$_[1]; return ($a-$b); } 1;
Tablicy @EXPORT można użyć do przekazania listy zmiennych i podprogramów, które domyślnie zostaną wyeksportowane do wywołującego moduł.
Tablicę @EXPORT_OK można wykorzystać do przekazania listy zmiennych i podprogramów, które będą eksportowane na żądanie, co użytkownik musi określić podczas ładowania modułu.
#!/usr/bin/perl use Arithmetic qw(subtract); print add(5,6); print subtract (5,6);
Domyślnie eksport podprogramu dodawania zostanie wyeksportowany. Metoda Subtract nie zostanie wyeksportowana, jeśli nie zostanie określona podczas ładowania modułu.
Programowanie obiektowe w Perlu
W tej sekcji dowiemy się, jak tworzyć moduły obiektowe w Perlu. Najpierw zobaczmy, co to jest za obiekt? Obiekt to instancja, za pomocą której możemy uzyskać dostęp, modyfikować i lokalizować pewne dane w dowolnym module Perla. To nic innego jak sprawienie, że istniejący pakiet Perla, zmienne i podprogramy będą działać jak klasy, obiekty i metody w odniesieniu do innych języków programowania.
Utwórz klasę
Wiemy już jak stworzyć moduły z poprzedniego tematu. Celem klasy jest przechowywanie metod i zmiennych. Moduł Perla będzie miał podprogramy, które są metodami. Musimy uzyskać dostęp do tych zmiennych i obiektów podprogramów.
Konstruktor Perla
Konstruktor w Perlu to metoda, która wykona i zwróci nam referencję z nazwą modułu otagowaną do referencji. Nazywa się to błogosławieństwem klasy. Używamy określonej zmiennej do błogosławienia klasy Perla, którą jest błogosławieństwo.
#!/usr/bin/perl package Arithmetic; sub new { my $class=shift; my $self={}; bless $self, $class; return $self; } sub add { my $self= shift; my $a=$_[0]; my $b=$_[1]; return ($a+$b); } sub subtract { my $self= shift; my $a=$_[0]; my $b=$_[1]; return ($a-$b); } 1;
Nowa metoda używana jako konstruktor klasy. Konstruktor ten utworzy dla nas obiekt i powróci do skryptu wywołującego ten konstruktor.
#!/usr/bin/perl use Arithmetic; my $obj= Arithmetic->new(); my $result= $obj->add(5,6); print "$result"; $result = $obj->subtract(6,5); print "$result";
Tutaj musimy zrozumieć, w jaki sposób obiekt został stworzony. Ilekroć próbujemy utworzyć obiekt dla klasy, musimy użyć pełnej nazwy klasy. Załóżmy, że klasa Perla znajduje się w jakimś pliku lib\Math\Arithmetic.pm. A jeśli chcemy uzyskać dostęp do tej klasy Perla z katalogu lib, musimy podać całą ścieżkę do klasy podczas wywoływania skryptu.
użyj lib::Math::Arithmetic;
my $obj = lib::Math::Arithmetic->new();
W ten sposób odbywa się tworzenie obiektów w Perlu.
@INC:
Skąd skrypt Perla wie, gdzie istnieje moduł biblioteki? Perl zna jedynie bieżący katalog skryptu i ścieżkę biblioteki wbudowanej w Perl. Ilekroć używamy modułu Perla, który nie znajduje się w bieżącym katalogu lub ścieżce biblioteki Perla, skrypt zawsze zakończy się niepowodzeniem. W przypadku @INC jest to tablica przechowująca wszystkie ścieżki katalogów, w których musi szukać modułów Perla. Spróbuj wykonać to polecenie i zobacz, jaki będzie wynik.
perl –e "print @INC"
To da pewne dane wyjściowe i jest to ścieżka, w której będą dostępne moduły lib. Ilekroć używamy nowego modułu biblioteki, musimy powiedzieć Perlowi, interpreterowi, aby sprawdził to konkretne miejsce, w którym dostępny jest moduł Perla.
push(@INC, "PATH TO YOUR MODULE");
Zrób to jako pierwszą linię kodu. To powie twojemu tłumaczowi, aby spojrzał na tę ścieżkę. Lub posługiwać się
lib Arithmetic; # List here is your Perl Module location
Destruktor Perla
Destruktor obiektu jest domyślnie wywoływany na końcu i przed zakończeniem skryptu. Służy do niszczenia obiektów z pamięci.
Skrypty powłoki PERL V/s
- Programowanie w Perlu nie powoduje problemów z przenośnością, co jest częste w przypadku używania różnych powłok w skryptach powłoki.
- Obsługa błędów jest w Perlu bardzo łatwa
- Możesz łatwo pisać długie i złożone programy w Perlu ze względu na jego rozległość. Jest to w przeciwieństwie do Shell, który nie obsługuje przestrzeni nazw, modułów, obiektów, dziedziczenia itp.
- Shell ma mniej dostępnych bibliotek wielokrotnego użytku. Nic w porównaniu z CPAN Perla
- Shell jest mniej bezpieczny. Wywołuje funkcje zewnętrzne (polecenia takie jak mv, cp itp. zależą od używanej powłoki). Wręcz przeciwnie, Perl wykonuje pożyteczną pracę, korzystając z funkcji wewnętrznych.
Jak PERL jest wykorzystywany w testowaniu automatycznym
Perl jest szeroko stosowany w automatyce. Może nie jest to najlepszy język programowania na świecie, ale najlepiej nadaje się do niektórych typów zadań. Porozmawiajmy, gdzie i dlaczego Perl jest używany Testowanie automatyczne.
Testowanie pamięci
Co to jest przechowywanie? Dane przechowywane w plikach.
Załóżmy, że mamy powiązany magazyn Przypadek testowy gdzie musimy zapisać dane na jednej partycji, przeczytaj je i sprawdź, czy dane są zapisane poprawnie.
Można to zrobić ręcznie, ale czy tester ręczny może wykonać to samo 10000 razy? To będzie koszmar! Potrzebujemy automatyzacji
Najlepszym narzędziem do automatyzacji wszystkiego, co jest związane z przechowywaniem, jest Perl ze względu na techniki obsługi plików, REGEX i wydajne analizowanie plików, które zajmuje najmniej czasu wykonania w porównaniu do innych języków programowania.
Dlaczego musimy przetestować pamięć masową? Pomyśl o dużych centrach danych, w których dane będą stale przepływać z jednego systemu do drugiego, a tysiące rekordów będzie przechowywanych na sekundę. Testowanie wytrzymałości takiego mechanizmu przechowywania jest niezbędne.
Wiele firm, takich jak HP, Dell, IBM a wielu producentów serwerów używa Perla jako interfejsu do testowania funkcjonalności w domenach pamięci masowej i sieci. NetApp jest jedną z takich firm, która całkowicie pracuje nad pamięcią masową i używa języka Perl jako języka programowania do automatyzacji przypadków testowych.
Jeśli interesuje Cię automatyzacja Perla, wskazane byłoby zapoznanie się z magazynowaniem i siecią Concepts.
Testowanie serwerów i sieci:
Testowanie serwerów i sieci przy użyciu języka Perl
PERL jest szeroko stosowany w monitorowaniu czasu pracy i wydajności serwerów.
Rozważmy centrum danych, które ma 100 hostów (serwerów). Musisz połączyć się z każdym hostem i zdalnie wykonać niektóre polecenia. Chcesz także ponownie uruchomić system i sprawdzić, kiedy wróci do trybu online.
Ręczne wykonanie tego zadania dla wszystkich 100 hostów będzie koszmarem. Ale możemy to łatwo zautomatyzować za pomocą Perla
Zaprojektuj kroki, aby osiągnąć powyższą automatyzację przy użyciu języka PERL
- Pobierz dane wejściowe z pliku dotyczące informacji o hoście, takich jak (adres IP, nazwa użytkownika i hasło).
- Użyj Net::SSH2, aby połączyć się z każdym systemem i ustanowić kanał do wykonywania poleceń.
- Wykonaj zestaw wymaganych poleceń, np.: ls, dir, ifconfig, ps itp.
- Zrestartuj system.
- Poczekaj 10 minut, aż system się uruchomi.
- Pinguj system za pomocą modułu Net::Ping i wydrukuj status.
Zakodujemy powyższy scenariusz.
Weźmy plik o nazwie Wejście.txt, który będzie przechowywać pełne informacje o wszystkich hostach, z którymi musimy się połączyć i wykonać polecenie.
Wejście.txt
Hasło roota 192.168.1.2
Hasło roota 192.168.1.3
192.168.1.4 root root123
HostCheck.pl
use Net::SSH2; use Net::Ping; use strict; use warnings; my $ping = Net::Ping->new(); # Creating object for Net::Ping my $SSHObj = Net::SSH2->new(); #Creating object for Net::SSH2 open( FH, "Input.txt" ); # Opening file and placing content to FH my @hosts = <FH>; my $ip; my @ips; foreach (@hosts) { if ( $_ =~ /(.*)\s+(\w+)\s+(.*)/ ) #Regex to get each info from file { $ip = $1; my $user = $2; my $password = $3; $SSHObj->connect($ip); print "Connecting to host -- $ip --Uname:$user --Password:$password\n"; my $status = $SSHObj->auth_password( $user, $password ); print "$status\n"; die("unable to establish connection to -- $ip") unless ($status); my $shell = $SSHObj->channel(); print "$_\n" while <$shell>; $shell->blocking(1); $shell->pty('tty'); $shell->shell(); sleep(5); #Executing the list of command on particular host. Can be any command print $shell "ls \n"; print "$_\n" while <$shell>; print $shell "ps \n"; print "$_\n" while <$shell>; print $shell "dir \n"; print "$_\n" while <$shell>; print $shell "init 6\n"; #rebooting the system push( @ips, $ip ); } } sleep 600; foreach (@ips) { if ( $ping->ping($_) ) { print "$_ is alive.\n" if $ping->ping($_); } else { print "$_ is not still up --waiting for it to come up\n"; } }
Testowanie sieci
Perl nie ogranicza się tylko do testowania pamięci masowej i sieci. Możemy również przeprowadzać testy internetowe przy użyciu języka PERL. WWW-Mechanizacja to jeden moduł używany do testowanie sieci. Zasadniczo nie uruchamia żadnej przeglądarki w celu przetestowania funkcjonalności aplikacji internetowych, raczej korzysta z kodu źródłowego stron HTML.
Możemy również przeprowadzić testy w oparciu o przeglądarkę za pomocą Selenium IDE, RC, sterownik sieciowy. Perl jest obsługiwany Selenium.
\N"; #this przechowuje pozostały ciąg po zakończeniu dopasowania wzorca.
wydrukuj „