Książka zawiera rzeczowe wprowadzenie do programowania w Perlu. Jeśli chcesz dowiedzieć się, jak coś zrobić w Perlu, tutaj znajdziesz odpowiedź.

Perl jest dużym i złożonym produktem, a niniejsza książka czyni ten język przystępnym. Jest to książka wyjątkowa, gdyż można ją uznać za bardzo zwarty podręcznik Perla 5. Autor to doskonały programista, który w swojej książce umieścił blisko 400 działających przykładów, a także omówił około 500 różnych zagadnień.

Znajdziesz tu kompletny opis składni Perla 5, jak również opis tworzenia internetowych książek odwiedzin. Nauczysz się tworzyć perlowe klasy i obiekty, używać pakietów i modułów, łączyć Perla z pakietem Tk, czy choćby budować aplikacje do prowadzenia rozmów (chat). W książce tej są omówione praktyczne zagadnienia programowania w Perlu: obsługa cookies, kwestie bezpieczeństwa w Sieci, usuwanie błędów, wysyłanie ze skryptów CGI poczty elektronicznej, złożone struktury danych -- znajdziesz tu po prostu wszystko.

Osoby które kupowały "Perl. Czarna księga", wybierały także:

• Perl. Mistrzostwo w programowaniu 44,00 zł, (22,00 zł -50%)
• Wielkie umysły programowania. Jak myślą i pracują twórcy najważniejszych języków 79,00 zł, (47,40 zł -40%)
• Learning Perl. Making Easy Things Easy and Hard Things Possible. 7th Edition 169,00 zł, (118,30 zł -30%)
• 100 sposobów na Perl 39,00 zł, (29,25 zł -25%)
• Perl Hacks. Tips & Tools for Programming, Debugging, and Surviving 94,98 zł, (80,73 zł -15%)

Spis treści

Perl. Czarna księga -- spis treści

O Autorze (17)

Wprowadzenie (19)

• Zawartość tej książki (19)
  
• Co będzie nam potrzebne? (22)
  
• Inne zasoby (23)

Część I Składnia języka Perl (25)

Rozdział 1. Co o Perlu trzeba wiedzieć? (27)

• W skrócie (27)
  
  • Zaczynamy od początku (27)
• Zagadnienia (28)
  
  • Uzyskanie i instalacja Perla (28)
  • Zapisywanie skryptów Perla (29)
  • Uwidacznianie Perla dla skryptów (30)
  • Kod Perla: instrukcje i deklaracje (32)
  • Uruchamianie skryptów Perla (33)
  • Interaktywne uruchamianie skryptów Perla (35)
  • Użycie przełączników wiersza poleceń (36)
  • Użycie przełącznika -w - ostrzeżenia (38)
  • Obsługa wejściowych i wyjściowych danych tekstowych przy pomocy standardowych uchwytów plików (39)
  • Wyświetlanie danych tekstowych (39)
  • Wyświetlanie numerów wierszy i nazw plików ze skryptami (40)
  • Wielokrotne drukowanie tekstu (40)
  • Podstawowe formatowanie tekstu (41)
  • Wyświetlanie tekstu niesformatowanego: otwierane dokumenty Perla (42)
  • Komentowanie kodu (42)
  • Odczyt wprowadzanych danych (43)
  • Użycie zmiennej domyślnej $_ (43)
  • Czyszczenie danych wejściowych (44)
  • Unikanie natychmiastowego zamknięcia okna skryptu w Windows 95/98 i NT (45)

Rozdział 2. Zmienne skalarne i listy (47)

• W skrócie (47)
  
  • Zmienne skalarne (47)
  • Listy (48)
