W tym artykule dowiesz się, jak definiować stałe w JavaScript za pomocą słowa kluczowego const.

ES6 zapewnia nowy sposób deklaracje stałych przy użyciu słowa kluczowego const. Słowo kluczowe const tworzy odwołanie tylko do odczytu do wartości.

Stała NAZWA ZMIENNEJ = wartość;

Zgodnie z konwencją, stałe identyfikatory w JavaScript są pisane wielkimi literami.

Słowo kluczowe const jest podobne do słowa kluczowego let w tym sensie, że tworzy zmienne o zasięgu blokowym, ale wartości zadeklarowanych za pomocą const nie można zmienić.

Zmienne zadeklarowane za pomocą słowa kluczowego let są modyfikowalne. Oznacza to, że w każdej chwili możesz zmienić ich wartości, jak pokazano w poniższym przykładzie.

Niech v = 10;
v = 20;
v = v + 5;
konsola.log(v); // 35

Jednakże zmienne utworzone za pomocą słowa kluczowego const są niezmienne. Innymi słowy, nie można ich ponownie przypisać różne znaczenia. Próba ponownego przypisania stałej zmiennej zakończy się błędem TypeError.

Stały PODATEK = 0,1;
PODATEK = 0,2; //Błąd typu

Ponadto zmienna zadeklarowana przy użyciu słowa kluczowego const musi zostać natychmiast zainicjowana wartością. Poniższy przykład zgłasza błąd SyntaxError z powodu braku inicjatora w deklaracji zmiennej stałej.

Stała CZERWONA; // Błąd składni

Jak wspomniano wcześniej, podobnie jak zmienne zadeklarowane za pomocą słowa kluczowego let, zmienne zadeklarowane za pomocą słowa kluczowego const mają zasięg blokowy.

To wszystko, w następnym artykule porozmawiamy o używaniu słowa kluczowego const z literałami obiektowymi w JavaScript.

Zmienne i stałe w JavaScript. Deklarowanie zmiennych i przypisywanie im wartości. Zmienne globalne i lokalne. Używanie stałych

Deklarowanie zmiennych w JavaScript

Nazwy zmiennych w JavaScript mogą składać się z liter, cyfr, znaku $ i znaku _, a nazwa zmiennej nie może zaczynać się od cyfry. Należy pamiętać, że w JavaScript rozróżniana jest wielkość liter, a zmienne a1 i A1 to różne zmienne. Nie zaleca się używania cyrylicy, chociaż jest to możliwe.
Zmienne w JavaScript deklaruje się za pomocą słowa kluczowego var:

Var Peremennaya_1 var Peremennaya_2

Nie zaleca się używania zmiennych w JavaScript bez deklaracji. Jest to możliwe, ale może prowadzić do błędów.

Przypisywanie wartości zmiennym

Przypisywanie wartości do zadeklarowanych zmiennych w JavaScript:

Peremennaya_1 = 25 Peremennaya_2 = "Przypisany tekst jest ujęty w cudzysłów prosty"

Możesz przypisać wartość do zmiennych natychmiast po deklaracji:

Var Peremennaya_1 = 25 var Peremennaya_2 = "Przypisany tekst jest ujęty w cudzysłów prosty"

Wartość zmiennej w JavaScript może ulec zmianie podczas wykonywania programu. Podczas zapisywania tekstu do zmiennej należy go ująć w cudzysłów prosty.

Zmienne lokalne i globalne

Jeśli zmienna jest zadeklarowana wewnątrz funkcji, to jest ona lokalna i będzie dostępna (widoczna) tylko w ramach tej funkcji. Kiedy funkcja kończy się, zmienne lokalne w JavaScript są niszczone, dzięki czemu można używać zmiennych o tej samej nazwie w różnych funkcjach.

Jeśli zmienna jest zadeklarowana poza funkcjami, to ma ona charakter globalny i będzie dostępna (widoczna) we wszystkich funkcjach w obrębie strony. Zmienne globalne są niszczone w JavaScript po zamknięciu strony.

Stałe w JavaScript

Stałe mają na celu ułatwienie pracy z kodem, gdy trzeba użyć powtarzających się wartości lub wyrażeń. Wystarczy raz ustawić wartość stałej i można jej używać do woli, wstawiając ją do kodu swoich programów. JavaScript nie ma słowa kluczowego do deklarowania stałych; zamiast stałych używane są zwykłe zmienne. Aby odróżnić stałe od zmiennych, zwykle się je oznacza wielkimi literami, używając podkreślenia, jeśli to konieczne:

Var DRUG_CHELOVEKA = "Pies"

Podany przykład stałej nie jest całkowicie kompletny, gdyż słowo „Pies” jest już łatwe do zapamiętania i wstawienia tam, gdzie jest to potrzebne. Możesz używać stałych w JavaScript do rejestrowania i wstawiania bardziej złożonych wartości, na przykład trudnych do zapamiętania kodów, zestawów znaków, długiego tekstu, adresów internetowych, adresów E-mail, numer telefonu, różne współczynniki.

W JavaScript stałe można przepisać jako zmienne, ale jeśli to zrobisz, znaczenie stałych zostanie utracone.

Funkcja to blok kodu, który wykonuje akcję lub zwraca wartość. Funkcje to niestandardowy kod, który można ponownie wykorzystać; Dlatego dzięki funkcjom programy stają się modułowe i bardziej produktywne.

