Perl dla każdego (ebook)(audiobook)(audiobook)

Spis treści

Wprowadzenie (25)


• Kompozycja książki (26)
• Konwencje przyjęte w książce (28)

Część I. Pierwsze kroki (29)


Rozdział 1. Wprowadzenie do języka Perl (31)


• Krótka charakterystyka języka Perl (31)
• Dlaczego warto uczyć się Perla? (33)
• Perl jest użyteczny (33)
• Perl jest samowystarczalny (34)
• Programowanie w Perlu przebiega bardzo szybko (34)
• Perl jest przenośny (35)
• Perl posiada duże możliwości (35)
• Perl jest elastyczny (35)
• Perl jest łatwy do nauczenia się (36)
• Społeczność użytkowników Perla (36)
• Pierwsze kroki w Perlu (37)
• Przykład: wszechobecny program Hello World (37)
• Tworzenie skryptu Hello World (38)
• Uruchamianie skryptu Hello World (39)
• Co zrobić, jeżeli nie działa? (40)
• Jak to działa? (40)
• Słowo na temat ostrzeżeń (41)
• Kolejny przykład: Echo (42)
• Trzeci przykład: Cookie Monster (43)
• Wkraczamy w głąb (44)
• Podsumowanie (45)
• Pytania i odpowiedzi (45)
• Warsztat (48)
• Quiz (48)
• Ćwiczenia (48)
• Odpowiedzi (49)
• Odpowiedzi do quizu (49)
• Odpowiedzi do ćwiczeń (50)

Rozdział 2. Łańcuchy i liczby (53)


• Dane skalarne i zmienne skalarne (53)
• Liczby (54)
• Łańcuchy (54)
• Konwersja między liczbami i łańcuchami (57)
• Zmienne skalarne (58)
• Konstruowanie skryptów Perla (59)
• Operacje arytmetyczne (60)
• Precyzja arytmetyczna i dziesiętna (61)
• Przykład: Konwersja stopni Fahrenheita na stopnie Celsjusza (62)
• Operatory testów i porównań (64)
• Czym jest prawda? (64)
• Operatory równości i związków (64)
• Operatory logiczne (66)
• Wkraczamy w głąb (68)
• Znaki ograniczające łańcuch (68)
• Znaki sterujące wpływające na wielkość znaków (69)
• Interpolacja zmiennych w łańcuchach (69)
• Podsumowanie (70)
• Pytania i odpowiedzi (71)
• Warsztat (72)
• Quiz (72)
• Ćwiczenia (72)
• Odpowiedzi (73)
• Odpowiedzi do quizu (73)
• Odpowiedzi do ćwiczeń (74)

Rozdział 3. Więcej danych skalarnych i operatorów (75)


• Operatory przypisania (75)
• Operatory inkrementacji i dekrementacji (76)
• Łączenie i powtarzanie łańcuchów (77)
• Priorytety i kolejność jednoczenia operatorów (78)
• Przykład: Prosta statystyka (80)
• Wejście i wyjście (82)
• Uchwyty plików oraz standardowe wejście i wyjście (82)
• Czytanie wiersza danych ze standardowego wejścia przy pomocy (83)
• Pisanie do standardowego wyjścia przy użyciu funkcji print (84)
• printf i sprintf (85)
• Słowo o korzystaniu z funkcji (87)
• Wkraczamy w głąb (87)
• Użyteczne funkcje (88)
• Operatory bitowe (89)
• Operatory cmp i <=> (89)
• Funkcje i operatory o charakterze funkcji (89)
• Podsumowanie (89)
• Pytania i odpowiedzi (90)
• Warsztat (91)
• Quiz (91)
• Ćwiczenia (91)
• Odpowiedzi (92)
• Odpowiedzi do quizu (92)
• Odpowiedzi do ćwiczeń (92)

Rozdział 4. Listy i tablice (95)