• Zagadnienia (48)
  
  • Czym jest zmienna skalarna? (48)
  • Nazwy zmiennych skalarnych (49)
  • Przypisywanie wartości skalarnych (50)
  • Co to jest lvalue? (50)
  • Użycie liczb jako wartości skalarnych (50)
  • Użycie wartości nieokreślonej: undef (51)
  • Deklarowanie stałej (52)
  • Obsługa w Perlu wartości logicznych (52)
  • Przekształcanie liczb ósemkowych, dziesiętnych i szesnastkowych (52)
  • Zaokrąglanie liczb (53)
  • Użycie w zmiennych skalarnych tekstów (54)
  • Stosowanie interpolacji w tekście (56)
  • Skomplikowane interpolacje (57)
  • Obsługa cudzysłowów i samodzielnych słów (58)
  • Czym jest lista? (59)
  • Odwoływanie się do elementów listy przez indeks (60)
  • Przypisywanie listy innej liście (61)
  • Odwzorowanie listy (61)
  • Łączenie listy w ciąg znaków (61)
  • Przekształcanie tekstu w listę (62)
  • Sortowanie list (62)
  • Odwracanie listy (63)
  • Wybieranie elementów z listy (63)
  • Jak rozumieć konteksty skalarny i listowy? (64)
  • Wymuszanie kontekstu skalarnego (64)

Rozdział 3. Tablice i asocjacje (67)

• W skrócie (67)
  
  • Tablice (67)
  • Asocjacje (67)
  • Typy ogólne (68)
• Zagadnienia (68)
  
  • Tworzenie tablic (68)
  • Użycie tablic (70)
  • Dokładanie elementów na koniec tablicy i ich usuwanie (70)
  • Przesuwanie elementów tablicy (71)
  • Określanie wielkości tablicy (72)
  • Powiększanie i zmniejszanie tablic (72)
  • Łączenie dwóch tablic (73)
  • Pobieranie warstw tablic (73)
  • Pętle na tablicach (73)
  • Wyświetlanie tablic (75)
  • Warstwy tablic (76)
  • Odwracanie tablic (76)
  • Sortowanie tablic (77)
  • Tworzenie asocjacji (77)
  • Użycie asocjacji (79)
  • Dodawanie elementów do asocjacji (79)
  • Sprawdzanie, czy istnieje dany element asocjacji (80)
  • Usuwanie elementów asocjacji (80)
  • Przetwarzanie asocjacji w pętli (81)
  • Wyświetlanie asocjacji (82)
  • Sortowanie asocjacji (82)
  • Łączenie dwóch asocjacji (83)
  • Użycie asocjacji i tablic w przypisaniach list (83)
  • Użycie typów ogólnych (84)
  • Porównywanie typów ogólnych i haseł tablicy symboli (85)

Rozdział 4. Operatory i priorytety (87)

• W skrócie (87)
  
  • Priorytety operatorów (88)
• Zagadnienia (89)
  
  • Najwyższy priorytet: termy i lewostronne operatory list (89)
  • Operator "strzałka" (90)
  • Inkrementacja i dekrementacja (90)
  • Potęgowanie (91)
  • Symboliczne operatory unarne (91)
  • Operatory wiązania (92)
  • Mnożenie i dzielenie (92)
  • Dodawanie, odejmowanie i konkatenacja (93)
  • Operatory przesunięć (93)
  • Nazwane operatory unarne (94)
  • Użycie operatorów testowania plików (94)
  • Operatory porównania (95)
  • Użycie operatorów równości (97)
  • Iloczyn bitowy (98)
  • Bitowa alternatywa (98)
  • Bitowa alternatywa wyłączająca (98)
  • Użycie logicznej koniunkcji w stylu C (99)
  • Użycie logicznej alternatywy w stylu C (100)
  • Operator zakresu (100)
  • Operator wyboru (101)
  • Przypisania (102)
  • Przecinek jako operator (102)
  • Użycie prawostronnych operatorów list (103)
  • Logiczna negacja (103)
  • Logiczna koniunkcja (103)
  • Logiczna alternatywa (103)
  • Logiczna alternatywa wykluczająca (104)

Rozdział 5. Instrukcje warunkowe i pętle (105)