W tym samouczku przedstawiono kilka sposobów definiowania i wywoływania funkcji oraz używania parametrów funkcji w języku JavaScript.

Definicja funkcji

Funkcje definiuje się lub deklaruje za pomocą słowa kluczowego Function. Składnia funkcji w JavaScript wygląda następująco:

nazwa funkcji() (
// Kod do wykonania
}

Deklaracja funkcji rozpoczyna się od słowa kluczowego funkcja, po którym następuje nazwa funkcji. Nazwy funkcji podlegają tym samym zasadom, co nazwy zmiennych: mogą zawierać litery, cyfry, znaki podkreślenia i znaki dolara i często są pisane wielką literą. Po nazwie następuje zestaw nawiasów, których można użyć w przypadku parametrów opcjonalnych. Kod funkcji jest zawarty w nawiasach klamrowych, jak instrukcja for lub if.

Jak być może zauważyłeś, wartość parametru name nie jest przypisana w kodzie; ma to miejsce podczas wywołania funkcji. Podczas wywoływania funkcji jako argument przekazywana jest nazwa użytkownika. Argumentem jest faktyczna wartość przekazywana do funkcji (w tym przypadku nazwa użytkownika, na przykład 8host).

// Wywołaj funkcję powitania z argumentem „8host”.
pozdrawiam("8host");

Wartość 8host jest przekazywana do funkcji poprzez parametr name. Teraz parametr name będzie reprezentował tę wartość w tej funkcji. Kod pliku greetUser.js wygląda następująco:

// Zainicjuj niestandardową funkcję powitania
funkcja powitaj(imię) (
console.log(`Witaj, $(nazwa)!`);
}
// Wywołaj funkcję powitania z argumentem „8host”.
pozdrawiam("8host");

Po uruchomieniu tego programu otrzymasz następujące dane wyjściowe:

Teraz wiesz, jak ponownie użyć funkcji.

Oprócz parametrów wewnątrz funkcji można deklarować zmienne. Zmienne te nazywane są lokalnymi i istnieją tylko w obrębie swojego bloku funkcyjnego. Zasięg zmiennej określa dostępność zmiennych; Zmienne zdefiniowane wewnątrz funkcji nie są dostępne spoza funkcji, ale można ich używać tyle razy, ile funkcja, do której należą, jest używana w programie.

Zwracanie wartości

W funkcji można użyć więcej niż jednego parametru. Możesz przekazać wiele wartości do funkcji i zwrócić wartość. Na przykład utwórz plik sum.js i zadeklaruj w nim funkcję, która znajdzie sumę dwóch wartości x i y.

// Zainicjuj funkcję dodawania
funkcja dodaj(x, y) (
zwróć x + y;
}

dodaj(9, 7);

Ten kod definiuje funkcję z parametrami x i y. Funkcja pobiera wtedy wartości 9 i 7. Uruchom program:

Program doda otrzymane wartości 9 i 7 i zwróci wynik 16.

W przypadku użycia słowa kluczowego return funkcja przestaje działać i zwraca wartość wyrażenia. W takim przypadku przeglądarka wyświetli wartość w konsoli, ale nie jest to to samo, co użycie console.log() do wyprowadzenia danych do konsoli. Po wywołaniu funkcja zwraca wartość do miejsca, z którego została wywołana. Wartość ta może zostać użyta lub umieszczona w zmiennej.

Wyrażenia funkcyjne

W poprzedniej sekcji zadeklarowałeś funkcję, która dodaje dwie liczby i zwraca wartość wynikową. Można także utworzyć wyrażenie funkcyjne, przypisując funkcję do zmiennej.

Użyj poprzedniej funkcji, aby zastosować wynikową wartość do zmiennej sumy.

// Przypisz funkcję dodawania do stałej sumy
const suma = funkcja add(x, y) (
zwróć x + y;
}
// Wywołaj funkcję, aby znaleźć sumę
suma(20, 5);
25

Teraz suma stała jest funkcją. Wyrażenie to można skrócić zamieniając je w funkcję anonimową (tak nazywa się funkcje bez parametru name). Obecnie funkcja nazywa się add, ale w wyrażeniach funkcyjnych nazwa jest zwykle pomijana.

// Przypisz funkcję do stałej sumy
suma stała = funkcja (x, y) (
zwróć x + y;
}
// Wywołaj funkcję, aby znaleźć sumę
suma(100, 3);
103

Teraz funkcja nie ma już nazwy, stała się anonimowa.

Do debugowania można używać nazwanych wyrażeń funkcyjnych.

Funkcje strzałek

Do tej pory funkcje definiowano za pomocą słowa kluczowego Function. Istnieje jednak nowszy i skondensowany sposób definicje funkcji to funkcje strzałkowe ECMAScript 6. Funkcje strzałkowe są reprezentowane przez znak równości, po którym następuje znak większości: =>.

Funkcje strzałkowe są zawsze anonimowe i stanowią rodzaj wyrażenia funkcyjnego. Spróbuj utworzyć podstawową funkcję strzałkową, aby znaleźć sumę dwóch liczb.

// Zdefiniuj funkcję mnożenia
stała mnożenia = (x, y) => (
zwróć x * y;
}

pomnóż (30, 4);
120