• Dane i zmienne listowe (95)
• Definiowanie i użytkowanie tablic oraz list (96)
• Tworzenie list (97)
• Tworzenie list z użyciem operatora zakresu (98)
• Przypisania i listy (98)
• Dostęp do elementów tablicy (100)
• Rozszerzanie tablic (100)
• Określanie końca tablicy (101)
• Określanie rozmiaru tablicy (102)
• Sortowanie list i tablic (102)
• Przetwarzanie kolejnych elementów tablicy (103)
• Przykład: Jeszcze raz statystyka (103)
• Kontekst listowy i skalarny (106)
• Czym jest kontekst? (106)
• Określanie rozmiaru tablicy - rewizja (107)
• Kontekst i przypisanie (108)
• Inne przypadki znaczenia kontekstu (109)
• Funkcja scalar (110)
• Wejście, wyjście i listy (111)
• Wykorzystanie w kontekście listowym (111)
• Wyświetlanie list (111)
• Wkraczamy w głąb (112)
• Negatywne indeksy tablicy (113)
• Jeszcze raz o operatorze zakresu (113)
• Funkcje chomp i chop w odniesieniu do list (113)
• Wyjściowe pole i rekord oraz separatory list (113)
• Kontekst pusty (114)
• Podsumowanie (115)
• Pytania i odpowiedzi (116)
• Warsztat (117)
• Quiz (117)
• Ćwiczenia (117)
• Odpowiedzi (118)
• Odpowiedzi do quizu (118)
• Odpowiedzi do ćwiczeń (119)

Rozdział 5. Tablice rozproszone (121)


• Tablice rozproszone kontra tablice i listy (121)
• Tablice rozproszone (122)
• Składnia list i tablice rozproszone (123)
• Konwersja pomiędzy listami, tablicami zwykłymi i rozproszonymi (124)
• Dostęp do elementów tablicy rozproszonej (124)
• Usuwanie elementów z tablicy rozproszonej (125)
• Przetwarzanie wszystkich wartości tablicy rozproszonej (126)
• Tablice rozproszone i kontekst (126)
• Przykład: Częstość w programie statystycznym (128)
• Podział danych przy użyciu funkcji split (131)
• Kolejny przykład: alfabetyczna lista nazwisk (132)
• Wkraczamy w głąb (133)
• Podsumowanie (134)
• Pytania i odpowiedzi (135)
• Warsztat (135)
• Quiz (135)
• Ćwiczenia (136)
• Odpowiedzi (136)
• Odpowiedzi do quizu (136)
• Odpowiedzi do ćwiczeń (137)

Rozdział 6. Wyrażenia warunkowe i pętle (139)


• Wyrażenia złożone i bloki programu (139)
• Wyrażenia warunkowe (140)
• if, if...else i if...elsif (140)
• unless (142)
• Operator warunkowy ?...: (142)
• Operatory logiczne w wyrażeniach warunkowych (143)
• Pętle while (144)
• while (144)
• until (146)
• do (146)
• Przykład: wskaż liczbę (147)
• Iteracje przy użyciu pętli for (149)
• for (150)
• foreach (151)
• Kontrolowanie pętli (152)
• last, next i redo (152)
• Etykietowanie pętli (154)
• Standardowa zmienna $_ (155)
• Czytanie danych z pliku przy użyciu pętli while i operatora <> (156)
• Wkraczamy w głąb (159)
• Modyfikatory o charakterze pętli i wyrażeń warunkowych (159)
• continue (160)
• Konstruowanie wyrażeń switch lub case (161)
• goto (161)
• Podsumowanie (162)
• Pytania i odpowiedzi (163)
• Warsztat (164)
• Quiz (164)
• Ćwiczenia (164)
• Odpowiedzi (165)
• Odpowiedzi do quizu (165)
• Odpowiedzi do ćwiczeń (166)

Rozdział 7. Kilka dłuższych przykładów (167)


• Statystyka z poprawionym histogramem (167)
• Jaka to cyfra? (172)
• Konwersja tekstu na postać dokumentu HTML (174)
• Zasada działania (174)
• Plik wejściowy (175)
• Skrypt (176)
• Podsumowanie (180)

Część II. Poszerzanie umiejętności (181)


Rozdział 8. Operowanie listami i łańcuchami (183)


• Wycinki tablic (183)
• Sortowanie list (185)
• Przeszukiwanie list (186)
• Przykład: jeszcze raz lista nazwisk (188)
• Modyfikowanie elementów listy (193)
• push i pop (193)
• shift i unshift (194)
• splice (195)
• Inne metody przetwarzania list (196)
• reverse (196)
• join (197)
• map (197)
• Manipulowanie łańcuchami (198)
• reverse (199)
• index i rindex (199)
• substr (200)
• Wkraczamy w głąb (201)
• Podsumowanie (201)
• Pytania i odpowiedzi (202)
• Warsztat (203)
• Quiz (203)
• Ćwiczenia (204)
• Odpowiedzi (204)
• Odpowiedzi do quizu (204)
• Odpowiedzi do ćwiczeń (205)