• W skrócie (105)
  
  • Instrukcje warunkowe (105)
  • Pętle (106)
• Zagadnienia (107)
  
  • Instrukcja if (107)
  • Instrukcja unless (108)
  • Pętla for (109)
  • Pętla foreach (110)
  • Pętla while (112)
  • Pętla until (113)
  • Użycie if, unless, until i while do modyfikowania działania instrukcji (113)
  • Pętla do while (114)
  • next - wymuszenie następnej iteracji (114)
  • last - zakończenie pętli (115)
  • redo - powtarzanie iteracji (116)
  • Instrukcja switch (116)
  • Użycie goto (117)
  • Użycie eval do uruchamiania kodu (118)
  • Użycie exit do zakończenia wykonywania programu (118)
  • Instrukcja die (119)

Rozdział 6. Wyrażenia regularne (121)

• W skrócie (121)
  
  • Użycie wyrażeń regularnych (121)
• Zagadnienia (123)
  
  • Wyrażenia regularne (123)
  • Zwykłe znaki w wyrażeniach regularnych (124)
  • Klasy znaków w wyrażeniach regularnych (126)
  • Alternatywne wzorce (127)
  • Kwantyfikatory w wyrażeniach regularnych (127)
  • Asercje w wyrażeniach regularnych (128)
  • Odwołania do poprzednich dopasowań (129)
  • Rozszerzenia wyrażeń regularnych (130)
  • Modyfikatory operatorów m// i s/// (130)
  • Operator tr/// - translacja (131)
  • Użycie modyfikatorów operatora tr/// (132)
  • Dopasowywanie słów (132)
  • Dobieranie początku wiersza (133)
  • Dobieranie końca wiersza (133)
  • Badanie liczb (133)
  • Badanie liter (134)
  • Odnajdowanie wielokrotnych dopasowań (134)
  • Pomijanie wielkości liter (135)
  • Wycinanie części ciągu (135)
  • Wywołania funkcji i wyrażeń Perla w wyrażeniach regularnych (136)
  • Dobranie n-tego dopasowania (136)
  • Ograniczanie apetytu kwantyfikatorów (136)
  • Usuwanie spacji wiodących i końcowych (137)
  • Użycie asercji do sprawdzania w przód i wstecz (137)

Rozdział 7. Procedury (139)

• W skrócie (139)
  
  • Użycie procedur (139)
• Zagadnienia (140)
  
  • Deklarowanie procedur (140)
  • Prototypy (141)
  • Definiowanie procedur (142)
  • Wywoływanie procedur (143)
  • Odczytywanie parametrów procedury (143)
  • Zmienna liczba parametrów (144)
  • Użycie domyślnych wartości parametrów (144)
  • Wartości zwracane przez procedury (funkcje) (145)
  • Użycie my do określania zasięgu (146)
  • Żądanie leksykalnego ograniczenia zmiennych (148)
  • Local - zmienne tymczasowe (148)
  • Zmienne trwałe (statyczne) (149)
  • Rekurencyjne wywoływanie procedur (150)
  • Zagnieżdżanie procedur (150)
  • Przekazywanie przez referencję (151)
  • Przekazywanie pozycji z tablicy symboli (152)
  • Użycie wantarray do sprawdzenia kontekstu wyjściowego (153)
  • Funkcje wywoływane (153)
  • Nadpisywanie funkcji wbudowanych i użycie CORE (154)
  • Tworzenie procedur anonimowych (154)
  • Tworzenie tablic procedur (155)

Rozdział 8. Wskaźniki w Perlu (157)

• W skrócie (157)
  
  • Wskaźniki bezpośrednie (157)
  • Wskaźniki symboliczne (158)
  • Operator strzałki (159)
  • Anonimowe tablice, asocjacje i procedury (159)
