DoneJS StealJS jQuery++ FuncUnit DocumentJS
4.3.0
5.0.0 3.13.1 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-bind
      • can-compute
      • can-debug
      • can-define
      • can-define/list/list
      • can-define/map/map
      • can-define-backup
      • can-define-stream
      • can-define-stream-kefir
      • can-event-queue
      • can-kefir
      • can-list
      • can-map
      • can-map-define
      • can-observation
      • can-observation-recorder
      • can-observe
      • can-simple-map
      • can-simple-observable
      • can-stream
      • can-stream-kefir
      • can-value
    • Data Modeling
      • can-connect
      • can-connect-feathers
      • can-fixture
      • can-fixture-socket
      • can-ndjson-stream
      • can-set
    • Views
      • can-component
      • can-stache
      • can-stache-bindings
      • can-stache-converters
      • can-stache-route-helpers
      • can-view-autorender
      • can-view-callbacks
      • 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-hash
      • can-route-mock
      • can-route-pushstate
    • JS Utilities
      • can-assign
      • can-define-lazy-value
      • can-diff
        • ./deep/
        • ./list/
        • ./map/
        • ./merge-deep/
        • ./patcher/
      • can-globals
      • can-join-uris
      • can-key
      • can-key-tree
      • can-make-map
      • can-parse-uri
      • can-queues
      • can-string
      • can-string-to-any
      • can-util
      • can-zone
      • can-zone-storage
    • DOM Utilities
      • can-ajax
      • can-attribute-encoder
      • can-child-nodes
      • can-control
      • can-dom-data
      • can-dom-events
      • can-dom-mutate
      • can-event-dom-enter
      • can-event-dom-radiochange
      • can-fragment
    • 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-data-types
      • can-namespace
      • can-reflect
      • can-reflect-dependencies
      • 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-diff/list/list

  • Edit on GitHub

Return a difference of two lists.

diffList( oldList, newList, [identity] )

Compares two lists and produces a sequence of patches that can be applied to make oldList take the shape of newList.

var diffList = require("can-diff/list/list");

console.log(diff([1], [1, 2])); // -> [{type: "splice", index: 1, deleteCount: 0, insert: [2]}]
console.log(diff([1, 2], [1])); // -> [{type: "splice", index: 1, deleteCount: 1, insert: []}]

// with an optional identity function:
diffList(
    [{id:1},{id:2}],
    [{id:1},{id:3}],
    (a,b) => a.id === b.id
); // -> [{type: "splice", index: 1, deleteCount: 1, insert: [{id:3}]}]

The patch algorithm is linear with respect to the length of the lists and therefore does not produce a perfect edit distance (which would be at least quadratic).

It is designed to work with most common list change scenarios, when items are inserted or removed to a list (as opposed to moved with in the last).

For example, it is able to produce the following patches:

diffList(
    ["a","b","c","d"],
    ["a","b","X","Y","c","d"]
); // -> [{type: "splice", index: 2, deleteCount: 0, insert: ["X","Y"]}]

Parameters

  1. oldList {ArrayLike}:

    The source array or list to diff from.

  2. newList {ArrayLike}:

    The array or list to diff to.

  3. schemaOrIdentity {function|getSchema(valueOrType)}:

    An optional identity function or a schema with an identity property for comparing elements. If a schemaOrIdentity is not provided, the schema of the oldList will be used. If a schema can not be found, items a default identity function will be created that checks if the two values are strictly equal ===.

Returns

{Array}:

An array of Patch objects representing the differences

Returns the difference between two ArrayLike objects (that have nonnegative integer keys and the length property) as an array of patch objects.

A patch object returned by this function has the following properties:

  • type: the type of patch ("splice").
  • index: the index of newList where the patch begins
  • deleteCount: the number of items deleted from that index in newList
  • insert: an Array of items newly inserted at that index in newList

Patches should be applied in the order they are returned.

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

On this page

Get help

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