Zamiast pisać funkcję, możesz po prostu użyć symboli =>.

Jeżeli funkcja ma tylko jeden parametr, nawiasy można pominąć. W poniższym przykładzie funkcja podnosi x do kwadratu, więc jako argument potrzebuje tylko jednej liczby.

// Zdefiniuj funkcję kwadratową
stała kwadratowa = x => (
zwróć x * x;
}
// Wywołaj funkcję, aby znaleźć produkt
kwadrat(8);
64

Uwaga: Jeżeli funkcja strzałkowa nie ma parametrów, należy dodać puste nawiasy ().

Funkcje strzałkowe składające się wyłącznie z instrukcji return można skrócić. Jeżeli funkcja składa się tylko z jednej linii powrotu, można pominąć nawiasy klamrowe i instrukcję return, jak w przykładzie poniżej.

// Zdefiniuj funkcję kwadratową
stała kwadratowa = x => x * x;
// Wywołaj funkcję, aby znaleźć produkt
kwadrat(10);
100

Wniosek

W tym samouczku przedstawiono deklarowanie funkcji, wyrażeń funkcyjnych i funkcji strzałkowych, zwracanie wartości i przypisywanie wartości funkcji do zmiennych.

Funkcja to blok kodu, który zwraca wartość lub wykonuje akcję.

Tagi:

Kiedy program musi zapisać wartość, aby móc jej później użyć, wartość ta jest przypisywana do zmiennej. Zmienna to po prostu symboliczna nazwa wartości, która umożliwia uzyskanie wartości według nazwy, co oznacza, że ​​gdy program określi nazwę zmiennej, wartość ją podstawi.

Zmienna ma swoją nazwę ze względu na fakt, że jej wartość można zmieniać w trakcie wykonywania programu.

Stałe

Stała to po prostu symboliczna nazwa wartości. Stała umożliwia odwoływanie się do wartości po nazwie, co oznacza, że ​​gdy program podaje nazwę stałej, zamiast niej podstawiana jest ta wartość. Stałe służą do przechowywania danych, które nie powinny ulegać zmianie podczas wykonywania programu.

Zanim będzie można użyć stałej, należy ją zadeklarować. Stałe deklaruje się za pomocą słowa kluczowego const, po którym następuje nazwa stałej. W celu odróżnienia stałych od zmiennych w kodzie programu zdecydowano się na nadawanie nazw stałych pisanych wielkimi literami:

Stała MAKS = 10;

Po utworzeniu stałej próba ponownego zdefiniowania jej do zmiennej lub próba przypisania wartości do istniejącej stałej spowoduje błąd.

Dlaczego potrzebne są zmienne i stałe?

Zmienne i stałe pomagają uczynić kod programu bardziej przejrzystym. Spójrzmy na mały przykład:

Cena całkowita = 2,42 + 4,33; // Cena całkowita

Liczby mogą tu oznaczać wszystko. Aby było jasne, co dokładnie jest tutaj podsumowywane, wartość 2,42 można przypisać zmiennej (lub stałej) candyPrice (cenie cukierka), a 4,33 zmiennej (lub stałej) OilPrice (cenie ropy):

Cena całkowita = cena cukierka + cena oleju;

Teraz zamiast pamiętać co oznaczają te wartości, widać, że skrypt podlicza cenę cukierka do ceny masła.

Ponadto zmienne i stałe pomagają zaoszczędzić czas podczas debugowania skryptu. Zamiast używać wszędzie tego samego literału, możesz przypisać go do zmiennej (lub stałej) na początku skryptu, a następnie używać tej zmiennej (lub stałej) zamiast literału w pozostałej części kodu skryptu. Jeżeli później zostanie podjęta decyzja o zmianie wartości, to zmiany w kodzie trzeba będzie dokonać nie w kilku miejscach, a tylko w jednym - tam, gdzie wartość została przypisana do zmiennej (lub stałej).

Zakres stałych

Do stałych obowiązują te same zasady, co do zmiennych zadeklarowanych za pomocą słowa kluczowego let:

Stała MAKS = 5; // Stała globalna( const MAX = 10; // Blokuj stałą console.log(MAX); // 10 ) console.log(MAX); // 5 foo(); // 15 console.log(MAX); // 5 funkcji foo() ( const MAX = 15; // Stała lokalna console.log(MAX); )

Stałe i typy referencyjne

Gdy stałej zostanie przypisana wartość typu referencyjnego, odniesienie do wartości staje się niezmienne, a sama wartość pozostaje zmienna:

Stały obj = (a: 5); obj.a = 10; konsola.log(obj.a); // 10

Jest to zbiór konwencji i zasad, których należy przestrzegać podczas pisania kodu JavaScript. Niniejsza umowa opiera się na dokumentach firmy Sun Corporation dotyczących języka programowania Java. Ponieważ jednak JavaScript nie jest językiem Java, dokument został przepisany w odniesieniu do języka JavaScript.

Wartość długoterminowa oprogramowanie, zależy bezpośrednio od jakości kodu. W czasie swojego istnienia program przechodzi przez ogromną liczbę rąk i oczu programistów. Jeśli kod programu jest napisany w taki sposób, że może jasno przekazać jego strukturę i cechy, wówczas prawdopodobieństwo jego złamania jest zmniejszone, jeśli po długim czasie wprowadzane są w nim zmiany przez innych programistów lub przez samego autora.