• Zagadnienia (159)
  
  • Tworzenie wskaźnika (159)
  • Tworzenie wskaźników na tablice anonimowe (161)
  • Tworzenie wskaźników na asocjacje anonimowe (162)
  • Tworzenie wskaźników na procedury anonimowe (162)
  • Tworzenie wskaźników na podstawie tablicy symboli (163)
  • Dereferencja wskaźnika (164)
  • Dereferencja przy użyciu operatora "strzałka" (165)
  • Pomijanie operatora "strzałki" (166)
  • Użycie operatora ref do określania typu wskaźnika (167)
  • Tworzenie wskaźników symbolicznych (167)
  • Wyłączanie wskaźników symbolicznych (168)
  • Użycie wskaźników na tablice jako wskaźników na asocjacje (169)
  • Tworzenie trwałych obszarów zasięgu (169)
  • Tworzenie funkcji na podstawie szablonów (170)

Część II Elementy wbudowane (173)

Rozdział 9. Wbudowane zmienne Perla (175)

• W skrócie (175)
  
  • Angielskie wersje wbudowanych zmiennych (175)
  • Wiązanie zmiennych wbudowanych z uchwytami plików (177)
• Zagadnienia (178)
  
  • $' - tekst za wzorcem (178)
  • $- - numery wierszy w lewej części strony (178)
  • $! - ostatni błąd (179)
  • $" - separator pól wyjściowych interpolowanych wartości z tablic (179)
  • $# - format wyjściowy liczb (179)
  • $$ - numer procesu Perla (179)
  • $% - numer strony wyjściowej (180)
  • $& - ostatnie dopasowanie (180)
  • $( - rzeczywisty GID (180)
  • $) - obowiązujący GID (180)
  • $* - wzorce wielowierszowe (180)
  • $, - separator pól wyjściowych (181)
  • $. - numer wiersza wejściowego (181)
  • $/ - separator rekordów wejściowych (181)
  • $: - znaki dzielenia wiersza (181)
  • $; - separator indeksów (182)
  • $? - status ostatniego zamknięcia potoku, wywołania polecenia przez ` lub wywołania funkcji systemowej (182)
  • $@ - błąd ostatniej funkcji eval (182)
  • $[ - początek indeksów tablic (182)
  • $\ - separator rekordów wyjściowych (183)
  • $] - wersja Perla (183)
  • $^ - format nagłówka strony (183)
  • $^A - zapis bufora (183)
  • $^D - flagi debugowania (183)
  • $^E - informacje o błędzie związane z systemem operacyjnym (183)
  • $^F - największy systemowy deskryptor pliku (184)
  • $^H - ustawienia kontroli składniowej (184)
  • $^I - wartość edycji w miejscu (184)
  • $^L - zmiana strony wyjściowej (184)
  • $^M - awaryjny bufor pamięci (184)
  • $^O - nazwa systemu operacyjnego (184)
  • $^P - obsługa debugowania (185)
  • $^R - wynik asercji ostatniego wyrażenia regularnego (185)
  • $^S - stan interpretera (185)
  • $^T - czas uruchomienia skryptu (185)
  • $^W - ustawienie przełącznika ostrzeżeń (186)
  • $^X - nazwa pliku interpretera (186)
  • $_ - zmienna domyślna (186)
  • $` - tekst przed wzorcem (186)
  • $| - czyszczenie bufora wyjściowego (187)
  • $~ - nazwa formatu raportowania (187)
  • $+ - ostatnie dopasowanie nawiasów (187)
  • $< - rzeczywisty UID (187)
  • $= - obowiązująca długość strony (187)
  • $>- obowiązujący UID (188)
  • $0 - nazwa programu (188)
  • $ARGV - nazwa bieżącego pliku (188)
  • $n - dopasowanie numer n (188)
  • %ENV - ustawienia środowiska (189)
  • %INC - pliki włączane (189)
  • %SIG - obsługa sygnałów (189)
  • @_ - parametry procedur (189)
  • @ARGV - parametry wiersza poleceń (189)
  • @INC - położenie uruchamianych skryptów (190)

Rozdział 10. Wbudowane funkcje: przetwarzanie danych (191)

