const {diff} = require('jest-diff'); in CommonJS modules
import {diff} from 'jest-diff'; in ECMAScript modules
Example of diff()
const a = ['delete', 'common', 'changed from'];const b = ['common', 'changed to', 'insert'];const difference = diff(a, b);
The returned string consists of:
annotation lines: describe the two change indicators with labels, and a blank line
comparison lines: similar to “unified” view on GitHub, but Expected lines are green, Received lines are red, and common lines are dim (by default, see Options)
' Comparing two different types of values. …' if the arguments have different types according to the jest-get-type package (instances of different classes have the same 'object' type)
'Compared values have no visual difference.' if the arguments have either referential identity according to Object.is method or same serialization according to the pretty-format package
null if either argument is a so-called asymmetric matcher in Jasmine or Jest
Usage of diffStringsUnified
Given strings, diffStringsUnified(a, b, options?) does the following:
compare the strings character-by-character using the diff-sequences package
clean up small (often coincidental) common substrings, also known as chaff
format the changed or common lines using the chalk package
Although the function is mainly for multiline strings, it compares any strings.
Write either of the following:
const {diffStringsUnified} = require('jest-diff'); in CommonJS modules
import {diffStringsUnified} from 'jest-diff'; in ECMAScript modules
Example of diffStringsUnified
const a = 'common\nchanged from';const b = 'common\nchanged to';const difference = diffStringsUnified(a, b);
The returned string consists of:
annotation lines: describe the two change indicators with labels, and a blank line
comparison lines: similar to “unified” view on GitHub, and changed substrings have inverse foreground and background colors (that is, from has white-on-green and to has white-on-red, which the following example does not show)
- Expected+ Received common- changed from+ changed to
Performance of diffStringsUnified
To get the benefit of changed substrings within the comparison lines, a character-by-character comparison has a higher computational cost (in time and space) than a line-by-line comparison.
If the input strings can have arbitrary length, we recommend that the calling code set a limit, beyond which splits the strings, and then calls diffLinesUnified instead. For example, Jest falls back to line-by-line comparison if either string has length greater than 20K characters.
Usage of diffLinesUnified
Given arrays of strings, diffLinesUnified(aLines, bLines, options?) does the following:
compare the arrays line-by-line using the diff-sequences package
format the changed or common lines using the chalk package
You might call this function when strings have been split into lines and you do not need to see changed substrings within lines.
Edge cases of diffLinesUnified or diffStringsUnified
Here are edge cases for arguments and return values:
both a and b are empty strings: no comparison lines
only a is empty string: all comparison lines have bColor and bIndicator (see Options)
only b is empty string: all comparison lines have aColor and aIndicator (see Options)
a and b are equal non-empty strings: all comparison lines have commonColor and commonIndicator (see Options)
Usage of diffLinesUnified2
Given two pairs of arrays of strings, diffLinesUnified2(aLinesDisplay, bLinesDisplay, aLinesCompare, bLinesCompare, options?) does the following:
compare the pair of Compare arrays line-by-line using the diff-sequences package
format the corresponding lines in the pair of Display arrays using the chalk package
Jest calls this function to consider lines as common instead of changed if the only difference is indentation.
You might call this function for case insensitive or Unicode equivalence comparison of lines.
Example of diffLinesUnified2
import {format} from 'pretty-format';const a = { text: 'Ignore indentation in serialized object', time: '2019-09-19T12:34:56.000Z', type: 'CREATE_ITEM',};const b = { payload: { text: 'Ignore indentation in serialized object', time: '2019-09-19T12:34:56.000Z', }, type: 'CREATE_ITEM',};const difference = diffLinesUnified2( // serialize with indentation to display lines format(a).split('\n'), format(b).split('\n'), // serialize without indentation to compare lines format(a, {indent: 0}).split('\n'), format(b, {indent: 0}).split('\n'),);
The text and time properties are common, because their only difference is indentation:
- Expected+ Received Object {+ payload: Object { text: 'Ignore indentation in serialized object', time: '2019-09-19T12:34:56.000Z',+ }, type: 'CREATE_ITEM', }
The preceding example illustrates why (at least for indentation) it seems more intuitive that the function returns the common line from the bLinesDisplay array instead of from the aLinesDisplay array.
Usage of diffStringsRaw
Given strings and a boolean option, diffStringsRaw(a, b, cleanup) does the following:
compare the strings character-by-character using the diff-sequences package
optionally clean up small (often coincidental) common substrings, also known as chaff
Because diffStringsRaw returns the difference as data instead of a string, you can format it as your application requires (for example, enclosed in HTML markup for browser instead of escape sequences for console).
The returned array describes substrings as instances of the Diff class, which calling code can access like array tuples:
The value at index 0 is one of the following:
value
named export
description
0
DIFF_EQUAL
in a and in b
-1
DIFF_DELETE
in a but not in b
1
DIFF_INSERT
in b but not in a
The value at index 1 is a substring of a or b or both.
If you call string.split('\n') for an empty string:
the result is [''] an array which contains an empty string
instead of [] an empty array
Depending of your application, you might call diffLinesRaw with either array.
Example of split method
import {diffLinesRaw} from 'jest-diff';const a = 'non-empty string';const b = '';const diffs = diffLinesRaw(a.split('\n'), b.split('\n'));
i
diffs[i][0]
diffs[i][1]
0
-1
'non-empty string'
1
1
''
Which you might format as follows:
- Expected - 1+ Received + 1- non-empty string+
Example of splitLines0 function
For edge case behavior like the diffLinesUnified function, you might define a splitLines0 function, which given an empty string, returns [] an empty array:
import {diffLinesRaw} from 'jest-diff';const a = '';const b = 'line 1\nline 2\nline 3';const diffs = diffLinesRaw(a.split('\n'), b.split('\n'));
i
diffs[i][0]
diffs[i][1]
0
1
'line 1'
1
1
'line 2'
2
1
'line 3'
Which you might format as follows:
- Expected - 0+ Received + 3+ line 1+ line 2+ line 3
In contrast to the diffLinesRaw function, the diffLinesUnified and diffLinesUnified2 functions automatically convert array arguments computed by string split method, so callers do not need a splitLine0 function.
Options
The default options are for the report when an assertion fails from the expect package used by Jest.
For other applications, you can provide an options object as a third argument:
Although the default inverse of foreground and background colors is hard to beat for changed substrings within lines, especially because it highlights spaces, if you want bold font weight on yellow background color:
import chalk from 'chalk';const options = { changeColor: chalk.bold.bgYellowBright,};
Example of option to format trailing spaces
Because diff() does not display substring differences within lines, formatting can help you see when lines differ by the presence or absence of trailing spaces found by /\s+$/ regular expression.
If change lines have a background color, then you can see trailing spaces.
If common lines have default dim color, then you cannot see trailing spaces. You might want yellowish background color to see them.
If a content line is empty, then the corresponding comparison line is automatically trimmed to remove the margin space (represented as a middle dot below) for the default indicators:
Indicator
untrimmed
trimmed
aIndicator
'-·'
'-'
bIndicator
'+·'
'+'
commonIndicator
' ·'
''
Example of option for sorting object keys
When two objects are compared their keys are printed in alphabetical order by default. If this was not the original order of the keys the diff becomes harder to read as the keys are not in their original position.
Use compareKeys to pass a function which will be used when sorting the object keys.
const a = {c: 'c', b: 'b1', a: 'a'};const b = {c: 'c', b: 'b2', a: 'a'};const options = { // The keys will be in their original order compareKeys: () => 0,};const difference = diff(a, b, options);
Depending on the implementation of compareKeys any sort order can be used.
const a = {c: 'c', b: 'b1', a: 'a'};const b = {c: 'c', b: 'b2', a: 'a'};const options = { // The keys will be in reverse order compareKeys: (a, b) => (a > b ? -1 : 1),};const difference = diff(a, b, options);