Porozumienia dot kod programu, może pomóc poprawić jakość produktów wyjściowych i zmniejszyć prawdopodobieństwo awarii produktu.

Pliki JavaScript

Programy JavaScript muszą być przechowywane w plikach .js.

Nie należy osadzać kodu JavaScript Pliki HTML, jeśli kod nie jest specyficzny dla jednej sesji. Kod HTML znacząco zwiększa wagę strony bez możliwości jej zmniejszenia poprzez buforowanie i kompresję.

znaczniki należy w miarę możliwości umieszczać na końcu dokumentu. Zmniejsza to opóźnienia podczas ładowania stron HTML.

Wcięcia

Wcięcie powinno wynosić cztery spacje. Dlatego, aby napisać kod, musisz skonfigurować swój edytor tak, aby zakładki zawierały dokładnie tę kwotę. Użycie tak dużej liczby znaków może mieć wpływ na rozmiar pliku, ale problem ten można rozwiązać, kompresując plik przed uruchomieniem produktu.

Długość linii

Unikaj linii dłuższych niż 80 znaków. Jeśli zestawienie nie mieści się w jednym wierszu, należy je przenieść lub podzielić. Podczas łamania linii następna linia musi być wcięta o 8 spacji od początku.

W odstępstwie od umowy, podane nowoczesne monitory i rozdzielczościach długość linii można zwiększyć do 120 znaków. Nowoczesne edytory kodu podkreślają tę linię, na przykład NetBeans, PHPStorm, i można regulować jej długość.

Uwagi

Należy starać się w pełni opisać złożone sekcje kodu. Programiści, którzy spojrzą na Twój kod lub Ty sam po pewnym czasie, powinni zrozumieć, co ten kod robi. Komentarze muszą być dobrze napisane, jasne, poprawne; jeśli komentarz nie jest wystarczająco kompletny, albo co gorsza, jest błędny, co może wprowadzić programistę w błąd, w takim przypadku lepiej nie pisać komentarza w ogóle.

Ponadto komentarze nie powinny opisywać rzeczy oczywistych, w przeciwnym razie zmarnują tylko czas czytelnika.

ja = 0; // Ustaw i na zero.

Kolejny z przydatne właściwości komentarze, że zapisane w określonych regułach, takich jak JSDoc, mogą zostać użyte do wygenerowania dokumentacji kodu.

Deklarowanie zmiennych

Wszystkie zmienne muszą zostać zadeklarowane, zanim będą mogły zostać użyte. JavaScript nie wymaga takich konstrukcji, ale znacznie ułatwia czytanie programu i ułatwia wykrywanie niezadeklarowanych zmiennych, które interpreter może uznać za globalne. Nigdy nie należy używać wywnioskowanych, ukrytych zmiennych globalnych; wszystkie zmienne należy deklarować wyłącznie jawnie, używając operatora var.

Konstrukcja var musi znajdować się na pierwszym miejscu w treści funkcji.

Zaleca się, aby każda zmienna była opisana w nowej linii i mogła zostać dodana z komentarzem. Jeśli to możliwe, najlepiej jest zachować deklaracje zmiennych w kolejności alfabetycznej.

Var currentEntry, // aktualnie wybrany poziom wpisu tabeli, // rozmiar poziomu wcięcia; // rozmiar tabeli

JavaScript nie posiada bloku deklaracji zmiennych, tak jak języki takie jak Pascal, jednak aby zachować porządek w kodzie, najlepiej zadeklarować zmienne na początku funkcji.

Użycie zmiennych globalnych powinno być ograniczone do minimum, a niejawna deklaracja zmiennych globalnych nie powinna być w ogóle stosowana.

Deklaracja funkcji

Wszystkie funkcje muszą zostać zadeklarowane przed ich użyciem. Funkcje wewnętrzne można zadeklarować za pomocą var. Pomaga to wyjaśnić, które zmienne wchodzą w zakres funkcji.

Pomiędzy nazwą funkcji a nawiasem otwierającym listę parametrów nie powinno być spacji. Pomiędzy nawiasem zamykającym a nawiasem klamrowym treści funkcji musi znajdować się spacja. Sama treść funkcji musi być wcięta czterema spacjami. Prawidłowy klamra sama funkcja musi być wyrównana z linią zawierającą deklarację funkcji.

Funkcja zewnętrzna(c, d) ( var e = c * d; funkcja wewnętrzna(a, b) ( powrót (e * a) + b; ) powrót wewnętrzna(0, 1); )

Jeśli funkcja literałowa jest anonimowa, pomiędzy słowem funkcja a nawiasem otwierającym listę parametrów musi znajdować się spacja. Jeśli nie ma spacji, może wystąpić zamieszanie, że nazwa funkcji jest funkcją, co może wydawać się błędem podczas odczytu kodu.

Div.onclick = funkcja (e) ( return false; ); that = ( metoda: funkcja () (zwróć this.datum; ), punkt odniesienia: 0 );

Należy również ograniczyć do minimum korzystanie z funkcji globalnych.

Gdy funkcja musi zostać wywołana natychmiast, jest ona ujęta w nawiasy. Wynikiem takiej funkcji będzie to, co funkcja zwróci, ale nie odwołanie do samej funkcji.