• W skrócie (191)
  
  • Funkcje wbudowane (191)
• Zagadnienia (192)
  
  • abs - wartość bezwzględna (192)
  • atan2 - arcus tangens (192)
  • chomp - usunięcie końców wierszy (192)
  • chop - usunięcie ostatniego znaku (193)
  • chr - znak o podanym kodzie (193)
  • cos - cosinus (193)
  • each - pary kluczy i wartości asocjacji (194)
  • eval - uruchamianie kodu Perla (194)
  • exists - sprawdzanie istnienia klucza w asocjacji (194)
  • exp - potęga liczby e (194)
  • hex - konwersja na liczbę szesnastkową (195)
  • index - położenie części tekstu (195)
  • int - odrzucenie części ułamkowej (195)
  • join - złączenie elementów listy w ciąg znaków (196)
  • keys - klucze asocjacji (196)
  • lc - zmiana na małe litery (196)
  • lcfirst - zmiana pierwszego znaku na małą literę (196)
  • length - długość tekstu (197)
  • log - logarytm naturalny (197)
  • map - wykonanie kodu dla każdego elementu (197)
  • oct - konwersja wartości ósemkowych (197)
  • ord - kod ASCII (198)
  • pack - kompresja danych (198)
  • pop - odebranie z tablicy elementu (199)
  • POSIX (grupa funkcji) (199)
  • push - wstawienie wartości do tablicy (200)
  • rand - liczba losowa (200)
  • reverse - odwrócenie kolejności elementów listy (201)
  • rindex - funkcja odwrotna do index (201)
  • scalar - wymuszenie kontekstu skalarnego (201)
  • shift - przesunięcie wartości w tablicy (201)
  • sin - sinus (202)
  • sort - sortowanie listy (202)
  • splice - warstwy tablic (203)
  • split - rozbicie tekstu na tablicę znaków (203)
  • sprintf - formatowanie tekstu (203)
  • sqrt - pierwiastek kwadratowy (205)
  • srand - wartość inicjalizująca generatora liczb losowych (206)
  • substr - zwraca część tekstu (206)
  • time - sekundy od 1 stycznia 1970 roku (206)
  • uc - wielkie litery (207)
  • ucfirst - zmiana pierwszej litery na wielką (207)
  • unpack - rozpakowywanie danych (207)
  • unshift - przesuwanie wartości w tablicy z ich dodawaniem (207)
  • values - wartości asocjacji (208)
  • vec - wektor składający się z liczb całkowitych bez znaku (208)

Rozdział 11. Funkcje wbudowane: I/O i komunikacja między procesami (209)

• W skrócie (209)
  
  • Formaty Perla (209)
• Zagadnienia (210)
  
  • print - drukowanie danych listowych (210)
  • printf - drukowanie formatowanych danych z list (211)
  • Użycie <>do odczytu danych (212)
  • getc - pobranie znaku (212)
  • write - zapis sformatowanego rekordu (212)
  • Formaty: wyrównanie tekstu do lewej (213)
  • Formaty: wyrównanie tekstu do prawej (213)
  • Formaty: centrowanie tekstu (213)
  • Formaty: prezentacja liczb (214)
  • Formaty: formatowanie danych wielowierszowych (214)
  • Formatowanie: rozdzielanie tekstu do formatowania danych wielowierszowych (214)
  • Formatowanie: wielowierszowe dane bez formatowania (215)
  • Formaty: dane w nagłówku raportu (215)
  • Formaty: zmienne formatów (216)
  • warn - wyświetlenie ostrzeżenia (216)
  • IPC: exec - wywołanie polecenia systemowego (217)
  • IPC: system - rozgałęzienie procesów i uruchomienie polecenia systemowego (218)
  • IPC: odczytywanie danych z innego programu (218)
  • IPC: wysyłanie danych do innego programu (219)
  • IPC: zapisywanie danych do procesu potomnego (219)
  • IPC: zapisywanie danych do procesu rodzica (220)
  • IPC: wysyłanie sygnału do innego procesu (221)
  • IPC: użycie gniazd (222)
  • IPC: OLE w Win32 (223)

