0Pricing
jQuery Academy · Ders

Genel Yöntemleri ve Geri Çağrıları Entegre Etme

Harici etkileşim için eklentilerinize genel yöntemler ekleyin ve kullanıcıların belirli eklenti olaylarına bağlanabilmesi için geri çağırma işlevleri ekleyin.

Genel Yöntemleri ve Geri Çağrıları Entegre Etme, CoddyKit'te ücretsiz bir jQuery Academy dersidir. Bu, 3 dersinin 3. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, jQuery Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. jQuery Academy kursu toplamda 3 dersten oluşur.

Eklentilerinizle Etkileşim Kurma

Harika eklentiler yalnızca bağımsız olarak çalışmaz. Başlatıldıktan sonra kullanıcıların onlarla etkileşim kurmasına da olanak tanır! Bu derste, dışarıdan denetim için genel yöntemler ve özel tepkiler için geri çağırma işlevleri eklemeyi öğreneceksiniz.

  • Genel Yöntemler: Kullanıcıların başlatılmış bir eklenti örneği üzerinde çağırabileceği işlevlerdir.
  • Geri Çağırmalar: Eklentinizin içinde belirli olaylar gerçekleştiğinde çalışan işlevlerdir.

Eklenti Temellerini Yeniden Hatırlama

jQuery eklentilerinin, genel alanın kirlenmesini önlemek için genellikle Immediately Invoked Function Expression (IIFE) içine alındığını hatırlayın. Bu yapı, eklentinizin mantığı ve dahili değişkenleri için güvenli bir alan sağlar.

Bu tanıdık yapı üzerine inşa edeceğiz.

(function($) {
  $.fn.myPlugin = function(options) {
    // Default settings
    var settings = $.extend({}, $.fn.myPlugin.defaults, options);

    return this.each(function() {
      var $this = $(this); // The element the plugin is applied to
      // Plugin logic goes here
      console.log("Plugin initialized on: " + $this.attr('id'));
    });
  };

  // Default options
  $.fn.myPlugin.defaults = {
    message: "Hello from plugin!"
  };
})(jQuery);

// How to use (in HTML <div id="myElement"></div>):
// $('#myElement').myPlugin();

Genel Yöntemler Nelerdir?

Genel yöntem, eklentiniz tarafından dışarıya açılan ve bir öğede eklenti başlatıldıktan sonra bile dahili kapsamının dışından çağrılabilen bir işlevdir.

Bunu eklentiniz için bir uzaktan kumanda gibi düşünebilirsiniz. Eklentiye "sıfırla", "güncelle" veya "bir değer al" gibi işlemler yapmasını söyleyebilirsiniz.

Genel Bir Yöntem Uygulama

Genel yöntemler eklemek için eklentinin örnek verilerini (yöntemleri de dâhil) genellikle jQuery'nin .data() yöntemini kullanarak doğrudan DOM öğesinde saklarız.

Basit bir "sayaç" eklentisi oluşturalım ve bir getValue yöntemi ekleyelim.

(function($) {
  $.fn.counterPlugin = function(options) {
    var settings = $.extend({
      initialValue: 0
    }, options);

    return this.each(function() {
      var $this = $(this);
      var value = settings.initialValue;

      var methods = {
        getValue: function() {
          return value;
        },
        increment: function() {
          value++;
          $this.text(value); // Update display
        },
        init: function() {
          $this.text(value); // Initial display
        }
      };

      // Store methods on the element's data
      $this.data('counterPlugin', methods);
      methods.init(); // Initialize display
    });
  };
})(jQuery);

// HTML: <div id="myCounter"></div>
// Usage: $('#myCounter').counterPlugin();
// Later: $('#myCounter').data('counterPlugin').getValue();

Genel Yöntemleri Çağırma

Eklentiniz başlatılıp yöntemleri .data() aracılığıyla saklandıktan sonra bunlara doğrudan erişip çağırabilirsiniz.

Önemli olan, önce öğeden saklanan örneği almak, ardından yöntemi bu örnek üzerinde çağırmaktır.