Kolekcja Var = (funkcja () ( var klucze = , wartości = ; return ( get: funkcja (klucz) ( var at = klucze.indexOf(klucz); if (at >= 0) ( zwracają wartości; ) ), zestaw: funkcja (klucz, wartość) ( ​​var at = klucze.indexOf(klucz); if (at = 0) ( klucze.splice(at, 1); wartości.splice(at, 1); ) ) ); )()) ;

Nazwy

Nazwy zmiennych lub funkcji mogą składać się z 26 dużych i małych znaków (A..Z, a...z), 10 cyfr (0..9) i znaku podkreślenia. Lepiej unikać używania znaków międzynarodowych, gdyż ich odczytanie i zrozumienie może przysporzyć pewnych trudności. Nie używaj $ (znaku dolara) ani (ukośnika odwrotnego) w nazwach zmiennych i funkcji.

Nie używaj znaku podkreślenia _ jako pierwszego znaku nazwy. Technika ta jest czasami używana do oznaczania lokalnych (prywatnych) zmiennych lub funkcji, ale w rzeczywistości nie czyni tych zmiennych prywatnymi. Jeśli Twój kod musi korzystać z prywatnych członków, powinieneś unikać ujawniania tych danych.

Większość zmiennych i funkcji musi zaczynać się od małej litery.

Funkcje konstruktora, które do działania używają operatora nowy musi zaczynać się od dużej litery. Podczas kompilowania skryptu JavaScript lub sprawdzania kodu za pomocą narzędzi innych firm, zostaną wyświetlone ostrzeżenia, jeśli funkcje lub nazwy zmiennych zostaną użyte bez konstrukcji nowy. Praca funkcji konstruktora, która nie korzysta z operatora nowy będą zachowywać się zupełnie inaczej, więc konwencja pisania takich funkcji wielką literą jest w pewnym stopniu zabezpieczeniem przed błędem.

Zmienne globalne, które noszą znaczenie stałych lub przestrzeni nazw, muszą być pisane wielką literą, ponieważ w JavaScript nie ma takich konstrukcji.

Operatory Operatory proste

Każdy wiersz musi zawierać co najwyżej jedno oświadczenie. Każda prosta instrukcja musi kończyć się średnikiem (;). Należy pamiętać, że instrukcja przypisania, do której przypisany jest literał funkcyjny, musi kończyć się średnikiem.

W JavaScript każde wyrażenie będzie operatorem. Może to ukryć pewne błędy, jeśli w tych instrukcjach na końcu znajduje się średnik. Na przykład może tak być zwykły ciąg ze średnikiem na końcu, co nie spowoduje żadnego błędu ani nie zepsuje skryptu.

Operatory złożone

Instrukcje złożone to instrukcje zawierające listę innych instrukcji ujętych w () (nawiasy klamrowe).

