Archiwum kategorii: Programowanie

Interpolacja, wiązanie danych i podstawowe zdarzenia

Po zapoznaniu się z dodaniem Vue i strukturą komponentu, przejdźmy do fundamentalnych mechanizmów Vue, czyli wiązania danych z widokiem (data binding) oraz obsługi zdarzeń. Vue wyróżnia się reaktywnością – zmiany danych automatycznie wpływają na zawartość HTML, dzięki czemu pisanie interaktywnego interfejsu jest znacznie uproszczone. Omówimy teraz podstawy: interpolację w tekście, wiązanie atrybutów oraz obsługę zdarzeń w Vue 3.

Interpolacja danych w HTML

Interpolacja to najprostszy sposób wyświetlania dynamicznych danych w szablonie Vue. Wykorzystuje ona tzw. składnię „wąsów” – podwójnych nawiasów klamrowych {{ }}. Umieszczając wyrażenie lub nazwę właściwości wewnątrz {{ }} w kodzie HTML, instruujemy Vue, aby w to miejsce wstawił bieżącą wartość danej właściwości. Przykład interpolacji:

<p>Wiadomość: {{ msg }}</p>

Jeśli nasz komponent posiada właściwość msg w swoim stanie (np. w data() zwracamy { msg: 'Hello' }), to w przeglądarce zobaczymy zawartość tej właściwości w miejscu klamer. Vue automatycznie zadba o aktualizację wyświetlanej wartości za każdym razem, gdy zmieni się msg. Interpolacja działa tylko w treści HTML między tagami. Nie można używać {{ }} bezpośrednio w atrybutach HTML (np. <img src="{{ dynamicUrl }}"> jest niepoprawne) – do tego służą dedykowane dyrektywy omówione poniżej.

Warto wspomnieć, że interpolacja tekstu renderuje dane jako zwykły tekst. Gdy chcemy wstrzyknąć surowy kod HTML przechowywany w zmiennej, Vue oferuje dyrektywę v-html, jednak korzystanie z niej niesie ryzyko XSS i powinno być ograniczone tylko do zaufanych treści. W większości przypadków standardowa interpolacja {{ }} jest wystarczająca i bezpieczna.

Wiązanie atrybutów z użyciem v-bind

Aby dynamicznie zmieniać atrybuty elementów HTML w reakcji na zmiany danych, Vue udostępnia dyrektywę v-bind. Pozwala ona powiązać (zbindować) wartości właściwości ze wskazanym atrybutem HTML. Składnia pełna to v-bind:nazwaAtrybutu="wyrażenie" – np. v-bind:href="url" ustawi atrybut href linku na wartość właściwości url z naszych danych. Dzięki v-bind framework synchronizuje atrybut elementu z wartością zmiennej – jeśli zmienna się zmieni, atrybut automatycznie zostanie zaktualizowany.

Ponieważ używanie v-bind jest bardzo częste, Vue oferuje skróconą składnię: zamiast pisać v-bind: można użyć dwukropka : przed nazwą atrybutu. Przykładowo, zapis <img :src="obrazekUrl"> jest równoważny z <img v-bind:src="obrazekUrl">. Tak samo <div :id="dynamicId"> to skrót od <div v-bind:id="dynamicId">. Używanie skrótu : czyni kod bardziej zwięzłym i czytelnym, dlatego jest on powszechnie stosowany.

Przykład zastosowania v-bind w praktyce (wraz z interpolacją dla porównania):