Rozdział 9. Porównywanie wzorców (207)


• Czym jest i do czego służy mechanizm porównywania wzorców (208)
• Wyrażenia i operatory porównywania wzorców (209)
• Wzorce proste (210)
• Sekwencje znaków (211)
• Porównywanie na granicy słowa lub wiersza (212)
• Porównania alternatywne (213)
• Porównywanie grup znaków (214)
• Klasy znaków (215)
• Zakresy (216)
• Zanegowane klasy znaków (216)
• Klasy specjalne (217)
• Dopasowywanie wszelkich znaków przy użyciu kropki (218)
• Przykład: optymalizacja skryptu numtolan (218)
• Dopasowywanie wielorakich wystąpień znaków (223)
• Znaki opcjonalne (224)
• Wielokrotne wystąpienia znaków (225)
• Wymuszanie obecności przynajmniej jednego znaku (225)
• Ograniczanie ilości wystąpień (226)
• Dalsze szczegóły na temat budowania wzorców (227)
• Wzorce i zmienne (227)
• Wzorce i pętle (228)
• Kolejny przykład: zliczanie (228)
• Priorytet wzorców (229)
• Wkraczamy w głąb (230)
• Inne możliwości użycia wzorców (230)
• Znaki ograniczające wzorzec i znaki specjalne (231)
• Podsumowanie (232)
• Pytania i odpowiedzi (232)
• Warsztat (233)
• Quiz (233)
• Ćwiczenia (234)
• Odpowiedzi (234)
• Odpowiedzi do quizu (234)
• Odpowiedzi do ćwiczeń (235)

Rozdział 10. Więcej na temat wyrażeń regularnych (237)


• Wydobywanie danych dopasowanych przez wzorzec (237)
• Użycie nawiasów do tworzenia odwołań wstecznych (238)
• Zmienne wzorców zapamiętanych (240)
• Dopasowanie i kontekst (240)
• Słowo o zachłanności (241)
• Wzorce w procesie poszukiwania i zamiany (243)
• Funkcja split po raz kolejny (244)
• Szukanie wzorca rozbitego na kilka wierszy danych (246)
• Zapisywanie wiersza danych (246)
• Przetwarzanie danych zawierających znaki nowego wiersza (247)
• Znaki specjalne i opcje - podsumowanie (248)
• Przykład: Ekstraktor rysunków (250)
• Wskazówki dotyczące budowania wyrażeń regularnych (254)
• Wkraczamy w głąb (255)
• Dodatkowe metaznaki (255)
• Zmienne specjalne (256)
• Opcje (256)
• Podsumowanie (257)
• Pytania i odpowiedzi (258)
• Warsztat (259)
• Quiz (259)
• Ćwiczenia (259)
• Odpowiedzi (260)
• Odpowiedzi do quizu (260)
• Odpowiedzi do ćwiczeń (261)

Rozdział 11. Tworzenie i użytkowanie procedur (263)


• Procedury kontra funkcje (263)
• Definiowanie i wywoływanie procedur (264)
• Przykład procedury (264)
• Definiowanie procedur (265)
• Wywoływanie procedur (266)
• Przykład: statystyka z użyciem procedur (267)
• Zwracanie wartości przez procedury (268)
• Zmienne lokalne w procedurach (270)
• Przekazywanie parametrów do procedury (272)
• Przekazywanie argumentów (272)
• Przetwarzanie argumentów wewnątrz procedur (273)
• Uwaga na temat argumentów przekazywanych przez odwołanie (274)
• Procedury i kontekst (275)
• Kolejny przykład: statystka z menu (275)
• Wkraczamy w głąb (281)
• Przekazywanie argumentów bez użycia nawiasów (282)
• Przekazywanie argumentów do procedury poprzez tablicę @_ (282)
• Procedury anonimowe (283)
• Prototypy procedur (283)
• Funkcja caller (284)
• Podsumowanie (284)
• Pytania i odpowiedzi (285)
• Warsztat (286)
• Quiz (286)
• Ćwiczenia (286)
• Odpowiedzi (287)
• Odpowiedzi do quizu (287)
• Odpowiedzi do ćwiczeń (289)

