diff

diff(actual: Any, expected: Any, diffConfig: { unordered?: Boolean } = {}, path: String = "(root)"): Diff

Returns the structural differences between two values.

Differences between objects can be ordered (the default) or unordered. Ordered means that two objects do not differ if their key-value pairs are in the same order. Differences are expressed as Difference type.

Parameters

Name Description

Name	Description
`actual`	The actual value. Can be any data type.
`expected`	The expected value to compare to the actual. Can be any data type.
`diffConfig`	Setting for changing the default to unordered using `{ "unordered" : true} (explained in the introduction).

actual

The actual value. Can be any data type.

expected

The expected value to compare to the actual. Can be any data type.

diffConfig

Setting for changing the default to unordered using `{ "unordered" : true} (explained in the introduction).

Example

This example shows a variety of uses of diff.

Source

import diff from dw::util::Diff
ns ns0 http://locahost.com
ns ns1 http://acme.com
output application/dw
---
{
  "a": diff({a: 1}, {b:1}),
  "b": diff({ns0#a: 1}, {ns1#a:1}),
  "c": diff([1,2,3], []),
  "d": diff([], [1,2,3]),
  "e": diff([1,2,3], [1,2,3, 4]),
  "f": diff([{a: 1}], [{a: 2}]),
  "g": diff({a @(c: 2): 1}, {a @(c: 3): 1}),
  "h": diff(true, false),
  "i": diff(1, 2),
  "j": diff("test", "other test"),
  "k": diff({a: 1}, {a:1}),
  "l": diff({ns0#a: 1}, {ns0#a:1}),
  "m": diff([1,2,3], [1,2,3]),
  "n": diff([], []),
  "o": diff([{a: 1}], [{a: 1}]),
  "p": diff({a @(c: 2): 1}, {a @(c:2): 1}),
  "q": diff(true, true),
  "r": diff(1, 1),
  "s": diff("other test", "other test"),
  "t": diff({a:1 ,b: 2},{b: 2, a:1}, {unordered: true}),
  "u": [{format: "ssn",data: "ABC"}] diff [{ format: "ssn",data: "ABC"}]
}

Output

ns ns0 http://locahost.com
ns ns1 http://acme.com
---
{
  a: {
    matches: false,
    diffs: [
      {
        expected: "Entry (root).a with type Number",
        actual: "was not present in object.",
        path: "(root).a"
      }
    ]
  },
  b: {
    matches: false,
    diffs: [
      {
        expected: "Entry (root).ns0#a with type Number",
        actual: "was not present in object.",
        path: "(root).ns0#a"
      }
    ]
  },
  c: {
    matches: false,
    diffs: [
      {
        expected: "Array size is 0",
        actual: "was 3",
        path: "(root)"
      }
    ]
  },
  d: {
    matches: false,
    diffs: [
      {
        expected: "Array size is 3",
        actual: "was 0",
        path: "(root)"
      }
    ]
  },
  e: {
    matches: false,
    diffs: [
      {
        expected: "Array size is 4",
        actual: "was 3",
        path: "(root)"
      }
    ]
  },
  f: {
    matches: false,
    diffs: [
      {
        expected: "1" as String {mimeType: "application/dw"},
        actual: "2" as String {mimeType: "application/dw"},
        path: "(root)[0].a"
      }
    ]
  },
  g: {
    matches: false,
    diffs: [
      {
        expected: "3" as String {mimeType: "application/dw"},
        actual: "2" as String {mimeType: "application/dw"},
        path: "(root).a.@.c"
      }
    ]
  },
  h: {
    matches: false,
    diffs: [
      {
        expected: "false",
        actual: "true",
        path: "(root)"
      }
    ]
  },
  i: {
    matches: false,
    diffs: [
      {
        expected: "2",
        actual: "1",
        path: "(root)"
      }
    ]
  },
  j: {
    matches: false,
    diffs: [
      {
        expected: "\"other test\"",
        actual: "\"test\"",
        path: "(root)"
      }
    ]
  },
  k: {
    matches: true,
    diffs: []
  },
  l: {
    matches: true,
    diffs: []
  },
  m: {
    matches: true,
    diffs: []
  },
  n: {
    matches: true,
    diffs: []
  },
  o: {
    matches: true,
    diffs: []
  },
  p: {
    matches: true,
    diffs: []
  },
  q: {
    matches: true,
    diffs: []
  },
  r: {
    matches: true,
    diffs: []
  },
  s: {
    matches: true,
    diffs: []
  },
  t: {
    matches: true,
    diffs: []
  },
  u: {
    matches: true,
    diffs: []
  }
}