• Instrukcje w instrukcjach złożonych muszą być wcięte czterema spacjami.
• ((Lewy nawias klamrowy) musi znajdować się na końcu wiersza, w którym rozpoczyna się instrukcja złożona.
• ) (prawy nawias klamrowy) należy umieścić Nowa linia i wcięcie w celu wyrównania z początkiem linii zawierającej dopasowanie ((lewy nawias klamrowy).
• Nawiasy klamrowe powinny być stosowane wszędzie tam, gdzie jest to możliwe, jest to konieczne, aby uniknąć przypadkowych błędów i ułatwić odczytanie kodu.

Tagi

Dostępność tagów przerwa I Kontynuować w kodzie można używać tylko w konstrukcjach chwila, Do, Do I przełącznik.

oświadczenie zwrotne

Wartość instrukcji return nigdy nie powinna być ujęta w () (nawiasy). Wartość tej instrukcji musi zaczynać się w tym samym wierszu, co sama instrukcja return, aby uniknąć przypadkowego wstawienia średnika podczas interpretacji lub kompresji kodu.

jeśli stwierdzenie

Konstrukcja if powinna wyglądać następująco:

If (warunek) (instrukcje) if (warunek) (instrukcje) else (instrukcje) if (warunek) (instrukcje) else if (warunek) (instrukcje) else (instrukcje)

za oświadczenie

Instrukcja for musi mieć następującą strukturę:

For (inicjalizacja; warunek; aktualizacja) (instrukcje) for (zmienna w obiekcie) ( if (filter) (instrukcje))

Pierwsza forma notacji używana jest do pracy z tablicami i pętlami z określoną liczbą iteracji.

Druga forma jest używana podczas pracy z obiektami. Należy pamiętać, że elementy dodane do prototypu obiektu zostaną uwzględnione w wyliczeniu. W tym celu należy zastosować sprawdzenie metodą hasOwnProperty w celu rozróżnienia prawdziwych właściwości obiektu:

For (zmienna w obiekcie) ( if (obiekt.hasOwnProperty(zmienna)) ( instrukcje ) )

podczas gdy oświadczenie

Konstrukcja while powinna wyglądać następująco:

Podczas gdy (warunek) ( instrukcje )

zrób operatora

Instrukcja do powinna wyglądać następująco:

Do (instrukcje) while (warunek);

W przeciwieństwie do innych stwierdzeń złożonych, to musi zawsze się kończyć; (średnik).

instrukcja switch

Instrukcja switch powinna wyglądać następująco:

Przełącznik (wyrażenie) (wyrażenie przypadku: instrukcje domyślnie: instrukcje)

Każda gałąź case musi znajdować się w tym samym wierszu, co instrukcja switch. Pozwala to uniknąć nadmiernych wcięć.

Każda grupa instrukcji case z wyjątkiem domyślnej musi kończyć się znakiem przerwa, powrót Lub rzucić.

spróbuj oświadczenie

Instrukcja try powinna wyglądać następująco:

Try (instrukcje) catch (zmienna) (instrukcje) try (instrukcje) catch (zmienna) (instrukcje) w końcu (instrukcje)

Kontynuuj operatora

Unikaj używania instrukcjicontinue. Ta instrukcja ma tendencję do ukrywania przepływu wykonywania funkcji.

Oświadczenie z

Nie należy używać operatora With.

Przestrzenie

Puste linie poprawiają czytelność, dzieląc kod na logicznie połączone sekcje.

Spacji należy używać w następujących przypadkach:

• Słowo kluczowe, po którym następuje ((lewy nawias), musi być oddzielone spacją
  podczas gdy (prawda) (
• Nie należy wstawiać spacji pomiędzy nazwą funkcji a ((lewym nawiasem) w konstrukcji funkcji f(). Pomaga to rozróżnić słowa kluczowe i wywołanie funkcji.
• Wszystkie operatory binarne z wyjątkiem . (kropki), ((lewy nawias) i [ (lewy nawias) muszą być oddzielone spacją.
• Każdy; (średnik) w części kontrolnej klauzuli for musi być oddzielony spacją.
• Po każdym przecinku muszą być spacje.

W dużych projektach uwzględnienie wszystkich tych konwencji bez użycia narzędzi pomocniczych i edytorów kodu staje się bardzo trudne. Dlatego dla własnej kontroli istnieje potrzeba nabycia takich narzędzi.

JSLint. Narzędzie do Kontrola JavaScript kod

Język JavaScript jest językiem interpretowanym, który nie posiada własnego kompilatora, w porównaniu do języków takich jak Java, C++, które sprawdzałyby jakość napisanego kodu podczas budowania projektu lub przed jego uruchomieniem, biorąc pod uwagę różne niuanse, np. jako zadeklarowane, ale nieużywane zmienne, niezoptymalizowany kod sekcji, brakujące średniki itp. Dlatego przydałoby się narzędzie, które sprawdzi i zwróci programiście uwagę na różne błędy.

Jednym z takich narzędzi jest JSLint. JSLint to program napisany w języku JavaScript, którego zadaniem jest wyszukiwanie problemów w programach JavaScript.

Kiedy C był jeszcze młodym językiem, występowało kilka typowych błędów programistycznych, których prymitywne kompilatory nie wyłapywały, dlatego opracowano program o nazwie lint, który skanował plik źródłowy w poszukiwaniu błędów.

Kiedy język osiągnął pewien poziom doskonałości, kompilatory zaczęły go lepiej sprawdzać i wydawać odpowiednie komunikaty, po czym program lint nie był już potrzebny.

JavaScript jest młodym językiem. Pierwotnie był używany do wykonywania małych zadań na stronach internetowych, dla których Java była zbyt ciężka i nieporęczna. Obecnie, Język JavaScript odgrywa dużą rolę w Internecie i jest używany w dużych i złożonych projektach. Wiele funkcji zaimplementowanych w języku miało na celu uproszczenie go, ale gdy projekty stają się większe i bardziej złożone, istnieją powody do obaw co do takiej funkcjonalności. Dlatego programy JavaScript potrzebują narzędzia takiego jak szarpie.

JSLint beret źródło JavaScript i skanuje go. W przypadku wykrycia problemu zwracany jest komunikat z opisem i przybliżoną lokalizacją Plik źródłowy. Problemem niekoniecznie musi być błąd składniowy; przeprowadzane są również kontrole stylu i zgodności ze strukturą kodu.

Zmienne globalne

Najbardziej wielki problem w JavaScript jest to zależność od zmiennych globalnych, które zostały zadeklarowane niejawnie. Jeśli zmienna nie zostanie zadeklarowana przy użyciu konstrukcji var, to w JavaScript zmienna ta stanie się globalna, jako właściwość obiektu okno. Z tego powodu mogą wystąpić różnego rodzaju błędy.

JSLint wymaga zadeklarowania wszystkich zmiennych i funkcji przed ich użyciem lub wywołaniem. Pozwala to łatwo wykryć zmienne globalne, a także jest dobrą praktyką i ułatwia odczytanie kodu źródłowego programu.

Czasami plik zależy od zmiennych globalnych i funkcji zdefiniowanych gdzie indziej. Aby to zrobić, należy opisać takie zmienne w specjalnej dyrektywie /*global */, która wskazuje JSLintowi, że są one używane w innych plikach i nie są błędne. Zmienne w dyrektywie to lista nazw oddzielonych przecinkami. Każda nazwa może zawierać dwukropek, po którym następuje flaga prawdy lub fałszu, wskazująca, czy zmienna była przeznaczona dla tego pliku, czy nie.

Niektóre zmienne globalne mogą być już początkowo zdefiniowane. Załóżmy, że jest to przeglądarka, podczas wstępnego definiowania standardowych właściwości globalnych udostępnianych przez przeglądarkę, takich jak dokument I dodajEventListener.

/*global clearInterval: false, clearTimeout: false, dokument: false, zdarzenie: false, ramki: false, historia: false, Obraz: false, lokalizacja: false, nazwa: false, nawigator: false, Opcja: false, parent: false , ekran: fałsz, setInterval: fałsz, setTimeout: fałsz, okno: fałsz, XMLHttpRequest: fałsz */

Obejmuje konsolę, alerty i funkcje, które można globalnie przedefiniować, które można rozszerzyć lub których zaleca się unikać w produkcie końcowym.

/*alert globalny: fałsz, potwierdzenie: fałsz, konsola: fałsz, debugowanie: fałsz, opera: fałsz, monit: fałsz, WSH: fałsz */

Średnik

JavaScript używa składni podobnej do języka C, która wymaga użycia średników do oddzielania instrukcji. W JavaScript umieszczenie średnika na końcu każdej instrukcji jest opcjonalne; zamiast tego możesz użyć znaku nowego wiersza, a ten kod będzie działał w przeglądarce internetowej, ale takie podejście może powodować błędy.

JSLint oczekuje, że każda instrukcja się zakończy; (średnik), wyjątki w niektórych sytuacjach mogą dotyczyć tylko dla oświadczeń, funkcja, jeśli, przełącz, spróbuj i póki.

Przecinek

Operator przecinka może prowadzić do zbyt skomplikowanych wyrażeń, a także może maskować niektóre błędy programistyczne.

JSLint oczekuje użycia przecinka jako ogranicznika, ale nie jako instrukcji (z wyjątkiem inicjalizacji i zwiększania części instrukcji).

Obszar widoczności

W wielu językach blok określa jego zakres. Zmienne zadeklarowane w tym bloku nie są widoczne poza nim.

W JavaScript bloki nie definiują zakresu. Zakres jest zdefiniowany tylko w obrębie funkcji. Zmienna zdefiniowana w funkcji będzie widoczna w każdym miejscu tej funkcji. Bloki w JavaScript mogą w tym zakresie dezorientować doświadczonych programistów innych języków, ze względu na ich podobną składnię, co w konsekwencji może prowadzić do błędów.

W językach o zasięgu blokowym ogólnie zaleca się deklarowanie zmiennych w miejscu, w którym są bezpośrednio używane. Ponieważ jednak JavaScript nie ma zasięgu blokowego, prawidłowe jest zadeklarowanie wszystkich zmiennych na górze funkcji. Zaleca się użycie jednego operatora var na funkcję. To zalecenie można wyłączyć za pomocą opcji Vars.

Wymagane bloki

JSLint zakłada, że ​​instrukcje if, while, do i for zawierają nawiasy, niezależnie od tego, ile operatorów znajduje się w tych konstrukcjach.

JavaScript pozwala na następujący sposób pisania:

instrukcja if (warunek);

Wiadomo, że ta forma notacji wprowadza błędy do projektów. Dlatego JSLint sugeruje użycie następującej notacji:

Jeśli (warunek) ( instrukcje; )

Doświadczenie twórców pokazuje, że ta forma nagrywania jest bardziej odporna na błędy.

dla w

Pętla for in służy do wypisywania wszystkich właściwości obiektu. Ale także za pomocą tego cyklu przeglądane są absolutnie wszystkie właściwości, w tym te, które zostały odziedziczone przez prototyp. Okazuje się źle efekt uboczny, gdy otrzymamy metodę jako właściwość. Jeżeli taka pętla zostanie napisana bez świadomości tej sytuacji, to ta część kodu może spowodować błąd.

Treść pętli powinna zostać owinięta instrukcją if, która testuje właściwość obiektu w celu wykluczenia właściwości prototypu, na przykład:

For (nazwa w obiekcie) ( if (obiekt.hasOwnProperty(nazwa)) ( .... ) )

W większości przypadków należy całkowicie unikać tego operatora. Najlepiej polegać na metodach takich jak Object.keys i Array.prototype.forEach.

przełącznik

Częstym błędem w instrukcji switch jest zapominanie o umieszczeniu break po konstrukcji case. JSLint oczekuje, że każda instrukcja case zakończy się przerwą, powrotem lub rzutem. Każda konstrukcja przypadku zostanie wyrównana z instrukcją switch.

odm

JavaScript pozwala zdefiniować var ​​w dowolnym miejscu funkcji. JSLint w tym przypadku jest bardziej rygorystyczny w stosunku do takich definicji.

JSLint oczekuje, że konstrukcja var zostanie zadeklarowana tylko raz i przed jej użyciem.

JSLint odradza używanie var w nawiasach, ponieważ nie mają one własnego zakresu.

z

Konstrukcja ta pierwotnie miała zapewniać skrótowy dostęp do właściwości głęboko zagnieżdżonych obiektów. Użycie tej konstrukcji może prowadzić do pomylenia użycia zmiennych i właściwości, co może skutkować nieprzewidywalnym zachowaniem programu. Dlatego lepiej nigdy nie używać tego operatora.

== i!=

Operatory AND != wykonują rzutowanie typu przed porównaniem. Jest źle, bo różne projekty na przykład „ trn” == 0 będzie prawdą. Może to maskować błędy. JSLint nie może wiarygodnie określić, czy użycie == jest obecnie uzasadnione, dlatego zawsze lepiej jest używać porównań bez ukrytego rzutowania typów, a mianowicie === i !==.

Używając opcji eqeq, możesz wyłączyć sprawdzanie tego operatora.

++ i --

JSLint jest przeciwny używaniu tych operatorów. Możesz włączyć ich użycie za pomocą opcji plusplus.

Operacje bitowe

JavaScript nie ma typu Integer, ale ma operatory bitowe. Operatory bitowe konwertują operandy zmiennoprzecinkowe na liczby całkowite i odwrotnie, więc nie są tak wydajne jak w C lub innych językach. Rzadko są przydatne w aplikacjach przeglądarkowych. Podobieństwa z operatory logiczne może maskować pewne błędy programistyczne. Opcja bitowa pozwala na użycie tych operatorów.

Ewa jest zła

Funkcja eval (i jej krewne setTimeout i setInterval) zapewniają dostęp do kompilatora JavaScript. Czasami jest to konieczne, ale w większości przypadków wskazuje na bardzo zły styl programowania. Funkcja eval jest najczęściej używaną funkcją JavaScript.

Konstruktorzy i nowi

Konstruktory to funkcje przeznaczone do użycia z operatorem new. Ten przedrostek tworzy nowy obiekt na podstawie prototypu funkcji i kojarzy ten obiekt funkcji z przypisaną zmienną. Jeśli zaniedbasz użycie operatora new dla funkcji konstruktora, zwrócony wynik nie będzie dokładnie taki, jakiego oczekiwano.

JSLint zapewnia konwencję, że konstruktory funkcji muszą mieć nazwy, których pierwsza litera będzie duże litery, w przeciwnym razie wywołanie tej funkcji z operatorem new zostanie uznane za błąd sprawdzania poprawności.

Użycie operatora new z obiektami typu Number, String, Boolean będzie traktowane jako błąd podczas weryfikacji.

Sprawdzając taką nową konstrukcję obiektu, JSLint założy, że jest ona niepoprawna i lepiej będzie użyć skrótu - ().

Opcje

JSLint oferuje kilka opcji kontrolujących sposób działania. W aplikacji internetowej JSLint opcje wybiera się za pomocą pól wyboru i dwóch pól.

Kiedy JSLint jest wywoływany jako funkcja, pobiera parametr - obiekt opcji, który pozwala określić akceptowalny podzbiór JavaScript. Na stronie internetowej http://www.JSLint.com wersja JSLint robi to automatycznie.

Opcje można także ustawić w skrypcie za pomocą dyrektywy /*JSLint*/:

/*jslint nomen: prawda, debugowanie: prawda, zło: fałsz, vars: prawda */

Opis	Opcja	Oznaczający
Toleruj wyrażenia przypisania	tyłek	true, jeśli przypisanie powinno być dozwolone poza pozycją instrukcji.
Ignorowanie operatorów bitowych	bitowo	true , jeśli operatory bitowe nie powinny być testowane
Zezwalaj na funkcje przeglądarki	przeglądarka	prawda, brane są pod uwagę standardowe zmienne globalne przeglądarki
Zezwalaj na idiomy zamykające Google	zamknięcie	true , jeśli powinny być dozwolone adnotacje zamknięcia Google
Zezwól na kontynuację	Kontynuować	true, więc użycie countinue jest ignorowane
Propozycja CouchDB	kanapa	true, jeśli chcesz, aby funkcje CouchDB były uznawane za globalne
Zezwól na debugger	odpluskwić	true , jeśli instrukcja debug powinna być dozwolona
Zezwól na konsolę, alert	rozwijać	true , jeśli opcja przeglądarki nie jest ustawiona i te operatory muszą być dozwolone
Zezwól == i !=	równ	true if operatory == i != powinny być dozwolone
Zezwól na ewaluację	zło	true, jeśli eval powinno być dozwolone
Spacje i wcięcia	akapit	Liczba spacji używanych do wcięcia (domyślnie 4)
Maksymalna liczba błędów	maks	Maksymalna liczba ostrzeżeń w raporcie skanowania (domyślnie 50)
Maksymalna długość linii	maxlen	Maksymalna liczba znaków w linii
Używanie wielkich liter na początku słowa w nazwie konstruktora	Newcap	true, jeśli wymagane są pierwsze litery nazw funkcji konstruktora
Rozważ Node.js	węzeł	true, jeśli Node.js powinien uwzględniać zmienne globalne
Zezwalaj na myślnik _ w identyfikatorach	nomen	true , jeśli takie zmienne nie powinny być dozwolone
Zatrzymywanie się przy pierwszym błędzie	niepowodzenie	true, jeśli skanowanie powinno zostać zatrzymane przy pierwszym błędzie
Zezwól na ++ i --	plusplus	true, jeśli użycie ++ lub -- powinno być dozwolone
Zezwalaj na brak „użyj ścisłego” na początku funkcji	niechlujny	true, więc wstawienie wiersza „use strict” jest opcjonalne
Zezwalaj na komentarze TODO	do zrobienia	prawda, żeby nie reagować na komentarze TODO
Zezwalaj na nieużywane parametry	nieparam	true, nie wyświetlaj ostrzeżeń o nieużywanych parametrach
Zezwalaj na wiele zmiennych w funkcji	Vars	true, w przypadku wielokrotnego użycia var w funkcji
Zezwalaj na brudne białe znaki	biały	true , aby ignorować brudne przestrzenie