Rozdział 12. Wykrywanie błędów (291)


• Korzystanie z debuggera - prosty przykład (292)
• Uruchamianie i praca z debuggerem (296)
• Śledzenie wykonania (297)
• Praca krokowa (298)
• Wyświetlanie kodu źródłowego (299)
• Wyświetlanie wartości zmiennych (300)
• Ustawianie punktów przerwań (301)
• Pozostałe polecenia (302)
• Słowo na zakończenie (302)
• Wkraczamy w głąb (302)
• Korzystanie z innych debuggerów (302)
• Uruchamianie Perla w sposób interaktywny (303)
• Najczęstsze błędy oraz pytania (303)
• Podsumowanie (303)
• Pytania i odpowiedzi (304)
• Warsztat (304)
• Quiz (304)
• Ćwiczenia (304)
• Odpowiedzi (305)
• Odpowiedzi do quizu (305)
• Odpowiedzi do ćwiczeń (306)

Rozdział 13. Zasięg, moduły i importowanie kodu (307)


• Zmienne globalne i pakiety (307)
• Problem ze zmiennymi globalnymi (308)
• Czym jest pakiet? (308)
• Pakiety a zmienne (309)
• Zmienne globalne nie należące do pakietów (310)
• Zmienne i zasięg lokalny (312)
• Zmienna lokalne i zasięg lokalny (312)
• Zmienne lokalne - my i local (313)
• Moduły Perla (314)
• Terminologia (314)
• Pobieranie modułów (315)
• Importowanie modułów (316)
• Użytkowanie modułów (317)
• Ręczne importowanie symboli (318)
• Identyfikatory importu (320)
• Pragmy (320)
• Moduł English (322)
• Przykład: moduł Text::Wrap (322)
• Użytkowanie modułów pochodzących z sieci CPAN (324)
• Słowo przestrogi (324)
• Pozyskiwanie modułów z sieci CPAN (325)
• Instalowanie modułów CPAN w środowisku Windows (326)
• Użytkowanie modułów sieci CPAN (327)
• Wkraczamy w głąb (327)
• Typeglob (327)
• Kolejna różnica między my i local (328)
• Przykład ilustrujący zmienne local kontra my (328)
• Inicjalizacja i finalizacja pakietów przy użyciu BEGIN i END (330)
• Importowanie kodu przy użyciu require (330)
• Podsumowanie (331)
• Pytania i odpowiedzi (332)
• Warsztat (334)
• Quiz (334)
• Ćwiczenia (334)
• Odpowiedzi (335)
• Odpowiedzi do quizu (335)
• Odpowiedzi do ćwiczeń (336)

Rozdział 14. Kilka dłuższych przykładów (339)


• Książka adresowa (adresy.pl) (339)
• Działanie (340)
• Plik adresów (341)
• Wnętrze skryptu (342)
• Czytanie adresu (343)
• Przeprowadzanie poszukiwania (344)
• Wyświetlanie rekordu (347)
• Kod skryptu (347)
• Analizator logów sieci WWW (weblog.pl) (349)
• Działanie (350)
• Plik logów (351)
• Budowa skryptu (352)
• Przetwarzanie pliku logów (353)
• Wyświetlanie wyników (356)
• Procedura &getdomains() (357)
• Procedura &gettop() (359)
• Kod skryptu (359)
• Podsumowanie (362)

Część III. Perl zaawansowany (365)


Rozdział 15. Pliki oraz standardowe wejście/wyjście (367)