Rozdział 12. Funkcje wbudowane: obsługa plików (225)

• W skrócie (225)
  
  • Wszystko o obsłudze plików (225)
• Zagadnienia (226)
  
  • open - otwarcie pliku (226)
  • close - zamknięcie pliku (228)
  • print - drukowanie do pliku (228)
  • write - pisanie do pliku (229)
  • binmode - ustawienie trybu binarnego (229)
  • Ustawianie buforowania kanału wyjściowego (230)
  • Odczyt plików przekazanych w wierszu poleceń (230)
  • Odczyt danych z uchwytu pliku (231)
  • read - odczyt danych (231)
  • readline - odczyt wiersza danych (232)
  • getc - pobranie znaku (232)
  • seek - ustawianie położenia w pliku (232)
  • tell - określanie położenia w pliku (233)
  • stat - status pliku (234)
  • Funkcje obsługi plików w POSIX (235)
  • select - określanie domyślnego uchwytu pliku wyjścia (235)
  • eof - sprawdzanie końca pliku (236)
  • Zapisywanie pliku bazy danych DBM (237)
  • Czytanie pliku bazy danych DBM (237)
  • flock - blokowanie pliku (238)
  • chmod - zmiana uprawnień do pliku (238)
  • glob - wyszukanie pasujących plików (238)
  • rename - zmiana nazwy pliku (239)
  • unlink - usuwanie plików (239)
  • opendir - otwarcie katalogu (239)
  • closedir - zamknięcie katalogu (240)
  • readdir - odczytanie pozycji katalogu (240)
  • seekdir - ustawienie się w katalogu (240)
  • telldir - określenie położenia w katalogu (240)
  • rewinddir - ustawienie się na początku katalogu (240)
  • chdir - zmiana katalogu roboczego (240)
  • mkdir - utworzenie katalogu (241)
  • rmdir - usunięcie katalogu (241)

Część III Programowanie w Perlu (243)

Rozdział 13. Moduły wbudowane (245)

• W skrócie (245)
  
  • Użycie modułów Perla (245)
• Zagadnienia (251)
  
  • Term::Cap - obsługa terminala (251)
  • Math: duże liczby i liczby urojone (251)
  • POSIX: Przenośny interfejs dostępu do systemu operacyjnego (252)
  • Benchmark: testy wydajności (253)
  • Time: czas i jego przeliczanie (253)
  • Carp: zgłaszanie błędów z punktu widzenia wywołującego (253)
  • locale: ustawienia lokalne (254)
  • File: operacje plikowe (254)
  • Net: dostęp do Internetu (254)
  • Safe: bezpieczne wykonywanie kodu (255)
  • Tk: zestaw narzędzi Tk (255)
  • Tk: przycisk i pole tekstowe (255)
  • Tk: przyciski radio i pole opcji (256)
  • Tk: lista wyboru (256)
  • Tk: suwak (257)
  • Tk: płótno (257)
  • Tk: menu (258)
  • Tk: Okienka dialogowe (259)

Rozdział 14. Struktury danych (261)

• W skrócie (261)
  
  • Żądanie deklarowania zmiennych? Świetny pomysł! (264)
• Zagadnienia (264)
  
  • Złożone rekordy: zapisywanie wskaźników i innych elementów (264)
  • Deklarowanie tablic tablic (265)
  • Tworzenie tablic tablic na bieżąco (266)
  • Sięganie do tablic tablic (267)
  • Deklarowanie asocjacji asocjacji (268)
  • Tworzenie asocjacji asocjacji na bieżąco (268)
  • Sięganie do asocjacji asocjacji (269)
  • Deklarowanie tablic asocjacji (270)
  • Tworzenie tablic asocjacji na bieżąco (270)
