Pierwsze kroki z Sails.js

JavaScript ewoluuje wykładniczo, nie tylko pozycjonując się jako podstawa rozwoju po stronie Front-end z pomocą różnych frameworków i technologii, ale także robiąc to dla Zaplecze, to dzięki wprowadzeniu słynnej platformy Node.js i wszystkie związane z tym korzyści.
Obecnie dysponujemy frameworkami, które pomagają nam wydajnie pracować z tymi technologiami, a jednym z nich jest Żagle.js, który jest niczym innym jak frameworkiem MVC zorientowanym na Back-End i obejmuje takie koncepcje jak REST, HTTP lub WebSockets, co pozwala nam od rozwoju interfejsów API, obsługi plików HTML po obsługę wielu żądań w naszych aplikacjach.
1- Aby wykonać ćwiczenia i przykłady zaproponowane w tym samouczku, musimy mieć instalację z najnowszą wersją Node.js. Jest to bardzo łatwe do uzyskania, w tym przypadku użyjemy instalatora Okna które dostajemy bezpośrednio na oficjalnej stronie Node.js, działa jak każdy instalator, a następnie generuje bezpośredni dostęp do konsoli Node.js gdzie możemy wykonać niezbędne skrypty. Jeśli nic nie wiemy Node.js i chcemy najpierw przyjrzeć się, zalecamy zapoznanie się z poniższym samouczkiem.
2- Potrzebujemy bogatego edytora tekstu w stylu Wzniosły tekst lub Notatnik ++ aby móc napisać niezbędny kod, aby wypełnić przykłady i ćwiczenia, które będziemy pokazywać.
3- Wreszcie potrzebujemy dostępu do Internetu, aby móc pobierać Żagle.js nawet raz.
Instalacja Żagle.js To tak proste, jak uruchomienie wiersza poleceń w naszej konsoli Node.js. Otwieramy go i korzystamy z menedżera pakietów Node.js zainstalować, wpisując:

npm -g zainstaluj żagle

Wykonujemy nasze polecenie, które może potrwać kilka minut, podczas gdy weryfikuje zależności i wykonuje instalację wszystkiego, co niezbędne dla naszego frameworka:

Po zakończeniu procesu tworzymy nową aplikację, aby sprawdzić, czy wszystko przebiegło sprawnie za pomocą polecenia:

żagle nowy projekt

Co powinno dać nam wiadomość o sukcesie z nazwą naszej aplikacji, jak widać na poniższym obrazku:

Dodatkowo, jeśli ustawimy się w naszej aplikacji i wylistujemy katalog, możemy zobaczyć wszystkie wygenerowane przez nią pliki:

Na koniec musimy tylko podnieść nasz serwer, aby to zrobić podczas gdy w aplikacji wykonujemy następujące polecenie:

podnoszą żagle

Dzięki temu podnieśliśmy już nasz serwer, dając nam kilka interesujących wiadomości, takich jak otoczenia co w tym przypadku jest rozwojem i Port gdzie aplikacja jest uruchomiona, czyli 1337, otwieramy wybraną przez nas przeglądarkę i odwiedzamy następujący adres http: lokalny host: 1337 który powinien wyglądać tak:

POWIĘKSZAĆ