• Czytanie i zapisywanie danych - uchwyty plików (367)
• Tworzenie uchwytów plików przy użyciu funkcji open (368)
• Funkcja die (370)
• Czytanie danych poprzez uchwyt pliku (371)
• Zapisywanie danych poprzez uchwyt pliku (372)
• Czytanie i zapisywanie plików binarnych (373)
• Zamykanie uchwytu pliku (373)
• Przykład: wydobywanie i zachowywanie tematów wiadomości pocztowych (373)
• Testy plików (374)
• Argumenty skryptu oraz tablica @ARGV (376)
• Anatomia tablicy @ARGV (376)
• Przełączniki skryptu i zabawa z modułem Getopt (377)
• getopts (378)
• Przetwarzanie błędów przy użyciu getopts (379)
• getopt (380)
• Kolejny przykład (381)
• Wkraczamy w głąb (382)
• Jeszcze raz funkcja open i uchwyty plików (382)
• Inne funkcje związane z przetwarzaniem plików (383)
• Operacje wejścia i wyjścia niskiego poziomu (383)
• Pliki DBM (384)
• Timestamps (385)
• Podsumowanie (385)
• Pytania i odpowiedzi (386)
• Warsztat (387)
• Quiz (387)
• Ćwiczenia (387)
• Odpowiedzi (388)
• Odpowiedzi do quizu (388)
• Odpowiedzi do ćwiczeń (389)

Rozdział 16. Tworzenie skryptów CGI za pomocą Perla (393)


• Wstęp (393)
• Jak działa CGI (394)
• Budowanie skryptu CGI, od formularza do odpowiedzi (396)
• Formularz (396)
• Tworzenie skryptu (397)
• Testowanie skryptu (399)
• Tworzenie skryptów CGI za pomocą modułu CGI.pm (400)
• Pobieranie modułu CGI.pm (401)
• Użytkowanie modułu CGI.pm (401)
• Przetwarzanie danych z formularza (402)
• Generowanie kodu HTML (403)
• Wyprowadzanie danych poprzez funkcje print (403)
• Wyprowadzanie danych poprzez dokumenty ze znacznikiem końca (403)
• Wyprowadzanie danych przy użyciu procedur modułu CGI.pm (404)
• Testowanie skryptów po ich zainstalowaniu (405)
• Przykład: ankieta (406)
• Formularz (407)
• Skrypt (408)
• Wkraczamy w głąb (411)
• Korzystanie ze zmiennych CGI (411)
• POST kontra GET (413)
• Przekierowanie (413)
• Ciasteczka i ściąganie plików (413)
• Skrypty CGI i bezpieczeństwo (413)
• Osadzanie Perla wewnątrz serwerów WWW (414)
• Podsumowanie (414)
• Pytania i odpowiedzi (415)
• Warsztat (417)
• Quiz (417)
• Ćwiczenia (417)
• Odpowiedzi (418)
• Odpowiedzi do quizu (418)
• Odpowiedzi do ćwiczeń (419)

Rozdział 17. Zarządzanie plikami i katalogami (421)


• Zarządzanie plikami (421)
• Zamiana nazwy pliku (422)
• Dowiązania (422)
• Usuwanie plików i odnośników (423)
• Inne operacje (423)
• Operacje związane z drzewem katalogów (424)
• Poruszanie się po drzewie katalogów (424)
• Listy plików (425)
• Globalne specyfikacje plików (425)
• Listy katalogów (426)
• Tworzenie i usuwanie katalogów (427)
• Przykład: tworzenie odnośników (428)
• Wkraczamy w głąb (430)
• Podsumowanie (431)
• Pytania i odpowiedzi (431)
• Warsztat (432)
• Quiz (432)
• Ćwiczenia (432)
• Odpowiedzi (433)
• Odpowiedzi do quizu (433)
• Odpowiedzi do ćwiczeń (434)

Rozdział 18. Perl a system operacyjny (437)


• Cechy UNIX-a w Perlu (438)
• Zmienne środowiskowe (438)
• Uruchamianie programów przy użyciu funkcji system (439)
• Cudzysłowy lewostronne (440)
• Użytkowanie procesów (441)
• Jak działają procesy (441)
• fork i exit (442)
• Zarządzanie procesami za pomocą funkcji exit, wait i kill (445)
• Uruchamianie innych programów przy użyciu funkcji exec (448)
• Inne funkcje związane z systemem UNIX (448)
• Perl dla Windows (448)
• Zgodność z systemem UNIX (449)
• Wbudowane procedury Win32 (450)
• Win32::MsgBox (451)
• Procesy Win32 (453)
• Przetwarzanie Rejestru Windows (455)
• Inne moduły Win32 (457)
• Wkraczamy w głąb (457)
• Strumienie (457)
• Sygnały (458)
• Podstawowe operacje sieciowe (458)
• Interfejs użytkownika w Perlu (459)
• Podsumowanie (459)
• Pytania i odpowiedzi (459)
• Warsztat (461)
• Quiz (461)
• Ćwiczenia (461)
• Odpowiedzi (462)
• Odpowiedzi do quizu (462)
• Odpowiedzi do ćwiczeń (463)

