Zastosuj w pracy sprawdzone style i standardy kodowania

• Wypracuj czytelne konwencje nazewnicze
• Stwórz odpowiednią dokumentację kodu
• Przetestuj kod i usuń błędy

Indywidualne style kodowania, obejmujące m.in. nazywanie zmiennych, wpisywanie komentarzy i stosowanie określonych konstrukcji językowych, pomagają w rozbudowywaniu programów i usuwaniu z nich błędów. Jednak taka metoda pracy, charakterystyczna dla doświadczonych programistów, nie zawsze jest najlepsza. Dodatkowo własny styl staje się ogromną przeszkodą w przypadku pracy zespołowej -- tu powinno się raczej stosować spójne standardy, dzięki którym kod będzie klarowny, niezawodny, wydajny, łatwy w konserwacji i zwięzły.

W książce "Perl. Najlepsze rozwiązania" znajdziesz ponad 250 porad programisty z 22-letnią praktyką, dotyczących pisania kodu źródłowego w Perlu. Wskazówki te obejmują układ kodu, konwencje nazewnicze, dobór struktur danych i konstrukcji sterujących, dekompozycję programu, projekt i implementację interfejsu, modularność, obiektowość, obsługę błędów, testowanie i debugowanie. Autor książki nie stara się udowodnić, że preferowane przez niego rozwiązania są jedyne i najlepsze -- przedstawia jedynie sprawdzone techniki, używane przez programistów z całego świata.

• Formatowanie kodu źródłowego
• Metody określania nazw zmiennych i obiektów
• Korzystanie ze struktur sterujących
• Przygotowywanie dokumentacji
• Implementacja operacji wejścia i wyjścia
• Stosowanie wyrażeń regularnych
• Obsługa wyjątków
• Podział kodu na moduły
• Wykrywanie i usuwanie błędów z kodu

Spis treści:

Przedmowa (13)

1. Zalecane praktyki 21

• Trzy cele (22)
  
• Niniejsza książka (24)
  
• Zmiana nawyków (26)

2. Układ kodu 27

• Stosowanie nawiasów (28)
  
• Słowa kluczowe (30)
  
• Procedury i zmienne (31)
  
• Funkcje wbudowane (31)
  
• Klucze i indeksy (32)
  
• Operatory (33)
  
• Średniki (34)
  
• Przecinki (35)
  
• Długość wierszy (36)
  
• Wcięcia (37)
  
• Znaki tabulacji (38)
  
• Bloki (39)
  
• Akapity (40)
  
• Instrukcje else (41)
  
• Wyrównanie pionowe (42)
  
• Dzielenie długich wierszy (44)
  
• Wyrażenia nieterminalne (45)
  
• Dzielenie wyrażeń według priorytetu (46)
  
• Przypisania (46)
  
• Operator trójkowy (47)
  
• Listy (48)
  
• Zautomatyzowane formatowanie (49)

3. Konwencje nazewnicze 51

• Identyfikatory (52)
  
• Wartości logiczne (55)
  
• Zmienne referencyjne (56)
  
• Tablice zwykłe i asocjacyjne (57)
  
• Znaki podkreślenia (58)
  
• Wielkość liter (58)
  
• Skróty (60)
  
• Niejednoznaczne skróty (61)
  
• Niejednoznaczne nazwy (61)
  
• Procedury narzędziowe (62)

4. Wartości i wyrażenia 65

• Ograniczniki łańcuchów (65)
  
• Łańcuchy puste (67)
  
• Łańcuchy jednoznakowe (67)
  
• Znaki specjalne (68)
  
• Stałe (69)
  
• Początkowe zera (72)
  
• Długie liczby (73)
  
• Łańcuchy wielowierszowe (73)
  
• Dokumenty here (74)
  
• Wcięcia w dokumentach here (74)
  
• Terminatory dokumentów here (75)
  
• Przytaczanie terminatorów (77)
  
• Nagie słowa (77)
  
• Grube przecinki (78)
  
• Cienkie przecinki (80)
  
• Operatory o niskim priorytecie (81)
  
• Listy (82)
  
• Przynależność do listy (83)

5. Zmienne 85

• Zmienne leksykalne (85)
  
• Zmienne pakietowe (87)
  
• Lokalizowanie (89)
  
• Inicjalizacja (89)
  
• Zmienne interpunkcyjne (90)
  
• Lokalizowanie zmiennych interpunkcyjnych (92)
  
• Zmienne dopasowania (93)
  
• Dolar-znak podkreślenia (96)
  