// Assume counterPlugin from previous scene is loaded

// HTML: <div id="myCounter"></div>

$(document).ready(function() {
  // Initialize the plugin
  $('#myCounter').counterPlugin({ initialValue: 5 });

  // Get the plugin instance
  var counterInstance = $('#myCounter').data('counterPlugin');

  // Call public methods
  console.log("Current value: " + counterInstance.getValue());
  counterInstance.increment();
  console.log("After increment: " + counterInstance.getValue());
});

Geri Çağırmalar Nelerdir?

Geri çağırma işlevleri, eklentinize aktardığınız ve eklentinin yaşam döngüsü sırasında belirli noktalarda veya belirli dahili olaylar gerçekleştiğinde çalıştırdığı işlevlerdir.

Kullanıcıların eklentinizin davranışına "bağlanmasına" ve eklentinin kaynak kodunu değiştirmeden kendi özel mantıklarını eklemesine olanak tanırlar.

  • Bunları eklentinin dahili eylemleri için olay dinleyicileri gibi düşünebilirsiniz.
  • Yaygın geri çağırmalar: onInit, onChange, onComplete.

Geri Çağırma Uygulama

Bir geri çağırma uygulamak için önce onu eklentinizin varsayılan seçeneklerinde tanımlayın. Ardından eklentinizin içinde, ilgili olay gerçekleştiğinde gerekli verileri aktararak bu işlevi çağırın.

Sayaç eklentimizi bir onChange geri çağırmasıyla genişletelim.

(function($) {
  $.fn.counterPlugin = function(options) {
    var settings = $.extend({
      initialValue: 0,
      onChange: function(newValue) {} // Default empty callback
    }, options);

    return this.each(function() {
      var $this = $(this);
      var value = settings.initialValue;

      var methods = {
        getValue: function() {
          return value;
        },
        increment: function() {
          value++;
          $this.text(value);
          // Call the callback when value changes
          settings.onChange.call($this[0], value); 
        },
        init: function() {
          $this.text(value);
        }
      };

      $this.data('counterPlugin', methods);
      methods.init();
    });
  };
})(jQuery);

// Usage: See next scene!

Geri Çağırma İşlevlerini Aktarma

Kullanıcılar özel geri çağırma işlevlerini başlatma sırasında doğrudan eklentinin seçenekler nesnesi içinde aktarır. Bu işlevler daha sonra uygun zamanda eklenti tarafından çağrılır.

.call($this[0], value) kullanımına dikkat edin. Bu ifade, geri çağırmanın içindeki this değerini DOM öğesi olarak ayarlar ve yeni değeri bağımsız değişken olarak aktarır.

// Assume counterPlugin with onChange callback is loaded

// HTML: <div id="myCounter"></div>

$(document).ready(function() {
  $('#myCounter').counterPlugin({
    initialValue: 10,
    onChange: function(newValue) {
      console.log("Counter changed to: " + newValue + " on element: " + this.id);
      if (newValue % 2 === 0) {
        $(this).css('color', 'blue');
      } else {
        $(this).css('color', 'red');
      }
    }
  });

  var counterInstance = $('#myCounter').data('counterPlugin');
  counterInstance.increment(); // Triggers callback
  counterInstance.increment(); // Triggers callback
});

Birden Çok Yöntem ve Geri Çağırma

Eklentiniz içinde çeşitli olayları yönetmek için birden çok genel yöntem ve birkaç farklı geri çağırma tanımlayabilirsiniz. Bu, esnek ve güçlü bir bileşen oluşturur.

  • Genel yöntemler, kullanıcıların eklentiye komut vermesini sağlar.
  • Geri çağırmalar, eklentinin neler olduğunu kullanıcı koduna bildirmesini sağlar.
