jQuery Academy · Lekcja

Tworzenie konfigurowalnych i wielokrotnego użytku wtyczek

Proszę tworzyć wtyczki z opcjami domyślnymi, pozwalające użytkownikom nadpisywać ustawienia, oraz przygotowywać je do ponownego użycia w różnych projektach przy minimalnym nakładzie pracy.

Lekcja 2 z 311 kroki

Tworzenie konfigurowalnych i wielokrotnego użytku wtyczek to bezpłatna lekcja jQuery Academy na CoddyKit. To lekcja 2 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej jQuery Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs jQuery Academy zawiera 3 lekcji w sumie.

Wprowadzenie do konfigurowalnych wtyczek

Witamy! W tej lekcji dowiedzą się Państwo, jak tworzyć elastyczne wtyczki jQuery, które można łatwo dostosowywać. Proszę wyobrazić sobie wtyczkę, której kolor, szybkość lub tekst można zmienić, podając zaledwie kilka opcji.

Jest to niezwykle ważne podczas tworzenia narzędzi, których można używać w wielu różnych projektach bez konieczności przepisywania kodu.

Dlaczego używać opcji domyślnych?

Wtyczki powinny działać od razu po instalacji, a jednocześnie umożliwiać dostosowanie. Właśnie do tego służą opcje domyślne.

  • Podstawowe działanie: Określają standardowy sposób działania wtyczki.
  • Łatwość użycia: Użytkownicy mogą zainicjować wtyczkę bez określania każdego ustawienia.
  • Elastyczność: Użytkownicy mogą zastąpić wartości domyślne, dostosowując wtyczkę do swoich potrzeb.

Definiowanie wartości domyślnych wtyczki

Opcje domyślne definiuje się jako obiekt wewnątrz wtyczki. Obiekt ten zawiera wszystkie ustawienia, z których wtyczka może korzystać, wraz z ich wartościami początkowymi.

Proszę uruchomić tę podstawową strukturę wtyczki, aby zobaczyć, jak deklaruje się wartości domyślne.

<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.7.1/jquery.min.js"></script>
<div id="myElement">Hello</div>
<script>
(function($) {
  $.fn.myPlugin = function(options) {
    // Define default settings here
    var defaults = {
      color: "blue",
      fontSize: "16px",
      message: "Default message!"
    };
    
    // For now, let's just log the defaults
    console.log("Plugin defaults:", defaults);
    
    return this; // Always return 'this' for chaining
  };
})(jQuery);

$(document).ready(function() {
  $('#myElement').myPlugin();
});
</script>

Scalanie opcji użytkownika: $.extend()

Aby umożliwić użytkownikom dostosowywanie ustawień, należy scalić podane przez nich opcje z wartościami domyślnymi. Doskonale nadaje się do tego metoda jQuery $.extend().

$.extend({}, defaults, options) tworzy nowy obiekt, kopiując najpierw właściwości z defaults, a następnie zastępując je właściwościami z options, jeśli zostały podane.

$.extend() w działaniu

Oto sposób użycia $.extend() wewnątrz wtyczki. Proszę zwrócić uwagę, że wartości użytkownika color i text zastępują wartości domyślne, natomiast fontSize pozostaje bez zmian, ponieważ nie został podany.

Proszę uruchomić ten kod i sprawdzić wynik w konsoli!

<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.7.1/jquery.min.js"></script>
<script>
(function($) {
  $.fn.myPlugin = function(options) {
    var defaults = {
      text: "Default text",
      color: "blue",
      fontSize: "16px"
    };
    
    // Merge defaults with user-provided options
    var settings = $.extend({}, defaults, options);
    
    console.log("Final settings:", settings);
    
    return this; // Keep chaining ability
  };
})(jQuery);

$(document).ready(function() {
  // User provides custom options
  $('body').myPlugin({
    text: "Custom Text!",
    color: "red"
  });
});
</script>

Dostęp do scalonych ustawień

Po uzyskaniu obiektu settings (zawierającego scalone wartości domyślne i opcje użytkownika) można uzyskać dostęp do dowolnej właściwości za pomocą notacji kropkowej, na przykład settings.color lub settings.animationSpeed.

Dzięki temu wtyczka zawsze korzysta z właściwej, ostatecznej konfiguracji.

Praktyczna wtyczka podpowiedzi

Zbudujmy prostą wtyczkę podpowiedzi, która umożliwia użytkownikom dostosowanie jej tekstu, koloru tła oraz opóźnienia przed wyświetleniem. Ten przykład pokazuje, jak konfigurowalne opcje zwiększają wszechstronność wtyczek.

<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.7.1/jquery.min.js"></script>
<style>
  .coddy-tooltip { /* Use unique class name */
    position: absolute;
    background-color: #333;
    color: white;
    padding: 5px 8px;
    border-radius: 3px;
    display: none;
    font-family: sans-serif;
    font-size: 14px;
  }