<div id="app">  <h2>{{ tytul }}</h2>  <img :src="obrazekUrl" alt="Opis obrazka" /> </div> <script>  const { createApp } = Vue;  createApp({    data() {      return {        tytul: 'Mój pierwszy obrazek w Vue',        obrazekUrl: 'https://placekitten.com/300/200' // przykładowy URL obrazka      };    }  }).mount('#app'); </script>

W powyższym fragmencie tytuł obrazka jest wstawiany w nagłówku <h2> poprzez interpolację {{ tytul }}, natomiast adres obrazka jest dowiązany do atrybutu src tagu <img> za pomocą :src. Gdyby zmienna obrazekUrl została zmieniona (np. wskazywała na inny link), Vue automatycznie zaktualizuje atrybut src obrazka na stronie, bez potrzeby ręcznego manipulowania DOM.

Obsługa zdarzeń za pomocą v-on

Interaktywność aplikacji wymaga reagowania na działania użytkownika, takie jak kliknięcia, wprowadzanie tekstu czy przesuwanie myszy. W Vue do obsługi zdarzeń służy dyrektywa v-on, pozwalająca nasłuchiwać na zdarzenia DOM i wywoływać w odpowiedzi określone metody lub wyrażenia. Pełna składnia to v-on:nazwaZdarzenia="funkcjaLubKod" – np. v-on:click="wywolajCos" sprawi, że po kliknięciu w element zostanie wykonana metoda wywolajCos naszego komponentu.

Podobnie jak w przypadku v-bind, dla v-on istnieje skrócona składnia: można zastąpić v-on: znakiem @. Dlatego zamiast v-on:click zazwyczaj piszemy po prostu @click. Przykładowy kod z użyciem v-on i skrótu @:

 <button v-on:click="powitaj">Kliknij mnie (v-on)</button> <!-- To samo z użyciem skrótu '@': --> <button @click="powitaj">Kliknij mnie (@click)</button>

W obu przypadkach kliknięcie przycisku spowoduje wywołanie metody powitaj zdefiniowanej w naszym komponencie (tak jak w poprzedniej sekcji przykładu z powitaj() w data/methods). Argumentem dyrektywy v-on jest nazwa zdarzenia DOM, którego obsługę chcemy podpiąć – np. click, input, submit itp. Vue automatycznie przekazuje kontekst komponentu, więc wewnątrz metody możemy odwoływać się do this (w Options API) lub korzystać ze zmiennych z setup() (w Composition API).

Przykład typowego zastosowania – licznik (counter): Połączmy teraz interpolację, bindowanie i obsługę zdarzeń, tworząc prosty licznik. Będzie on miał przycisk zwiększający wartość licznika i tekst wyświetlający bieżący stan. Dodatkowo pokażemy dynamiczne wiązanie atrybutu disabled przycisku oraz użycie atrybutu title do wyświetlenia podpowiedzi po najechaniu kursorem:

<div id="app">  <h3>Licznik: {{ count }}</h3>  <button @click="increment" :disabled="count >= max">    Dodaj +1  </button>  <p :title="'Aktualny stan: ' + count">    Najedź kursorem tutaj, aby zobaczyć stan licznika.  </p> </div> <script>  const { createApp } = Vue;  createApp({    data() {      return {        count: 0,    // bieżąca wartość licznika        max: 5       // maksymalna wartość licznika      };    },    methods: {      increment() {        if (this.count < this.max) {          this.count++;        }      }    }  }).mount('#app');
 </script>

Omówienie działania powyższego przykładu: W nagłówku <h3> używamy interpolacji {{ count }}, aby wyświetlić aktualną wartość licznika. Przycisk Dodaj +1 ma zdefiniowany nasłuch na zdarzenie kliknięcia @click="increment", który wywołuje metodę increment() komponentu. Metoda increment zwiększa wartość count o jeden, ale tylko jeśli nie został osiągnięty maksimum (prosta logika zabezpieczająca, aby pokazać wykorzystanie danych w metodzie). W atrybucie disabled przycisku wykorzystujemy v-bind (skróconą składnię :) z warunkiem count >= max. Gdy wartość count osiągnie wartość max (5), wyrażenie to zwróci true, co spowoduje przypisanie atrybutu disabled do elementu <button> (przycisk stanie się nieaktywny). Gdy count jest mniejsze niż max, wyrażenie count >= max jest false i atrybut disabled nie będzie obecny, dzięki czemu przycisk jest aktywny (Vue usuwa atrybut dla wartości falsy). Natomiast <p> poniżej ma atrybut title dowiązany do tekstu "Aktualny stan: " + count. Dzięki temu po najechaniu kursorem na ten akapit przeglądarka pokaże dymek z aktualną wartością licznika. Ten atrybut title aktualizuje się automatycznie wraz ze zmianą count, ponieważ jest powiązany poprzez reakcję Vue.

Powyższy przykład ilustruje kluczowe koncepty: interpolacja ({{ count }}), wiązanie atrybutu (:disabled, :title) oraz obsługa zdarzenia (@click). Widzimy, że dzięki reaktywności Vue nie musimy bezpośrednio manipulować DOM (np. używać document.querySelector czy ręcznie dodawać atrybutów) – wystarczy zdefiniować powiązania, a framework sam zadba o aktualizację widoku, gdy zmienią się dane. To znacząco upraszcza tworzenie interaktywnych aplikacji.



Struktura komponentu Vue

Składnia komponentu w Vue 3: Podstawowym elementem każdej aplikacji Vue są komponenty. Komponentem może być zarówno główna instancja aplikacji (root component), jak i mniejsze, wielokrotnego użytku części interfejsu. W Vue 3 można definiować komponenty na dwa główne sposoby – za pomocą Options API (znanego z Vue 2) lub nowszego Composition API. Niezależnie od podejścia, komponent posiada swój szablon (template) oraz logikę (dane i metody) opisującą zachowanie. W przypadku używania Vue bez procesu budowania (np. przez CDN), zazwyczaj definicja komponentu odbywa się w kodzie JavaScript, a szablonem jest bezpośrednio kod HTML w miejscu montowania komponentu lub łańcuch znaków.

Typowy komponent z wykorzystaniem Options API definiujemy jako obiekt zawierający m.in.:

  • data – obiekt lub funkcja zwracająca obiekt przechowujący stan aplikacji (dane reaktywne komponentu).
  • methods – obiekt z metodami (funkcjami), które można wywoływać z poziomu szablonu (np. w obsłudze zdarzeń) lub z innych metod komponentu.

Przy tworzeniu instancji aplikacji (komponentu głównego) przez createApp, przekazujemy właśnie taki obiekt konfiguracyjny. Oprócz data i methods możemy tam zdefiniować m.in. computed (właściwości obliczane zależne od danych) czy watch (reakcje na zmiany danych), ale w prostej pierwszej aplikacji nie jest to konieczne. Poniżej pokazano strukturę głównego komponentu z użyciem Options API w jednym pliku HTML:

 <div id="app">
  <p>{{ message }}</p>
  <button v-on:click="powitaj">Kliknij mnie</button>
 </div>

 <script>
  const { createApp } = Vue;
  createApp({
    data() {
      return {
        message: 'Witaj, świecie Vue!'
      };
    },
    methods: {
      powitaj() {
        alert(this.message);
      }
    }
  }).mount('#app');
 </script>

W powyższym przykładzie komponentem głównym jest obiekt przekazany do createApp. Ma on właściwość data() zwracającą obiekt z danymi (message) oraz metodę powitaj(), która odwołuje się do danych poprzez this.message. Szablonem komponentu jest po prostu zawartość elementu <div id="app"> w momencie montowania – Vue przeanalizuje tę zawartość i znajdzie w niej wiązania ({{ message }}) oraz dyrektywy (np. v-on:click) do powiązania z danymi i metodami komponentu.

Composition API vs Options API (krótko): Vue 3 wprowadziło Composition API jako alternatywę dla Options API, aby lepiej organizować logikę w komponentach, zwłaszcza gdy stają się one duże. Główna różnica polega na tym, że w Composition API zamiast definiować oddzielne pola obiektu (data, methods, itd.), używamy funkcji setup(), w której za pomocą importowanych funkcji Vue (np. ref, reactive, composables) tworzymy i konfigurujemy stan oraz działania komponentu. Zamiast korzystać z this, od razu operujemy na zmiennych i funkcjach wewnątrz setup(), a na końcu zwracamy obiekt zawierający elementy, które mają być dostępne w szablonie.

Z perspektywy początkującego Options API jest na ogół prostsze i bardziej intuicyjne, ponieważ grupuje logikę według przeznaczenia (dane, metody, itp.) i przypomina tradycyjne podejście z Vue 2medium.com. Natomiast Composition API oferuje większą elastyczność – pozwala grupować kod według funkcjonalności, lepiej współdzielić logikę pomiędzy komponentami (przez tzw. composable funkcje) oraz zapewnia lepsze wsparcie dla TypeScriptmedium.com. W praktyce Options API bywa łatwiejsze na start, ale Composition API ułatwia utrzymanie większych projektów. Dla przykładu, poniżej zobrazowano te dwa podejścia definiowania tego samego prostego komponentu:

 // Przykład: komponent z polem tekstowym i przyciskiem – Options API
 const KomponentOptions = {
  data() {
    return { msg: 'Tekst' };
  },
  methods: {
    zmienTekst() {
      this.msg = 'Zmieniony!';
    }
  }
 };

 // Przykład: ten sam komponent – Composition API
 const KomponentComposition = {
  setup() {
    const msg = Vue.ref('Tekst');
    function zmienTekst() {
      msg.value = 'Zmieniony!';
    }
    return { msg, zmienTekst };
  }
 };

Oba powyższe komponenty osiągają ten sam efekt – przechowują tekst msg i oferują metodę do jego zmiany. Różnica polega na składni: Options API korzysta z oddzielnych pól obiektu (data, methods) i odwołuje się do stanu przez this, podczas gdy Composition API wszystko definiuje wewnątrz setup() korzystając z funkcji reaktywnych (tu ref) i zmiennej msg bez potrzeby używania this. Dla początkujących rekomenduje się rozpoczęcie nauki od Options API, aby dobrze zrozumieć reaktywność i podstawy Vue, a następnie zapoznanie się z Composition API, gdy zajdzie potrzeba lepszej organizacji kodu.

Tworzenie komponentu głównego w jednym pliku HTML: Jak pokazano wcześniej, możliwe jest zdefiniowanie całej logiki aplikacji Vue w obrębie jednego pliku HTML (bez korzystania z plików .vue). Komponent główny (root) może być zdefiniowany „inline” w skrypcie osadzonym na stronie. W tym podejściu szablonem jest albo istniejący kod HTML wewnątrz elementu montowanego (jak <div id="app">), albo możemy jawnie określić opcję template w definicji komponentu jako łańcuch zawierający kod HTML. Na przykład, zamiast polegać na zawartości elementu HTML, moglibyśmy napisać:

 createApp({
  data() { return { komunikat: 'Cześć!' } },
  template: `<p>{{ komunikat }}</p>`
 }).mount('#app');

W powyższym kodzie przypisaliśmy szablon komponentu wprost w kodzie JavaScript za pomocą parametru template. Taka metoda bywa używana w prostych przykładach lub podczas szybkiego prototypowania. Należy jednak pamiętać, że przy bardziej złożonych szablonach wygodniej jest korzystać z naturalnego HTML w dokumencie albo (docelowo) przenieść komponenty do osobnych plików .vue i użyć narzędzi kompilujących. Mimo ograniczeń, umieszczenie komponentu głównego w jednym pliku HTML jest możliwe i bywa wystarczające na etapie nauki.

Tworzenie pierwszej aplikacji w Vue 3

Dodanie Vue przez CDN

Jak załadować Vue 3 przez CDN: Najprostszym sposobem rozpoczęcia pracy z Vue 3, bez konieczności instalowania narzędzi czy tworzenia projektu build, jest skorzystanie z CDN (Content Delivery Network). Framework Vue można załadować bezpośrednio na stronę HTML za pomocą tagu <script> wskazującego na plik biblioteki udostępniony przez CDN. Na przykład, aby załadować Vue 3 z popularnego CDN unpkg, wystarczy umieścić w sekcji <head> lub na końcu <body> następujący element script:

 <!-- Ładowanie Vue 3 z CDN (unpkg) -->
 <script src="https://unpkg.com/vue@3/dist/vue.global.js"></script>

Powyższy skrypt wczytuje globalną wersję Vue 3, w której wszystkie najważniejsze API są dostępne poprzez globalny obiekt Vue. Można także użyć innych CDN obsługujących paczki npm, takich jak jsDelivr czy cdnjs, lub pobrać plik z Vue i hostować go samodzielnie. Dzięki tej metodzie nie ma potrzeby przeprowadzania kroku kompilacji czy używania narzędzi typu webpack – kod działa od razu w przeglądarce.

Przykład użycia Vue 3 bez budowania projektu: Po załadowaniu biblioteki z CDN możemy od razu utworzyć prostą aplikację Vue. Wystarczy w HTML przygotować element, do którego „przywiążemy” aplikację (np. <div id="app">), a następnie w skrypcie stworzyć instancję aplikacji za pomocą Vue.createApp i zamontować ją na tym elemencie. Poniżej znajduje się przykład minimalnej aplikacji Vue 3 osadzonej w pojedynczym pliku HTML:

 <!DOCTYPE html>
 <html lang="pl">
 <head>
  <meta charset="UTF-8" />
  <title>Pierwsza aplikacja Vue 3</title>
  <!-- Dodanie Vue 3 z CDN -->
  <script src="https://unpkg.com/vue@3/dist/vue.global.js"></script>
 </head>
 <body>
  <!-- Element, do którego zostanie zamontowana aplikacja Vue -->
  <div id="app">
    {{ message }}
  </div>

  <script>
    // Wyodrębnienie funkcji createApp z globalnego obiektu Vue
    const { createApp } = Vue;
    // Utworzenie instancji aplikacji Vue
    createApp({
      data() {
        return {
          message: 'Witaj Vue!'
        };
      }
    }).mount('#app'); // Zamontowanie aplikacji do elementu o id="app"
  </script>
 </body>
 </html>   

W powyższym kodzie po załadowaniu biblioteki Vue tworzymy aplikację za pomocą createApp. Wykorzystujemy API opcji (Options API) – przekazujemy obiekt z danymi (data) do funkcji createApp. Obiekt data() zwraca stan aplikacji (tu jedna właściwość message), który następnie interpolujemy w elemencie <div id="app"> za pomocą składni {{ message }}. Metoda mount('#app') sprawia, że Vue przejmuje kontrolę nad elementem o podanym selektorze i renderuje w nim nasz szablon z danymi.

Zalety metody CDN dla początkujących: Dodawanie Vue przez CDN jest szczególnie przyjazne dla osób początkujących z kilku powodów:

  • Brak konfiguracji i budowania: Nie wymaga instalacji Node.js, konfiguracji bundlera ani żadnych kroków kompilacji – wystarczy dodać skrypt i można od razu pisać kod Vue. Taka konfiguracja jest dużo prostsza i świetnie nadaje się do szybkiego prototypowania lub dodawania Vue do istniejącej statycznej strony HTML.
  • Szybki start: Pozwala w ciągu minut zobaczyć efekty działania frameworka, co jest motywujące dla początkujących. Można skupić się na nauce samego Vue, zamiast na narzędziach do budowania projektu.
  • Łatwa integracja: Metoda CDN umożliwia stopniowe integrowanie Vue z istniejącymi projektami backendowymi lub statycznymi stronami – można dodać Vue tylko do wybranych części interfejsu bez przebudowy całej aplikacji.

Ograniczenia tej metody: Mimo wygody, ładowanie Vue z CDN ma pewne ograniczenia istotne z perspektywy dalszej nauki i rozwoju aplikacji:

  • Brak SFC i narzędzi deweloperskich: Przy takiej prostej konfiguracji nie można używać składni Single-File Component (SFC), czyli pojedynczych plików .vue zawierających szablon, skrypt i style komponentu. Jesteśmy ograniczeni do pisania kodu w zwykłych <script> w HTML, co przy większych projektach staje się mało wygodne.
  • Mniejsza skalowalność: Tworzenie większej aplikacji z wieloma komponentami staje się trudne bez modułowego systemu plików i build step. Dla rozbudowanych projektów zaleca się użycie narzędzi (np. Vue CLI z Vite) i strukturyzację aplikacji w komponentach SFC.
  • Wydajność i zależności: Przy bezpośrednim dodaniu z CDN wszystkie skrypty ściągane są przy każdym odświeżeniu strony. Chociaż CDN często korzysta z cachowania, w środowisku produkcyjnym zazwyczaj lepiej mieć kontrolę nad wersjami i pakować aplikację. Ponadto, dodając kolejne biblioteki (np. Vue Router, Vuex/Pinia) również przez CDN, trzeba ręcznie dbać o ich poprawne wczytanie we właściwej kolejności.

Podsumowując, dla początkujących korzystanie z Vue przez CDN jest znakomitym sposobem na pierwsze kroki – pozwala szybko zobaczyć działanie frameworka i zrozumieć podstawy, zanim przejdziemy do bardziej zaawansowanych narzędzi.

Metody uruchamiania aplikacji Vue.js

1. Osadzenie Vue przez CDN

Najprostszy sposób na użycie Vue to dodanie go do strony HTML poprzez CDN (sieć dostarczania treści). Wymagania: potrzebna jest tylko przeglądarka i dostęp do Internetu (w przypadku zewnętrznego CDN). Nie jest potrzebny Node.js ani instalacja dodatkowych narzędzi.

Instalacja narzędzi: W praktyce niczego nie instalujemy – wystarczy umieścić w kodzie HTML tag <script> wskazujący na CDN Vue. Na przykład:

 <script src="https://unpkg.com/vue@3/dist/vue.global.js"></script>

Można użyć różnych dostawców CDN (unpkg, jsDelivr, cdnjs itp.).

Tworzenie i uruchomienie projektu: Przygotowujemy zwykły plik HTML. W sekcji <head> lub na końcu <body> dodajemy powyższy <script>, a następnie w osobnym skrypcie inicjujemy aplikację Vue. Przykładowy minimalny kod:

 <!DOCTYPE html>
 <html>
 <head>
  <!-- Osadzenie Vue przez CDN -->
  <script src="https://unpkg.com/vue@3/dist/vue.global.js"></script>
 </head>
 <body>
  <div id="app">{{ message }}</div>

  <script>
    // Tworzymy nową aplikację Vue i montujemy ją na elemencie #app
    const { createApp } = Vue;
    createApp({
      data() {
        return { message: 'Witaj Vue!' }
      }
    }).mount('#app');
  </script>
 </body>
 </html>

Po otwarciu tego pliku w przeglądarce zobaczymy działający prosty przykład („Witaj Vue!”). W tej metodzie nie ma lokalnego serwera developerskiego – wystarczy otworzyć plik statyczny (lub użyć np. dowolnego prostego serwera plików). Struktura katalogów: zwykle to tylko jeden plik index.html, ewentualnie dodatkowe pliki CSS/JS, jeśli chcemy rozdzielić kod. Przykład:

  • index.html – główny plik (z kodem Vue i HTML).
  • (opcjonalnie) app.js – osobny plik JavaScript z logiką Vue, jeśli nie chcemy pisać wszystkiego inline.

Ten sposób jest najprostszy, ale ma ograniczenia: nie pozwala korzystać z zaawansowanych składników jednoplikowych (.vue) ani wbudowanych systemów modułów. Jest jednak idealny do prototypowania lub małych wzbogaceń statycznych stron.

2. Użycie Vue CLI

Vue CLI (Command Line Interface) to narzędzie oficjalnie wspierane dla Vue 2 i 3, które automatycznie tworzy strukturę projektu z użyciem bundlera (Webpack). Uwaga: od czasu wprowadzenia Vite, Vue CLI jest w trybie konserwacji, ale nadal używane w wielu kursach i starszych projektach.

Wymagania wstępne: Należy mieć zainstalowany Node.js (wersja co najmniej 8.9, zalecana 10 lub wyższa)cli.vuejs.org. Zaleca się Node LTS lub nowszy. Po instalacji Node.js mamy również npm.

Instalacja narzędzi: Instalujemy globalnie pakiet Vue CLI przez npm lub Yarn:

 npm install -g @vue/cli  
 # lub, jeśli używasz Yarn:
 yarn global add @vue/cli

Polecenie to dodaje wiersz poleceń vue. Po instalacji można sprawdzić wersję poleceniem vue --version.

Utworzenie projektu: W katalogu, gdzie chcemy pracować, wywołujemy:

 vue create moj-projekt

Narzędzie zapyta o kilka opcji (można wybrać preset domyślny z Babel i ESLint lub wybrać ręcznie dodatkowe funkcje, np. TypeScript, Router itp.). Wyboru można dokonać strzałkami/enterem w konsoli. Po potwierdzeniu rozpocznie się generowanie projektu.

Uruchomienie lokalnego serwera developerskiego:
Po utworzeniu projektu przechodzimy do jego katalogu i instalujemy zależności:

cd moj-projekt
npm install

Następnie uruchamiamy serwer developerski:

 npm run serve

Serwer zwykle wystartuje na lokalnym adresie (np. http://localhost:8080). W terminalu CLI wyświetli się komunikat z adresem. Serwer obsługuje hot-reload – zmiany w kodzie (np. w plikach .vue) będą automatycznie odzwierciedlane w przeglądarce.

Struktura katalogów projektu (Vue CLI):
Po wygenerowaniu projektu otrzymujemy typową strukturę:

moj-projekt/
├─ node_modules/ – zależności projektu
├─ public/
│ └─ index.html – główny plik HTML szablonu
├─ src/
│ ├─ assets/ – zasoby (obrazy, czcionki itp.)
│ ├─ components/ – gotowe komponenty Vue (np. HelloWorld.vue)
│ ├─ App.vue – główny komponent aplikacji
│ └─ main.js – punkt wejścia (inicjalizacja Vue)
├─ .gitignore
├─ babel.config.js
├─ package.json – metadane i skrypty (m.in. `serve`, `build`)
└─ README.md
  • W public/index.html znajduje się pojedynczy <div id="app">, do którego montuje się aplikacja.
  • Plik src/main.js zawiera coś w rodzaju:
 import { createApp } from 'vue'     import App from './App.vue' createApp(App).mount('#app')

  • Natomiast App.vue jest komponentem głównym (zawiera <template>, <script>, <style>). Inne komponenty umieszczamy w src/components.

Vue CLI domyślnie używa Webpack do budowania projektu. Polecenie npm run serve odpala lokalny serwer dev, a npm run build buduje projekt do folderu dist (produkcja). Przy korzystaniu z CLI mamy pełną elastyczność: możemy modyfikować konfigurację Webpack (przez plik vue.config.js), dodawać pluginy, używać TypeScript, Router, Vuex itd.

3. Użycie Vite (create-vue)

Vite to nowoczesny bundler/narzędzie build-step rekomendowane obecnie przez zespół Vue (szczególnie dla Vue 3). Zapewnia dużo szybszy start i hot-reload dzięki wykorzystaniu natywnych modułów ES i szybkich kompilacji.

Wymagania wstępne: Podobnie jak przy CLI, potrzebujemy Node.js. Dokumentacja wskazuje na Node.js w wersji co najmniej 18.3 (lub nowszej) dla pełnej zgodności.

Instalacja narzędzi: Nie instalujemy nic globalnie (chyba że npm/yarn). W terminalu uruchamiamy komendę inicjalizującą nowy projekt:

 npm create vue@latest

Alternatywnie (jeśli używasz innych narzędzi):

 pnpm create vue@latest
 yarn create vue

Polecenie to pobierze i uruchomi oficjalny skrypt create-vue, który zapyta o kilka opcji (np. nazwa projektu, TypeScript, router, Pinia, testy itp.). Przykładowy zestaw pytań:

 ✔ Project name: … moj-vue-vite
 ✔ Add TypeScript? … No
 ✔ Add Vue Router for SPA? … Yes
 ✔ Add Pinia for state management? … No
 ✔ Add ESLint? … Yes

Po potwierdzeniu Vue automatycznie wygeneruje projekt. Czekamy na komunikat „Scaffolding project in ./<nazwa>… Done”.

Uruchomienie lokalnego serwera developerskiego:
Po skończeniu tworzenia projektu przechodzimy do katalogu i instalujemy zależności:

 cd moj-vue-vite npm install

Następnie uruchamiamy serwer deweloperski poleceniem:

 npm run dev

Zwykle pojawia się adres lokalny (np. http://localhost:5173). Vite oferuje bardzo szybkie odświeżanie zmian.

Struktura katalogów projektu (Vite + Vue):
Typowa struktura wygenerowana przez create-vue jest podobna do Vue CLI, ale trochę uproszczona:

moj-vue-vite/
├─ node_modules/
├─ public/
│ └─ vite.svg – plik graficzny startowy (można usuwać)
├─ src/
│ ├─ assets/
│ ├─ components/
│ │ └─ HelloWorld.vue
│ ├─ App.vue
│ └─ main.js
├─ .gitignore
├─ index.html – główny plik HTML (punkt startu aplikacji)
├─ package.json
└─ vite.config.js – konfiguracja Vite (domyślnie niewiele potrzeba zmieniać)

Zawartość jest analogiczna: main.js importuje App.vue i montuje aplikację, a App.vue może wykorzystywać składnię <script setup> (Composition API). Na przykład main.js może wyglądać tak:

 import { createApp } from 'vue'
 import App from './App.vue'

 createApp(App).mount('#app')

A App.vue może być np.:

 <template>
  <div>
    <h2>{{ message }}</h2>
    <input v-model="message" placeholder="Zmień wiadomość"/>
  </div>
 </template>

 <script setup>
     import { ref } from 'vue'
     const message = ref('Witaj Vite!')
 </script>

 <style>
     h2 { color: green; }
 </style>