• Sięganie do tablic asocjacji (271)
  
  • Deklarowanie asocjacji tablic (272)
  • Tworzenie asocjacji tablic na bieżąco (272)
  • Sięganie do asocjacji tablic (272)
  • Listy powiązanych wartości i bufory pierścieniowe (273)

Rozdział 15. Tworzenie pakietów i modułów (275)

• W skrócie (275)
  
  • Pakiety (275)
  • Moduły (277)
• Zagadnienia (277)
  
  • Tworzenie pakietu (277)
  • BEGIN - konstruktor pakietu (279)
  • END - destruktor pakietu (279)
  • Określanie bieżącego pakietu (280)
  • Pakiet w wielu plikach (280)
  • Tworzenie modułów (281)
  • Domyślne eksportowanie symboli z modułów (281)
  • Udostępnianie symboli z modułu do eksportu (282)
  • Blokowanie importowania symboli (283)
  • Blokowanie eksportowania symboli (283)
  • Eksportowanie bez metody import (284)
  • Submoduły zagnieżdżone (284)
  • Sprawdzanie numeru wersji modułu (285)
  • Automatyczne ładowanie procedur (286)
  • AutoLoader i SelfLoader (287)

Rozdział 16. Klasy i obiekty (289)

• W skrócie (289)
  
  • Klasy (290)
  • Obiekty (290)
  • Metody (291)
  • Dziedziczenie (291)
• Zagadnienia (292)
  
  • Tworzenie klasy (292)
  • Tworzenie konstruktora (292)
  • Tworzenie obiektu (292)
  • Tworzenie metody klasy (293)
  • Tworzenie instancji metody (293)
  • Wywoływanie metody (294)
  • Tworzenie zmiennej instancji (294)
  • Tworzenie metod i zmiennych prywatnych (295)
  • Tworzenie zmiennej klasy (296)
  • Tworzenie destruktora (296)
  • Dziedziczenie klas (297)
  • Dziedziczenie konstruktorów (298)
  • Dziedziczenie zmiennych instancji (299)
  • Dziedziczenie wielokrotne (299)
  • Przykrywanie metod klasy bazowej (300)
  • Wiązanie skalarów (301)
  • Wiązanie tablic (302)
  • Wiązanie asocjacji (303)
  • Użycie klasy UNIVERSAL (303)

Rozdział 17. Usuwanie błędów z kodu Perla. Wytyczne dla programistów (305)

• W skrócie (305)
  
  • Przykładowa sesja usuwania błędów (306)
• Zagadnienia (307)
  
  • Przechwytywanie błędów wykonania (307)
  • Uruchamianie debuggera (308)
  • Dostępne polecenia debuggera (308)
  • Prezentacja kodu (309)
  • Praca "krok po kroku" (310)
  • Przeskakiwanie wywołań procedur (310)
  • Ustawianie punktów kontrolnych (311)
  • Usuwanie punktów kontrolnych (311)
  • Wykonywanie kodu do punktu kontrolnego (312)
  • Wyświetlanie wyrażenia (312)
  • Wyliczanie wartości wyrażenia (312)
  • Zmiana wartości zmiennych (312)
  • Ustawianie podglądu (313)
  • Realizacja zadań debuggera (313)
  • Kończenie pracy z debuggerem (314)
  • Wytyczne dla programistów Perla (314)

Część IV Programowanie CGI (317)

Rozdział 18. Programowanie CGI (319)

• W skrócie (319)
  
  • Użycie CGI.pm (320)
  • Tworzenie i używanie elementów graficznych HTML (321)