</style>
<button id="hoverMe">Hover Over Me</button>
<script>
(function($) {
  $.fn.coddyTooltip = function(options) {
    var defaults = {
      text: "Default Tooltip",
      bgColor: "#333",
      textColor: "white",
      delay: 200 // ms before showing
    };
    var settings = $.extend({}, defaults, options);

    return this.each(function() {
      var $this = $(this);
      var $tooltip = $('<div class="coddy-tooltip"></div>')
                       .text(settings.text)
                       .css({
                         'background-color': settings.bgColor,
                         'color': settings.textColor
                       })
                       .appendTo('body');

      var timeoutId; // To clear previous timeouts

      $this.on('mouseenter', function() {
        clearTimeout(timeoutId);
        timeoutId = setTimeout(function() {
          var offset = $this.offset();
          $tooltip.css({
            top: offset.top - $tooltip.outerHeight() - 5,
            left: offset.left + ($this.outerWidth() / 2) - 
                   ($tooltip.outerWidth() / 2)
          }).fadeIn(100);
        }, settings.delay);
      }).on('mouseleave', function() {
        clearTimeout(timeoutId);
        $tooltip.fadeOut(100);
      });
    });
  };
})(jQuery);

$(document).ready(function() {
  // Initialize the tooltip with custom options
  $('#hoverMe').coddyTooltip({
    text: "Hello from CoddyKit!",
    bgColor: "darkblue",
    delay: 500
  });
});
</script>

Projektowanie z myślą o ponownym użyciu

Oprócz możliwości konfiguracji naprawdę solidna wtyczka powinna nadawać się do ponownego użycia. Oznacza to, że można ją dodać do dowolnego projektu i uruchomić bez konfliktów ani specjalnej konfiguracji.

  • Hermetyzacja: Należy użyć IIFE (function($){...})(jQuery);, aby zachować prywatność kodu.
  • `this.each()`: Należy zawsze iterować po wybranych elementach, aby zastosować logikę do wszystkich pasujących elementów.
  • Brak zanieczyszczania zakresu globalnego: Należy unikać tworzenia globalnych zmiennych i funkcji.
  • Samodzielna logika: Wtyczka nie powinna zależeć od zewnętrznych skryptów ani stylów, chyba że zostało to wyraźnie opisane.

Znaczenie `this.each()`

Gdy użytkownik wywołuje wtyczkę dla zaznaczenia takiego jak $('.my-class').myPlugin(), jQuery może zwrócić wiele elementów. Wzorzec return this.each(function(){ ... }); gwarantuje, że logika wtyczki zostanie wykonana dla każdego elementu w tym zaznaczeniu.

W funkcji callback przekazanej do each wartość this odnosi się do aktualnie przetwarzanego elementu DOM.

<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.7.1/jquery.min.js"></script>
<div class="item">Item 1</div>
<div class="item">Item 2</div>
<script>
(function($) {
  $.fn.highlight = function(options) {
    var defaults = {
      color: "yellow"
    };
    var settings = $.extend({}, defaults, options);

    return this.each(function() {
      // 'this' refers to the current DOM element in the loop
      $(this).css('background-color', settings.color);
    });
  };
})(jQuery);

$(document).ready(function() {
  // Apply highlight to all elements with class 'item'
  $('.item').highlight({ color: "lightblue" });
});
</script>

Szybkie sprawdzenie: dobre praktyki tworzenia wtyczek

Sprawdźmy Państwa wiedzę na temat tworzenia konfigurowalnych i wielokrotnego użytku wtyczek jQuery!

Podsumowanie: konfigurowalność i możliwość ponownego użycia

Opanowali już Państwo tworzenie zaawansowanych i elastycznych wtyczek jQuery!

  • Należy definiować opcje domyślne, aby określić podstawowe działanie.
  • Należy używać $.extend() do scalania opcji użytkownika, umożliwiając dostosowanie.
  • Należy stosować return this.each(), aby zapewnić działanie wtyczki na wielu wybranych elementach.
  • Należy hermetyzować kod w IIFE, aby umożliwić ponowne użycie i uniknąć konfliktów globalnych.

Techniki te sprawiają, że wtyczki są solidne, elastyczne i gotowe do użycia w każdym projekcie!

Bezpłatny start

Ucz się JavaScript dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy
22
Lekcje
48

Często zadawane pytania

Czy lekcja „Tworzenie konfigurowalnych i wielokrotnego użytku wtyczek” jest bezpłatna?

Tak — pełny tekst „Tworzenie konfigurowalnych i wielokrotnego użytku wtyczek” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu jQuery Academy, przejdź na CoddyKit PRO. Kurs jQuery Academy zawiera 3 lekcji w sumie.

Co nauczysz się w „Tworzenie konfigurowalnych i wielokrotnego użytku wtyczek”?

Proszę tworzyć wtyczki z opcjami domyślnymi, pozwalające użytkownikom nadpisywać ustawienia, oraz przygotowywać je do ponownego użycia w różnych projektach przy minimalnym nakładzie pracy. Ćwiczysz jQuery Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć jQuery Academy?

Nie wymagamy żadnego doświadczenia. jQuery Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 3.

Ile czasu zajmuje lekcja „Tworzenie konfigurowalnych i wielokrotnego użytku wtyczek”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji jQuery Academy?

Tak. Każda lekcja jQuery Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Wzorce projektowe i zakresy wtyczek
  2. Tworzenie konfigurowalnych i wielokrotnego użytku wtyczek
  3. Integracja metod publicznych i callbacków
← Powrót do jQuery Academy