Jak widać mamy do dyspozycji widok wyświetlający domyślnie home, który zawiera między innymi następujące kroki do wykonania, aby kontynuować naszą ścieżkę w tym frameworku. Po sprawdzeniu, że wszystko działa poprawnie, umieścimy w nawiasie, aby dowiedzieć się trochę o strukturze naszej aplikacji i o tym, z czym mamy do dyspozycji.
Żagle.js Jest to dość kompletny framework, dla którego generuje szereg katalogów i plików ważnych dla naszego rozwoju, zobaczmy:
To jest katalog, w którym kontrolerzy Tak Modele naszej aplikacji, dodatkowo katalog o nazwie zasady gdzie definiowane są reguły autoryzacji i kontroli dostępu.
Mamy też katalog odpowiedzi gdzie odpowiedzi serwera są zarządzane i wreszcie usługi Możemy myśleć o nim jako o katalogu, w którym znajdują się biblioteki, które zawierają funkcje, które pomagają nam osiągnąć różne funkcjonalności w naszej aplikacji.
ten aktywa odnoszą się do tych statycznych plików, takich jak js, css, obrazy itp.., które znajdują się na naszym serwerze i chcemy, aby były dostępne z zewnątrz. w Żagle.js te pliki są umieszczone w katalogu aktywa, który posiada funkcję przetwarzania i synchronizacji tych plików oraz umieszczania ich w folderze tymczasowym za każdym razem, gdy uruchamiamy naszą aplikację, gdzie zawartość tego folderu tymczasowego jest tym, czym jest Żagle.js odpowiada za serwowanie.
Następnie mamy nasz katalog config, który zawiera dwa podkatalogi oraz dość dużą ilość plików przeznaczonych do konfiguracji naszej aplikacji. Pierwszy katalog to zazdrościć, który ma dwa pliki, jeden do definiowania parametrów, gdy pracujemy w rozwoju, a drugi w produkcji. Drugi katalog nazywa się lokalny i pozwala nam tworzyć nasze JSON w różnych językach obsługiwanych przez aplikację.
Jeden z najważniejszych plików w katalogu konfiguracja Jest to plik o nazwie połączenia.js, który umożliwia zarządzanie różnymi połączeniami do Bazy danych, połączenia są już zdefiniowane i wystarczy dodać parametry połączenia. To dlatego, że Żagle.js już przychodzi domyślnie z Wodnica potężny ORM do zarządzania operacjami z relacyjnymi bazami danych, a nie relacjami jako takimi.
Dlatego możemy mieć połączenia z bazą danych MySQL:

someMysqlServer: {adapter: 'sails-mysql', host: 'TWÓJ_MYSQL_SERVER_NAZWA_HOSTA_LUB_ADRES_IP', użytkownik: 'TWÓJ_UŻYTKOWNIK_MYSQL', hasło: 'TWOJE_HASŁO_MYSQL', baza danych: 'TWÓJ_MYSQL_DB'},

Do bazy danych noSQL, takiej jak MongoDB:

someMongodbServer: {adapter: 'sails-mongo', host: 'localhost', port: 27017, // użytkownik: 'nazwa_użytkownika', // hasło: 'hasło', // baza danych: 'twoja_mongo_db_nazwa_tutaj'},

Lub nawet PostgreSQL:

somePostgresqlServer: {adapter: 'sails-postgresql', host: 'YOUR_POSTGRES_SERVER_HOSTNAME_OR_IP_ADDRESS', użytkownik: 'YOUR_POSTGRES_USER', hasło: 'YOUR_POSTGRES_PASSWORD', baza danych: 'YOUR_POSTGRES_DB'

Musimy tylko zainstalować zależności dla Baza danych potrzebujemy i będziemy gotowi do współpracy Żagle.js szybko i łatwo.
Informator zadania zawiera pewne zasady dla naszej aplikacji, ale jeśli chodzi o sposób obsługi niektórych plików, na przykład plik pipe.js definiuje w jakiej kolejności nasze js, css i szablony powinny być kompilowane, a następnie linkowane i obsługiwane przez widoki w naszej aplikacji.
Dodatkowo w tym katalogu mamy kilka całkiem przydatnych funkcji, takich jak plik odpowiedzialny za przeprowadzenie procesu minifikacji do naszego css a nawet taki, który używa CoffeeScript skompilować kod JavaScript.
Wreszcie mamy nasze widoki, które są niczym innym jak szablonami, które są kompilowane na serwerze i są obsługiwane jako strony HTML, gdzie w większości przypadków te wyświetlenia są wynikiem prośby HTTP służyć tym samym.
Po zapoznaniu się nieco bardziej z naszym frameworkiem i plikami, które mamy do dyspozycji, zamierzamy kontynuować praktyczny przypadek tego samouczka, a tym samym zademonstrować moc i wszechstronność Żagle.js.
Tworząc naszą aplikację, wykorzystamy ją do wygenerowania REST API, w tym celu sprawdzamy, czy nie mamy jeszcze uruchomionego serwera, jeśli tak, to zatrzymujemy go CTRL + C. Następnie ustawiamy się w naszej aplikacji i wykonujemy następujące polecenie:

żagle generują użytkownika api

Z którym konsola odpowie komunikatem o sukcesie naszego nowego api utworzony, co dodatkowo wygeneruje dwa nowe pliki związane z tym procesem, model i oczywiście kontroler.

POWIĘKSZAĆ

Teraz, gdy to zrobiliśmy, zadajemy sobie pytanie: co teraz robimy? Chociaż może się wydawać, że trudno uwierzyć, że wygenerowaliśmy CRUD podstawowe, wystarczy spróbować, w tym celu ponownie podnosimy naszą usługę o podnoszą żagle i idziemy pod adres, który wcześniej podaliśmy, ale tym razem mamy dostęp do naszej ścieżki użytkownika, zobaczmy:

Jak widzimy nie mamy żadnego użytkownika, sytuację, którą możemy szybko zmienić, Sails.js pozwala nam tworzyć potrzebne nam wartości bezpośrednio z przeglądarki, do tego umieszczamy:

http://localhost:1337/user/create?name = Jonathan Acosta

Ta akcja utworzy naszego pierwszego użytkownika w aplikacji, jeśli spojrzymy, musimy zdefiniować atrybut do uwzględnienia za pomocą tej notacji, ponieważ przetwarza te wartości jako JSON, zobaczmy odpowiedź Żagle kiedy uruchamiamy ten adres URL w naszej przeglądarce:

Dodajemy kolejnych użytkowników, ale zdajemy sobie sprawę, że napisaliśmy złą nazwę, nie ma problemu, możemy ją zmodyfikować, w tym celu umieszczamy w naszym adresie URL i wartość zostanie zaktualizowana bez problemu:

http://localhost: 1337/użytkownik/aktualizacja/5?nazwa = Manuel% 20Perez

Jak widać, nie różni się ona zbytnio od naszej poprzedniej operacji, ważne jest, aby pamiętać, że musimy przesłać identyfikator użytkownika i nową wartość atrybutu do modyfikacji, za pomocą którego Żagle Odpowiesz nam w następujący sposób:

Dodatkowo, jeśli któryś z wpisanych przez nas rekordów uznamy, że nie jest już przydatny dla naszej aplikacji, możemy go bez problemu wyeliminować, w tym celu wykonujemy tylko:

http: // localhost: 1337 / użytkownik / zniszcz / 5

Konsultujemy się z naszymi użytkownikami i widzimy, jak nasz użytkownik o identyfikatorze 5 już nie istnieje:

Te, które właśnie zrobiliśmy, nazywają się skrótami lub skrótyNa potrzeby tego samouczka i aplikacji, które nie są w produkcji możemy to zrobić w ten sposób, jednak zaleca się ich dezaktywację ze względów bezpieczeństwa, w tym celu przechodzimy do naszego pliku blueprints.js i szukamy opcji skróty i przypisujemy wartość false. Z tym, gdy próbujesz użyć tworzyć, aktualizować lub niszczyć przez adres URL da nam stronę błędu 404:

POWIĘKSZAĆ

Na tym kończymy ten samouczek, w którym właśnie widzieliśmy wierzchołek góry lodowej Żagle.js, potężny i wszechstronny framework, który pozwala nam tworzyć aplikacje w ciągu kilku sekund, dając nam całkowitą kontrolę nad naszą aplikacją, osiągając optymalne i profesjonalne wyniki.Podobał Ci się i pomógł ten samouczek?Możesz nagrodzić autora, naciskając ten przycisk, aby dać mu pozytywny punkt