• Zagadnienia (326)
  
  • Użycie PerlScriptu (326)
  • Początek dokumentu HTML w CGI (327)
  • Tworzenie nagłówków HTML (327)
  • Wyśrodkowanie elementów HTML (328)
  • Tworzenie list HTML (328)
  • Tworzenie hiperłączy (328)
  • Tworzenie poziomej linii (329)
  • Tworzenie formularza HTML (329)
  • Używanie pól tekstowych (329)
  • Odczytywanie danych spod elementów graficznych HTML (330)
  • Używanie obszarów tekstowych (330)
  • Używanie pól opcji (331)
  • Używanie list wyboru (331)
  • Używanie przycisków radio (332)
  • Używanie menu (332)
  • Użycie pól ukrytych (333)
  • Tworzenie przycisków SUBMIT i RESET (333)
  • Zakończenie formularza HTML (333)
  • Zakończenie dokumentu HTML (334)
  • Programowanie CGI przy pomocy funkcji (334)

Rozdział 19. Programowanie CGI przy użyciu cgi-lib.pl (337)

• W skrócie (337)
  
  • Użycie cgi-lib.pl (339)
• Zagadnienia (342)
  
  • Jakie procedury zawiera cgi-lib.pl? (342)
  • Początek dokumentu HTML (343)
  • Tworzenie nagłówków HTML (344)
  • Wyśrodkowanie elementów HTML (344)
  • Tworzenie list HTML (344)
  • Tworzenie hiperłączy (344)
  • Tworzenie poziomej linii (345)
  • Tworzenie formularza HTML (345)
  • Używanie pól tekstowych (345)
  • Odczytywanie danych spod elementów graficznych HTML (346)
  • Używanie obszarów tekstowych (346)
  • Używanie pól opcji (346)
  • Używanie list wyboru (347)
  • Używanie przycisków radio (348)
  • Używanie menu (348)
  • Użycie pól ukrytych (349)
  • Tworzenie przycisków SUBMIT i RESET (349)
  • Zakończenie formularza HTML (349)
  • Zakończenie dokumentu HTML (349)
  • Wyświetlanie wszystkich zmiennych (350)

Rozdział 20. CGI: liczniki odwiedzin, księga gości, wysyłanie listów, kwestie bezpieczeństwa (351)

• W skrócie (351)
  
  • Bezpieczeństwo CGI (352)
• Zagadnienia (352)
  
  • Bezpieczeństwo na poważnie (352)
  • Użycie błędnych danych (354)
  • Korygowanie danych (355)
  • Zwiększanie uprawnień skryptu CGI w systemie UNIX (356)
  • Tworzenie licznika odwiedzin (356)
  • Tworzenie księgi gości (357)
  • Użycie skryptów CGI do wysyłania poczty (362)

Rozdział 21. Pogawędki (chat), cookies i gry (367)

• W skrócie (367)
  
  • Aplikacje do pogawędek (367)
  • Cookies (368)
  • Gra (368)
• Zagadnienia (368)
  
  • Aplikacja do pogawędek (368)
  • Zapisywanie i odczytywanie cookies (374)
  • Tworzymy grę (377)

Dodatki (385)

Dodatek A Przewodnik (387)

• Wartość prawdy - true (387)
  
• Wyróżniki przedrostkowe zmiennych (387)
  
• Zmienne skalarne (388)
  
• Listy (388)
  
• Kontekst skalarny a kontekst listowy (388)
  
• Tablice (389)
  
• Asocjacje (389)
  
• Typy ogólne (390)
  
• Operatory (390)
  
• Przypisywanie wartości (390)
  
• Operatory porównania (390)
  
• Operatory równości (391)
  
• Instrukcja if (393)
  
• Instrukcja unless (393)
  
• Instrukcja for (393)
  
• Instrukcja foreach (393)
  
• Instrukcja while (394)
  
• Użycie pętli until (394)
  
• Modyfikowanie instrukcji za pomocą fraz if, unless, until i while (394)
  
• Instrukcje pętli (394)
  
• Instrukcja goto (395)
  
• Procedury (395)
  
• Odczyt parametrów przekazanych procedurze (396)
  
• Zwracanie wartości z procedur (396)
  
• Wskaźniki (396)
  
• Dereferencja wskaźników (397)
  
• Zmienne wbudowane (397)
  
• Pakiety (398)

Skorowidz (399)