Rozdział 19. Odwołania (465)


• Czym jest odwołanie? (465)
• Podstawowe informacje z zakresu odwołań (466)
• Tworzenie odwołań (466)
• Wyświetlanie i korzystanie z odwołań (467)
• Dostęp do wartości wskazywanych przez odwołania (468)
• Podmiana wskazywanych danych (469)
• Wykorzystanie odwołań w procedurach (470)
• Argumenty procedur (471)
• Zwracanie wartości przez odwołania (473)
• Inne metody korzystania z odwołań (473)
• Dostęp do elementów listy wskazywanej przez odwołanie (473)
• Dostęp do wartości poprzez bloki (474)
• Funkcja ref (475)
• Kilka uwag na temat pamięci (476)
• Tworzenie zagnieżdżonych struktur danych (477)
• Czym jest zagnieżdżona struktura danych? (478)
• Dane anonimowe (478)
• Tworzenie struktur danych z użyciem danych anonimowych (480)
• Tablice tablic (480)
• Tablice rozproszone tablic (481)
• Tablice rozproszone tablic rozproszonych (482)
• Inne struktury (483)
• Tworzenie struktur na postawie istniejących danych (484)
• Dostęp do elementów zagnieżdżonych struktur danych (485)
• Przykład: baza danych artystów i ich dzieł (487)
• Wkraczamy w głąb (491)
• Skrótowa forma tworzenia odwołań (491)
• Odwołania symboliczne (492)
• Odwołania do typeglobów i uchwytów plików (492)
• Odwołania do procedur (493)
• Podsumowanie (493)
• Pytania i odpowiedzi (494)
• Warsztat (495)
• Quiz (495)
• Ćwiczenia (496)
• Odpowiedzi (497)
• Odpowiedzi do quizu (497)
• Odpowiedzi do ćwiczeń (499)

Rozdział 20. Pozostałe elementy języka Perl (503)


• Jednoliniowe skrypty Perla (504)
• Programowanie zorientowane obiektowo (506)
• Wprowadzenie (506)
• Podstawy (dla osób znających już OOP) (507)
• Używanie klas, obiektów i odwołań do obiektów (507)
• Zmienne obiektów (508)
• Dziedziczenie (510)
• Definiowanie metod (510)
• Metody uruchamiane automatycznie (512)
• Przykład: wykorzystanie modułów obiektowych (513)
• Formatowanie danych (515)
• Gniazda (518)
• Pliki POD (519)
• Tworzenie plików POD (519)
• Osadzanie dokumentacji POD w skryptach (521)
• Realizacja kodu w czasie rzeczywistym (521)
• Tworzenie skryptów w wersji międzynarodowej (522)
• Bezpieczeństwo skryptów - taint mode (522)
• PerlScript (523)
• Rozszerzenia Perla (524)
• Nowe cechy Perla w wersji 5.005 (525)
• Wkraczamy w głąb (526)
• Podsumowanie (526)
• Pytania i odpowiedzi (527)
• Warsztat (528)
• Quiz (528)
• Ćwiczenia (529)
• Odpowiedzi (529)
• Odpowiedzi do ćwiczeń (529)
• Odpowiedzi do ćwiczeń (531)

Rozdział 21. Kilka dłuższych przykładów (535)


• Generator strony domowej (homepage.pl) (536)
• Jak to działa (536)
• Wewnątrz skryptu (538)
• Moduły LWP::Simple i URI::URL (540)
• Funkcja eval (541)
• Inna konfiguracja (542)
• Menadżer zadań (544)
• Plik danych (546)
• Działanie skryptu (546)
• Inicjalizacja danych - &init() (546)
• Przetwarzanie formularza oraz jego danych - &process() (547)
• Wyświetlanie danych - &display_all() i &display_data() (548)
• Uaktualnianie danych - update_data() (548)
• Dodawanie i usuwanie zadań - &add_item() i &remove_selected() (549)
• Inne procedury (zapisywanie danych i wykrywanie błędów) (549)
• Kod (550)
• Podsumowanie (557)

Dodatki (559)


Dodatek A. Funkcje Perla (561)