(function($) {
  $.fn.advancedCounter = function(options) {
    var settings = $.extend({
      initial: 0,
      onIncrement: null, // New callback
      onDecrement: null, // New callback
      onReset: null      // New callback
    }, options);

    return this.each(function() {
      var $this = $(this);
      var value = settings.initial;

      var methods = {
        getValue: function() { return value; },
        increment: function() {
          value++;
          $this.text(value);
          if ($.isFunction(settings.onIncrement)) {
            settings.onIncrement.call($this[0], value);
          }
        },
        decrement: function() {
          value--;
          $this.text(value);
          if ($.isFunction(settings.onDecrement)) {
            settings.onDecrement.call($this[0], value);
          }
        },
        reset: function() {
          value = settings.initial;
          $this.text(value);
          if ($.isFunction(settings.onReset)) {
            settings.onReset.call($this[0], value);
          }
        },
        init: function() { $this.text(value); }
      };

      $this.data('advancedCounter', methods);
      methods.init();
    });
  };
})(jQuery);

// HTML: <div id="myAdvancedCounter"></div>
$(document).ready(function() {
  $('#myAdvancedCounter').advancedCounter({
    initial: 100,
    onIncrement: function(v) { console.log("Inc: " + v); },
    onReset: function(v) { console.log("Reset to: " + v); }
  });
  var inst = $('#myAdvancedCounter').data('advancedCounter');
  inst.increment();
  inst.reset();
});

Genel Yöntem ve Geri Çağırma İpuçları

Eklentinizin genel arayüzünü tasarlarken şu ipuçlarını aklınızda bulundurun:

  • Tutarlı Adlandırma: Yöntemler ve geri çağırmalar için açık ve açıklayıcı adlar kullanın.
  • Hata Yönetimi: Çağırmadan önce geri çağırmaların gerçekten işlev olup olmadığını kontrol edin (örneğin, $.isFunction(settings.onComplete)).
  • Bağlam: Geri çağırmaların this bağlamını, çoğu zaman eklentinin uygulandığı öğe olacak şekilde ayarlamak için .call() veya .apply() kullanın.
  • Bağımsız Değişkenler: Geri çağırmalara ilgili verileri aktarın (örneğin, yeni değer veya olay nesnesi).

Eklenti Etkileşimi Sınavı

#myElement üzerinde başlatılmış bir jQuery eklentisini düşünün. Eklentinin doSomething() adlı bir genel yöntemi ve bir onComplete geri çağırması vardır.

Hangi kod parçası genel yöntemi doğru şekilde çağırır VE başlatma sırasında özel bir geri çağırma aktarır?

Özet ve Sonraki Adımlar

jQuery eklentilerinizi gerçekten etkileşimli ve esnek hâle getirmeyi öğrendiniz!

  • Genel yöntemler, eklentiniz başlatıldıktan sonra dış kodun onu denetlemesine ve sorgulamasına olanak tanır.
  • Geri çağırmalar, kullanıcıların özel mantık eklemesi ve dahili eklenti olaylarına tepki vermesi için bağlantı noktaları sağlar.

Bu teknikler sağlam, yeniden kullanılabilir ve kullanıcı dostu jQuery eklentileri oluşturmak için çok önemlidir.

Sıkça Sorulan Sorular

“Genel Yöntemleri ve Geri Çağrıları Entegre Etme” dersi ücretsiz mi?

Evet — “Genel Yöntemleri ve Geri Çağrıları Entegre Etme” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve jQuery Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. jQuery Academy kursu toplamda 3 dersten oluşur.

“Genel Yöntemleri ve Geri Çağrıları Entegre Etme” dersinde ne öğreneceğim?

Harici etkileşim için eklentilerinize genel yöntemler ekleyin ve kullanıcıların belirli eklenti olaylarına bağlanabilmesi için geri çağırma işlevleri ekleyin. jQuery Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

jQuery Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te jQuery Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 3 dersinin 3. dersidir.

“Genel Yöntemleri ve Geri Çağrıları Entegre Etme” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu jQuery Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her jQuery Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. Eklenti Tasarım Kalıpları ve Kapsamlandırma
  2. Yapılandırılabilir ve Yeniden Kullanılabilir Eklentiler Oluşturma
  3. Genel Yöntemleri ve Geri Çağrıları Entegre Etme
← jQuery Academy Sayfasına Dön