JavaScript_mocne_strony_jscmoc.pdf

(332 KB) Pobierz
JavaScript - mocne strony
Autor: Douglas Crockford
ISBN: 978-83-246-1998-6
Tytu³ orygina³u:
JavaScript: The Good Parts
Format: 168x237, stron: 160
Poznaj doskona³¹ u¿ytecznoœæ jêzyka JavaScript!
•
Jak efektywnie wykorzystaæ najlepsze funkcje JavaScript?
•
Jak pisaæ programy, aby ustrzec siê b³êdów?
•
Jak zdefiniowaæ podzbiór jêzyka i tworzyæ idealne aplikacje?
Warto poznaæ jêzyk JavaScript, poniewa¿ stanowi on jedno z wa¿niejszych narzêdzi
w informatyce — dziêki temu, ¿e jest jednoczeœnie podstawowym i domyœlnym jêzykiem
przegl¹darek internetowych oraz jêzykiem programowania. JavaScript pozwala na
tworzenie wydajnego kodu bibliotek obiektowych czy aplikacji opartych na technice
AJAX. Jego skrypty s³u¿¹ najczêœciej do zapewniania interaktywnoœci, sprawdzania
poprawnoœci formularzy oraz budowania elementów nawigacyjnych. Doœæ ³atwa
sk³adnia sprawia, ¿e pisanie pe³noprawnych i wydajnych aplikacji w tym jêzyku nie jest
trudne nawet dla pocz¹tkuj¹cych programistów.
Ksi¹¿ka „JavaScript — mocne strony” to wyj¹tkowy podrêcznik do nauki tego
popularnego, dynamicznego jêzyka programowania. Dowiesz siê z niej, jak efektywnie
wykorzystaæ wszystkie jego mocne strony (m.in. funkcje, dynamiczne obiekty, litera³y
obiektowe) oraz jak unikaæ pu³apek. Poznasz elementy sk³adowe jêzyka oraz sposoby
ich ³¹czenia, zrozumiesz, na czym polega dziedziczenie prototypowe, w jaki sposób
brak kontroli typów ma pozytywny wp³yw na pisanie aplikacji oraz dlaczego stosowanie
zmiennych globalnych jako podstawowego modelu programowania nie jest dobrym
pomys³em. Znaj¹c wszelkie ograniczenia jêzyka JavaScript, bêdziesz móg³
profesjonalnie wykorzystaæ jego najlepsze czêœci.
•
Gramatyka jêzyka JavaScript
•
Obiekty i funkcje
•
Rekurencja
•
Kaskadowe ³¹czenie wywo³añ
•
Litera³y obiektowe
•
Dziedziczenie — pseudoklasyczne, prototypowe, funkcyjne
•
Tablice
•
Wyra¿enia regularne
•
Klasa znaków i kwantyfikator wyra¿enia regularnego
Nie traæ czasu — siêgaj tylko po to, co najlepsze w jêzyku JavaScript!
Spis treści
Wstęp ........................................................................................................................................9
1. Mocne strony ................................................................................................................11
Dlaczego JavaScript?
Analizując JavaScript
Prosta platforma testowa
12
12
14
2. Gramatyka ................................................................................................................... 15
Białe znaki
Nazwy
Liczby
Łańcuchy
znakowe
Instrukcje
Wyrażenia
Literały
Funkcje
15
16
17
18
20
24
27
28
3. Obiekty .........................................................................................................................29
Literały obiektowe
Pobieranie
Modyfikacja
Referencja
Prototyp
Refleksja
Wyliczanie
Usuwanie
Ograniczanie liczby zmiennych globalnych
29
30
30
31
31
32
32
33
33
4. Funkcje .........................................................................................................................35
Obiekty funkcji
Literał funkcji
Wywołanie
Argumenty
35
36
36
39
5
Powrót z funkcji
Wyjątki
Rozszerzanie typów
Rekurencja
Zasięg
Domknięcia
Wywołania zwrotne
Moduł
Kaskadowe
łączenie
wywołań
Funkcja curry
Spamiętywanie
40
40
41
42
43
44
47
47
49
50
51
5. Dziedziczenie ...............................................................................................................53
Dziedziczenie pseudoklasyczne
Określenia obiektów
Dziedziczenie prototypowe
Dziedziczenie funkcyjne
Części
53
56
56
58
61
6. Tablice ..........................................................................................................................63
Literały tablicowe
Długość tablicy
Usuwanie elementów
Wyliczanie
Problem z rozpoznawaniem typu
Metody
Wymiary
63
64
65
65
65
66
67
7. Wyrażenia regularne ...................................................................................................69
Przykład
Tworzenie
Elementy
70
74
75
8. Metody ......................................................................................................................... 81
9. Styl ................................................................................................................................ 97
10. Najpiękniejsze cechy języka .......................................................................................101
6
|
Spis treści
Dodatek A Kłopotliwe cechy języka .................................................................................... 105
Dodatek B Nietrafione cechy języka .....................................................................................113
Dodatek C JSLint ....................................................................................................................119
Dodatek D Diagramy składni ............................................................................................... 129
Dodatek E JSON .................................................................................................................... 139
Skorowidz ............................................................................................................................. 149
Spis treści
|
7
ROZDZIAŁ 5.
Dziedziczenie
Dziedziczenie jest ważnym zagadnieniem w większości języków programowania.
W językach klasycznych (takich jak Java) dziedziczenie ma dwa główne zadania. Po pierwsze,
jest formą wielokrotnego użycia kodu. Jeśli nowa klasa jest podobna do istniejącej, wystarczy
określić dzielące je różnice. Ponowne wykorzystanie kodu jest ważne, ponieważ pozwala zmniej-
szyć koszty wytwarzania oprogramowania. Drugą zaletą dziedziczenia jest to,
że
zawiera ono
w sobie specyfikację systemu typów. Uwalnia to programistów w dużej mierze od konieczności
rzutowania z jednego typu na drugi, co jest istotną zaletą, ponieważ rzutowanie podważa
całą wartość bezpieczeństwa systemu typów.
JavaScript, jako język bez kontroli typów, nigdy nie wymaga rzutowania. Hierarchia dziedzi-
czenia obiektu nie ma tu znaczenia. Ważne jest, co obiekty potrafią robić, a nie po czym
dziedziczą.
JavaScript posiada dużo bogatszy zasób możliwości ponownego wykorzystania kodu. Może
naśladować klasyczne wzorce, ale dostarcza również innych, bardziej ekspresyjnych. Zbiór
możliwych wzorców dziedziczenia w JavaScripcie jest bardzo szeroki. W tym rozdziale przyj-
rzymy się kilku najprostszym przypadkom. Dużo bardziej skomplikowane są również moż-
liwe, ale zazwyczaj lepiej jest trzymać się tych najprostszych.
W klasycznych językach obiekty są instancjami klas, a klasa może dziedziczyć po innej klasie.
JavaScript jest językiem prototypowym, co oznacza,
że
obiekty dziedziczą bezpośrednio z in-
nych obiektów.
Dziedziczenie pseudoklasyczne
Język JavaScript ma wewnętrznie głęboko rozdartą naturę. Jego mechanizm prototypowy jest
zaciemniany przez niektóre skomplikowane elementy składni, które wyglądają bardziej kla-
sycznie. Zamiast pozwolić obiektom dziedziczyć bezpośrednio z innych obiektów, JavaScript
wprowadza niepotrzebny poziom abstrakcji, w którym obiekty tworzone są przy użyciu
funkcji konstruktorów.
Kiedy tworzony jest obiekt funkcji, konstruktor
Function
zwracający obiekt funkcji wykonuje
kod podobny do poniższego:
this.prototype = {constructor: this};
53

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin