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
      • can-event/async/async
      • can-event/batch/batch
      • can-event/lifecycle/lifecycle
      • can-kefir
      • can-list
        • Prototype
          • attr
          • concat
          • each
          • filter
          • forEach
          • indexOf
          • join
          • map
          • pop
          • push
          • replace
          • reverse
          • shift
          • slice
          • splice
          • unshift
        • Static
          • Map
          • extend
      • 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

replace

  • Edit on GitHub

Replace all the elements of a List.

list.replace(collection)

Parameters

  1. collection {Array|can-list|can.Deferred}:

    the collection of new elements to use If a [can.Deferred] is passed, it must resolve to an Array or can-list. The elements of the list are not actually removed until the Deferred resolves.

replace replaces all the elements of this List with new ones.

replace is especially useful when can-lists are live-bound into can-controls, and you intend to populate them with the results of a [can-model] call:

can.Control({
    init: function() {
        this.list = new Todo.List();
        // live-bind the list into the DOM
        this.element.html(can.view('list.stache', this.list));
        // when this AJAX call returns, the live-bound DOM will be updated
        this.list.replace(Todo.findAll());
    }
});

Learn more about [can.Model.List making Lists of models].

Events

A major difference between replace and attr(newElements, true) is that replace always emits an add event and a remove event, whereas attr will cause set events along with an add or remove event if needed. Corresponding change and length events will be fired as well.

The differences in the events fired by attr and replace are demonstrated concretely by this example:

var attrList = new List(['Alexis', 'Bill']);
attrList.bind('change', function(ev, index, how, newVals, oldVals) {
    console.log(index + ', ' + how + ', ' + newVals + ', ' + oldVals);
});

var replaceList = new List(['Alexis', 'Bill']);
replaceList.bind('change', function(ev, index, how, newVals, oldVals) {
    console.log(index + ', ' + how + ', ' + newVals + ', ' + oldVals);
});

attrList.attr(['Adam', 'Ben'], true);         // 0, set, Adam, Alexis
                                              // 1, set, Ben, Bill
replaceList.replace(['Adam', 'Ben']);         // 0, remove, undefined, ['Alexis', 'Bill']
                                              // 0, add, ['Adam', 'Ben'], ['Alexis', 'Bill']

attrList.attr(['Amber'], true);               // 0, set, Amber, Adam
                                              // 1, remove, undefined, Ben
replaceList.replace(['Amber']);               // 0, remove, undefined, ['Adam', 'Ben']
                                              // 0, add, Amber, ['Adam', 'Ben']

attrList.attr(['Alice', 'Bob', 'Eve'], true); // 0, set, Alice, Amber
                                              // 1, add, ['Bob', 'Eve'], undefined
replaceList.replace(['Alice', 'Bob', 'Eve']); // 0, remove, undefined, Amber
                                              // 0, add, ['Alice', 'Bob', 'Eve'], Amber

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