• Dalsze szczegóły (561)
• Funkcje Perla w porządku alfabetycznym (562)
• abs (562)
• accept (562)
• alarm (562)
• atan2 (562)
• bind (563)
• binmode (563)
• bless (563)
• caller (563)
• chdir (564)
• chmod (564)
• chomp (564)
• chop (564)
• chown (565)
• chr (565)
• chroot (565)
• close (565)
• closedir (565)
• connect (566)
• cos (566)
• crypt (566)
• dbmclose (566)
• dbmopen (566)
• defined (567)
• delete (567)
• die (567)
• do (567)
• dump (568)
• each (568)
• eof (568)
• eval (569)
• exec (569)
• exists (569)
• exit (569)
• exp (570)
• fcntl (570)
• fileno (570)
• flock (570)
• fork (570)
• format (571)
• formline (571)
• getc (571)
• getlogin (571)
• getpeername (571)
• getpgrp (571)
• getpid (572)
• getpriority (572)
• getsockname (572)
• getsockopt (572)
• glob (572)
• gmtime (572)
• goto (573)
• grep (573)
• hex (573)
• import (573)
• index (574)
• int (574)
• ioctl (574)
• join (574)
• keys (575)
• kill (575)
• last (575)
• lc (575)
• lcfirst (575)
• length (576)
• link (576)
• listen (576)
• local (576)
• localtime (576)
• log (576)
• lstat (577)
• map (577)
• mkdir (577)
• msgctl (577)
• msgget (578)
• msgrcv (578)
• msgsnd (578)
• my (578)
• next (578)
• no (578)
• oct (579)
• open (579)
• opendir (579)
• ord (579)
• pack (579)
• package (581)
• pipe (581)
• pop (581)
• pos (581)
• print (581)
• printf (582)
• push (582)
• quotemeta (582)
• rand (582)
• read (583)
• readdir (583)
• readlink (583)
• recv (583)
• redo (583)
• ref (584)
• rename (584)
• require (584)
• reset (584)
• return (584)
• reverse (585)
• rewinddir (585)
• rmdir (585)
• scalar (585)
• seek (585)
• seekdir (585)
• select (586)
• semctl (586)
• semget (586)
• semop (586)
• send (586)
• setpgrp (586)
• setpriority (587)
• setsockopt (587)
• shift (587)
• shmctl (587)
• shmget (587)
• shmread (587)
• shmwrite (588)
• shutdown (588)
• sin (588)
• sleep (588)
• socket (588)
• socketpair (588)
• sort (589)
• splice (589)
• split (590)
• sprintf (591)
• sqrt (591)
• srand (592)
• stat (592)
• study (592)
• substr (593)
• symlink (593)
• syscall (593)
• sysopen (593)
• sysread (593)
• sysseek (594)
• system (594)
• syswrite (594)
• tell (594)
• telldir (594)
• tie (594)
• tied (595)
• time (595)
• times (595)
• truncate (595)
• uc (595)
• ucfirst (595)
• umask (596)
• undef (596)
• unlink (596)
• unpack (596)
• unshift (596)
• utime (596)
• values (597)
• vec (597)
• wait (597)
• waitpid (597)
• wantarray (597)
• warn (597)
• write (598)

Dodatek B. Przegląd modułów Perla (599)