• Indeksy tablic (98)
  
• Wycinki (99)
  
• Układ wycinków (100)
  
• Wyodrębnianie list z wycinków (101)

6. Struktury sterujące 103

• Bloki if (103)
  
• Selektory przyrostkowe (104)
  
• Inne modyfikatory przyrostkowe (105)
  
• Negatywne instrukcje sterujące (106)
  
• Pętle w stylu C (109)
  
• Niepotrzebne indeksowanie (110)
  
• Potrzebne indeksowanie (112)
  
• Zmienne iteracyjne (114)
  
• Nieleksykalne iteratory pętli (116)
  
• Generowanie list (118)
  
• Wybieranie elementów z listy (119)
  
• Transformacja listy (120)
  
• Złożone odwzorowania (121)
  
• Efekty uboczne przetwarzania list (122)
  
• Wielokrotny wybór (124)
  
• Wyszukiwanie wartości (125)
  
• Operatory trójkowe w układzie tabelarycznym (128)
  
• Pętle do...while (129)
  
• Kodowanie liniowe (131)
  
• Rozproszone sterowanie (132)
  
• Powtarzanie przebiegu pętli (134)
  
• Etykiety pętli (135)

7. Dokumentacja 139

• Typy dokumentacji (139)
  
• Szablony (140)
  
• Rozszerzone szablony (144)
  
• Miejsce (145)
  
• Ciągłość (145)
  
• Położenie (146)
  
• Dokumentacja techniczna (146)
  
• Komentarze (147)
  
• Dokumentacja algorytmiczna (148)
  
• Dokumentacja wyjaśniająca (149)
  
• Dokumentacja defensywna (149)
  
• Dokumentacja sygnalizująca (150)
  
• Dokumentacja dygresyjna (150)
  
• Korekta (152)

8. Funkcje wbudowane 153

• Sortowanie (153)
  
• Odwracanie list (156)
  
• Odwracanie skalarów (157)
  
• Dane z polami o stałej szerokości (157)
  
• Dane rozdzielone separatorami (160)
  
• Dane z polami o zmiennej szerokości (161)
  
• Ewaluacje łańcuchów (163)
  
• Automatyzacja sortowania (166)
  
• Podłańcuchy (167)
  
• Wartości tablic asocjacyjnych (168)
  
• Rozwijanie nazw plików (168)
  
• Wstrzymywanie programu (169)
  
• Funkcje map i grep (170)
  
• Funkcje narzędziowe (171)

9. Procedury 177

• Składnia wywołań (177)
  
• Homonimy (179)
  
• Listy argumentów (180)
  
• Nazwane argumenty (183)
  
• Brakujące argumenty (184)
  
• Domyślne wartości argumentów (185)
  
• Skalarne wartości zwrotne (187)
  
• Kontekstowe wartości zwrotne (188)
  
• Wielokontekstowe wartości zwrotne (191)
  
• Prototypy (194)
  
• Jawne powroty (196)
  
• Zwracanie błędów (198)

10. Wejście-wyjście 201

• Uchwyty plików (201)
  
• Pośrednie uchwyty plików (203)
  
• Lokalizowanie uchwytów plików (204)
  
• Eleganckie otwieranie (205)
  
• Sprawdzanie błędów (207)
  
• Porządkowanie (207)
  
• Pętle wejściowe (209)
  
• Wczytywanie danych wiersz po wierszu (210)
  
• Proste "zasysanie" (211)
  
• Zaawansowane "zasysanie" (212)
  
• Standardowe wejście (213)
  
• Pisanie w uchwytach plików (214)
  
• Proste monitowanie (214)
  
• Interaktywność (215)
  
• Zaawansowane monitowanie (217)
  
• Wskaźniki postępu (218)
  
• Automatyczne wskaźniki postępu (220)
  
• Automatyczne opróżnianie bufora (221)

11. Referencje 223

• Wyłuskiwanie (223)
  
• Referencje w nawiasach klamrowych (224)
  
• Referencje symboliczne (226)
  
• Referencje cykliczne (227)

12. Wyrażenia regularne 231

• Rozszerzone formatowanie (232)
  
• Granice wierszy (233)
  
• Granice łańcuchów (234)
  
• Koniec łańcucha (235)
  
• Dopasowywanie dowolnych znaków (236)
  
• Opcje dla leniwych (237)
  
• Nawiasy klamrowe jako ograniczniki w wyrażeniach regularnych (237)
  
• Inne ograniczniki (240)
  
• Metaznaki (241)
  
