DoneJS StealJS jQuery++ FuncUnit DocumentJS
3.14.1
5.0.0 4.3.0 2.3.35
  • About
  • Guides
  • API Docs
  • Community
  • Contributing
  • Bitovi
    • Bitovi.com
    • Blog
    • Design
    • Development
    • Training
    • Open Source
    • About
    • Contact Us
  • About
  • Guides
  • API Docs
    • Observables
      • can-compute
      • can-define
      • can-define/list/list
      • can-define/map/map
      • can-define-stream
      • can-define-stream-kefir
      • can-event
        • static
          • addEventListener
          • bind
          • delegate
          • dispatch
          • listenTo
          • off
          • on
          • one
          • removeEventListener
          • stopListening
          • trigger
          • unbind
          • undelegate
      • can-event/async/async
      • can-event/batch/batch
      • can-event/lifecycle/lifecycle
      • can-kefir
      • can-list
      • can-map
      • can-map-backup
      • can-map-define
      • can-observation
      • can-observe
      • can-simple-map
      • can-simple-observable
      • can-stream
      • can-stream-kefir
    • Data Modeling
      • can-connect
      • can-connect-cloneable
      • can-connect-feathers
      • can-connect-ndjson
      • can-connect-signalr
      • can-fixture
      • can-fixture-socket
      • can-ndjson-stream
      • can-set
    • Views
      • can-component
      • can-ejs
      • can-element
      • can-react-component
      • can-stache
      • can-stache/helpers/route
      • can-stache-bindings
      • can-stache-converters
      • can-view-autorender
      • can-view-callbacks
      • can-view-href
      • can-view-import
      • can-view-live
      • can-view-model
      • can-view-nodelist
      • can-view-parser
      • can-view-scope
      • can-view-target
      • react-view-model
      • react-view-model/component
      • steal-stache
    • Routing
      • can-deparam
      • can-param
      • can-route
      • can-route-pushstate
    • JS Utilities
      • can-assign
      • can-define-lazy-value
      • can-globals
      • can-key-tree
      • can-make-map
      • can-parse-uri
      • can-string
      • can-string-to-any
      • can-util
      • can-zone
      • can-zone-storage
    • DOM Utilities
      • can-ajax
      • can-attribute-encoder
      • can-control
      • can-dom-events
      • can-event-dom-enter
      • can-event-dom-radiochange
      • can-jquery
    • Data Validation
      • can-define-validate-validatejs
      • can-validate
      • can-validate-interface
      • can-validate-legacy
      • can-validate-validatejs
    • Typed Data
      • can-cid
      • can-construct
      • can-construct-super
      • can-namespace
      • can-reflect
      • can-reflect-promise
      • can-types
    • Polyfills
      • can-symbol
      • can-vdom
    • Core
    • Infrastructure
      • can-global
      • can-test-helpers
    • Ecosystem
    • Legacy
  • Community
  • Contributing
  • GitHub
  • Twitter
  • Chat
  • Forum
  • News
Bitovi

can-event

  • npm package badge
  • Star
  • Edit on GitHub

Add event functionality into your objects.

The canEvent object provides a number of methods for handling events in objects. This functionality is best used by mixing the canEvent object into an object or prototype. However, event listeners can still be used even on objects that don't include canEvent.

All methods provided by canEvent assume that they are mixed into an object -- this should be the object dispatching the events.

assign(YourClass.prototype, canEvent)

Adds event functionality to YourClass objects. This can also be applied to normal objects: assign(someObject, canEvent).

The assign function can be any function that assigns additional properties on an object such as Object.assign or lodash's _.assign or assign.

import assign from "can-util/js/assign/assign";
import canEvent from "can-event";

function Thing() {

}

assign( Thing.prototype, canEvent );

const thing = new Thing();
thing.addEventListener( "prop", function() { /* ... */ } );

Using as a mixin

The easiest way to add events to your classes and objects is by mixing can-event into your object or prototype.

var SomeClass = Construct("SomeClass", {
    init: function() {
        this.value = 0;
    },
    increment: function() {
        this.value++;
        this.dispatch("change", [this.value]);
    }
});
Object.assign(SomeClass.prototype, canEvent);

Now that canEvent is included in the prototype, we can add/remove/dispatch events on the object instances.

var instance = new SomeClass();
instance.on("change", function(ev, value) {
    alert("The instance changed to " + value);
});

// This will dispatch the "change" event and show the alert
instance.increment();

Using without mixing in

The same event functionality from canEvent can be used, even if the given object doesn't include canEvent. Every method within canEvent supports being called with an alternate scope.

var obj = {};

canEvent.addEventListener.call(obj, "change", function() {
    alert("object change!");
});

// This will dispatch the "change" event and show the alert
canEvent.dispatch.call(obj, "change");

CanJS is part of DoneJS. Created and maintained by the core DoneJS team and Bitovi. Currently 3.14.1.

On this page

Get help

  • Chat with us
  • File an issue
  • Ask questions
  • Read latest news