• Pragmy (599)
• constant (600)
• diagnostics (600)
• integer (600)
• lib (600)
• overload (600)
• sigtrap (600)
• strict (600)
• subs (601)
• vars (601)
• Podstawowe moduły Perla (601)
• Autoloader (601)
• B (601)
• Carp (601)
• Config (602)
• English (602)
• Exporter (602)
• Opcode (602)
• PodParser (602)
• Symbol (602)
• Moduły Tie (602)
• Moduły wspierające proces projektowania (603)
• Benchmark (603)
• Devel::DProf (603)
• ExtUtils (603)
• Usage (603)
• Moduły związane z różnymi systemami operacyjnymi (603)
• AppleII (603)
• BSD::Time (604)
• Env (604)
• Fcntl (604)
• OS2 (604)
• POSIX (604)
• Moduły realizujące zadania sieciowe (604)
• IPC::Signal (605)
• Net::Cmd (605)
• Net::Country (605)
• Net::DNS (605)
• Net::Domain (605)
• Net::FTP (605)
• Net::Gen (605)
• Net::Ident (605)
• Net::Inet (606)
• Net::Netrc (606)
• Net::NIS, Net::NISPlus (606)
• Net::NNTP (606)
• Net::Ping (606)
• Net::POP3 (606)
• Net::SMTP (606)
• Net::SNPP (606)
• Net::SSLeay (607)
• Net::TCP (607)
• Net::Telnet (607)
• Net::Time (607)
• Net::UDP (607)
• SNMP (607)
• Socket (607)
• Narzędzia zarządzające typami danych (607)
• Date::DateCalc (608)
• Date::Format (608)
• Date::Language (608)
• Date::Manip (608)
• Date::Parse (608)
• Math::BigFloat, Math::BigInt (608)
• Math::Complex (608)
• Math::Fraction (608)
• Math::Matrix (609)
• Math::PRSG (609)
• Math::Trig (609)
• Math::TrulyRandom (609)
• Ref (609)
• Sort::Versions (609)
• Statistics::Descriptive (609)
• Time-Modules (609)
• TimeDate (610)
• Moduły związane z obsługą baz danych (610)
• AnyDBM_File (610)
• DBD (610)
• DBI (610)
• DB_File (610)
• Msql (611)
• Oraperl (611)
• Pg (611)
• SDBM_File (611)
• Sybperl (611)
• Interfejsy użytkownika (611)
• Curses (611)
• Qt (611)
• Term::AnsiColor (612)
• Term::Gnuplot (612)
• Tk (612)
• X11:FVWM (612)
• X11:Protocol (612)
• Moduły obsługi systemu plików (612)
• Cwd (612)
• File::Df (612)
• File::Flock (613)
• File::Copy (613)
• File::Lock (613)
• File::Lockf (613)
• File::Recurse (613)
• File::Tools (613)
• Moduły przetwarzające łańcuchy (613)
• Przetwarzanie opcji/argumentów (614)
• Getopt::Long (614)
• Getopt::Mixed (614)
• Getopt::Std (614)
• IniConf (614)
• Internacjonalizacja i lokalizacja (614)
• I18N::Collate (614)
• Locale::Codes (614)
• Unicode (615)
• Kryptografia, autoryzacja i bezpieczeństwo (615)
• Authen::Radius (615)
• Crypt::Des (615)
• Crypt::Idea (615)
• MD5 (615)
• PGP (615)
• Moduły związane z HTML, HTTP, WWW i CGI (616)
• Apache (616)
• CGI (616)
• libwww (616)
• Archiwizacja i kompresja (616)
• Compress (616)
• Convert::BinHex (617)
• Convert::UU (617)
• Operacje na obrazach i bitmapach (617)
• GD (617)
• Image::Size (617)
• Image::Magick (617)
• Poczta i Usenet (617)
• Mail::POP3Client (617)
• News::Newsrc (618)
• Narzędzia kontrolujące przepływ (618)
• AtExit (618)
• Religion (618)
• Uchwyty plików oraz Wejście/Wyjście (618)
• DirHandle (618)
• FileCache (618)
• FileHandle (619)
• IO (619)
• Moduły środowiska Windows (619)
• libwin32 (619)
• Inne moduły (619)
• Archie (619)
• Business::CreditCard (619)
• CPAN (620)

Dodatek C. Instalowanie Perla w systemie UNIX (621)


• Co jest potrzebne do instalacji Perla? (621)
• Dostęp do Perla (622)
• Pobieranie wersji skompilowanej (622)
• Pobieranie wersji źródłowej (623)
• Dekompresja i kompilacja (624)
• Uruchomienie programu konfiguracyjnego (624)
• Przygotowanie instalacji (625)
• Katalogi i konfiguracja podstawowa (625)
• Kompilatory i biblioteki (626)
• Dokumentacja i ustawienia sieciowe (626)
• Pozostałe rzeczy (627)
• Uruchomienie programu make (628)
• Dalsze informacje (629)

Dodatek D. Instalowanie Perla dla Windows (631)


• Pobieranie Perla dla Windows (632)
• Instalowanie Perla dla Windows (633)
• Uruchomienie Perla dla Windows (634)
• Pobieranie kodu źródłowego Perla (634)
• Dalsze informacje (635)

Skorowidz (637)

pokaż cały spis treści

ukryj recenzje