• Nazwy znaków (242)
  
• Właściwości (242)
  
• Odstępy (243)
  
• Nieograniczone powtórzenia (244)
  
• Nawiasy przechwytujące (246)
  
• Przechwycone wartości (246)
  
• Zmienne przechwytujące (247)
  
• Dopasowywanie po kawałku (250)
  
• Tabelaryczne wyrażenia regularne (252)
  
• Konstruowanie wyrażeń regularnych (254)
  
• Wyrażenia regularne z puszki (255)
  
• Alternacje (257)
  
• Wyodrębnianie wspólnej części alternacji (258)
  
• Wycofywanie (260)
  
• Porównywanie łańcuchów (262)

13. Obsługa błędów 265

• Wyjątki (266)
  
• Błędy funkcji wbudowanych (269)
  
• Błędy kontekstowe (270)
  
• Błędy systemowe (271)
  
• Błędy naprawialne (272)
  
• Zgłaszanie błędów (273)
  
• Komunikaty o błędach (275)
  
• Dokumentowanie błędów (276)
  
• Obiekty wyjątków (277)
  
• Ulotne komunikaty o błędach (280)
  
• Hierarchie wyjątków (280)
  
• Przetwarzanie wyjątków (281)
  
• Klasy wyjątków (282)
  
• Odpakowywanie wyjątków (285)

14. Wiersz poleceń 287

• Struktura wiersza polecenia (288)
  
• Konwencje składni wiersza polecenia (289)
  
• Metaopcje (291)
  
• Argumenty in situ (292)
  
• Przetwarzanie wiersza polecenia (293)
  
• Spójność interfejsu (298)
  
• Spójność aplikacji (301)

15. Obiekty 305

• Używanie technik obiektowych (306)
  
• Kryteria (306)
  
• Pseudotablice (308)
  
• Ograniczone tablice asocjacyjne (308)
  
• Hermetyzacja (309)
  
• Konstruktory (317)
  
• Klonowanie (317)
  
• Destruktory (320)
  
• Metody (321)
  
• Akcesory (323)
  
• Akcesory l-wartościowe (328)
  
• Pośredni dostęp do obiektów (330)
  
• Interfejsy klas (333)
  
• Przeciążanie operatorów (335)
  
• Przekształcenia typów (337)

16. Hierarchie klas 339

• Dziedziczenie (340)
  
• Obiekty (340)
  
• "Błogosławienie" obiektów (344)
  
• Argumenty konstruktora (346)
  
• Inicjalizacja klasy bazowej (349)
  
• Konstrukcja i destrukcja (353)
  
• Automatyzowanie hierarchii klas (360)
  
• Niszczenie atrybutów (360)
  
• Budowanie atrybutów (363)
  
• Konwersje typów (364)
  
• Metody kumulacyjne (365)
  
• Automatyczne wczytywanie (368)

17. Moduły 373

• Interfejsy (373)
  
• Refaktoryzacja (376)
  
• Numery wersji (379)
  
• Wymagania dotyczące wersji (380)
  
• Eksportowanie (382)
  
• Eksportowanie deklaratywne (383)
  
• Zmienne interfejsu (385)
  
• Tworzenie modułów (389)
  
• Biblioteka standardowa (390)
  
• CPAN (391)

18. Testowanie i debugowanie 393

• Przypadki testowe (393)
  
• Testowanie modularne (394)
  
• Pakiety testów (397)
  
• Błędy (398)
  
• Co testować? (398)
  
• Debugowanie i testowanie (399)
  
• Ograniczenia (401)
  
• Ostrzeżenia (403)
  
• Poprawność (404)
  
• Omijanie ograniczeń (405)
  
• Debuger (407)
  
• Debugowanie ręczne (408)
  
• Debugowanie półautomatyczne (410)

19. Zagadnienia różne 413

• Kontrola wersji (413)
  
• Inne języki (414)
  
• Pliki konfiguracyjne (416)
  
• Formaty (419)
  
• Więzy (422)
  
• Spryt (423)
  
• Ukryty spryt (424)
  
• Mierzenie wydajności (426)
  
• Pamięć (429)
  
• Buforowanie (429)
  
• Memoizacja (431)
  
• Optymalizacja przez buforowanie (432)
  
• Profilowanie (433)
  
• Zapluskwianie (435)

A Perl: kluczowe praktyki (437)

B Perl: zalecane praktyki (441)

C Konfiguracje edytorów (453)

D Zalecane moduły i narzędzia (459)

E Bibliografia (465)

Skorowidz (467)