Fuzzysort is a fast and powerful fuzzy search library for JavaScript. It allows you to perform fuzzy searching on arrays of strings or objects, providing ranked results based on their similarity to the search query.
Basic Fuzzy Search
This feature allows you to perform a basic fuzzy search on an array of strings. The results are ranked based on their similarity to the search query 'twl'.
const fuzzysort = require('fuzzysort');
const results = fuzzysort.go('twl', ['twilight', 'twelve', 'two', 'towel']);
console.log(results.map(result => result.target));Fuzzy Search on Objects
This feature allows you to perform a fuzzy search on an array of objects. The 'key' option specifies which property of the objects to search within.
const fuzzysort = require('fuzzysort');
const books = [
{title: 'The Great Gatsby'},
{title: 'The Grapes of Wrath'},
{title: 'Great Expectations'}
];
const results = fuzzysort.go('grt', books, {key: 'title'});
console.log(results.map(result => result.obj.title));Highlighting Matches
This feature allows you to highlight the matching parts of the search results. The 'highlight' function wraps the matching parts with the specified HTML tags.
const fuzzysort = require('fuzzysort');
const results = fuzzysort.go('grt', ['The Great Gatsby', 'The Grapes of Wrath', 'Great Expectations']);
results.forEach(result => {
console.log(fuzzysort.highlight(result, '<b>', '</b>'));
});Fuse.js is a lightweight fuzzy-search library that supports searching through arrays of strings and objects. It offers a rich set of options for fine-tuning the search behavior, such as setting the search threshold, specifying keys for object searches, and more. Compared to fuzzysort, Fuse.js provides more configuration options but may be slightly slower in performance.
Lunr is a full-text search library for JavaScript. It allows you to create an index of your documents and perform searches on that index. Lunr is more suitable for larger datasets and provides more advanced search features like boosting and field-specific search. However, it is more complex to set up compared to fuzzysort.
JS-Search is a client-side search library that allows you to index and search JavaScript objects. It supports tokenization, stemming, and custom scoring functions. JS-Search is more focused on providing a full-text search experience and is more configurable than fuzzysort, but it may not be as fast for simple fuzzy searches.
Fast, Tiny, & Good fuzzy search for JavaScript.
Fast: <1ms to search 13,000 files.
Tiny: 1 file, 0 dependencies, 5kb.
Good: clean api + sorts results well.
https://rawgit.com/farzher/fuzzysort/master/test/test.html
npm i fuzzysort
import fuzzysort from 'fuzzysort'
const fuzzysort = require('fuzzysort')
<script src="https://cdn.jsdelivr.net/npm/fuzzysort@3.0.2/fuzzysort.min.js"></script>
fuzzysort.go(search, targets, options=null)const mystuff = [{file: 'Apple.cpp'}, {file: 'Banana.cpp'}]
const results = fuzzysort.go('a', mystuff, {key: 'file'})
// [{score: 0.81, obj: {file: 'Apple.cpp'}}, {score: 0.59, obj: {file: 'Banana.cpp'}}]
fuzzysort.go(search, targets, {
threshold: 0, // Don't return matches worse than this
limit: 0, // Don't return more results than this
all: false, // If true, returns all results for an empty search
key: null, // For when targets are objects (see its example usage)
keys: null, // For when targets are objects (see its example usage)
scoreFn: null, // For use with `keys` (see its example usage)
})
resultconst result = fuzzysort.single('query', 'some string that contains my query.')
result.score // .80 (1 is a perfect match. 0.5 is a good match. 0 is no match.)
result.target // 'some string that contains my query.'
result.obj // reference to your original obj when using options.key
result.indexes // [29, 30, 31, 32, 33]
result.highlight('<b>', '</b>')
// 'some string that contains my <b>query</b>.'
result.highlight((m, i) => <react key={i}>{m}</react>)
// ['some string that contains my ', <react key=0>query</react>, '.']
Search a list of objects, by multiple complex keys, with custom weights.
let objects = [{
title: 'Liechi Berry',
meta: {desc: 'Raises Attack when HP is low.'},
tags: ['berries', 'items'],
bookmarked: true,
}, {
title: 'Petaya Berry',
meta: {desc: 'Raises Special Attack when HP is low.'},
}]
let results = fuzzysort.go('attack berry', objects, {
keys: ['title', 'meta.desc', obj => obj.tags?.join()],
scoreFn: r => r.score * r.obj.bookmarked ? 2 : 1, // if the item is bookmarked, boost its score
})
var keysResult = results[0]
// When using multiple `keys`, results are different. They're indexable to get each normal result
keysResult[0].highlight() // 'Liechi <b>Berry</b>'
keysResult[1].highlight() // 'Raises <b>Attack</b> when HP is low.'
keysResult.score // .84
keysResult.obj.title // 'Liechi Berry'
let targets = [{file: 'Monitor.cpp'}, {file: 'MeshRenderer.cpp'}]
// filter out targets that you don't need to search! especially long ones!
targets = targets.filter(t => t.file.length < 1000)
// if your targets don't change often, provide prepared targets instead of raw strings!
targets.forEach(t => t.filePrepared = fuzzysort.prepare(t.file))
// don't use options.key if you don't need a reference to your original obj
targets = targets.map(t => t.filePrepared)
const options = {
limit: 100, // don't return more results than you need!
threshold: .5, // don't return bad results
}
fuzzysort.go('gotta', targets, options)
fuzzysort.go('go', targets, options)
fuzzysort.go('fast', targets, options)
result.score is implemented as a getter/setter and stored different internally
r.score = .3; // r.score == 0.30000000000000004
keys and your search contains spaces!options.key can now be a function {key: obj => obj.tags.join()}fuzzysort.indexes & Added result.indexes (as a getter/setter for GC perf)fuzzysort.highlight() & Added result.highlight()straw berry now matches great against strawberryresult.score is behind a getter/setter for performance reasonsresult.indexes & Added fuzzysort.indexes (improved GC performance)options.allowTypofuzzysort.goAsyncfuzzysort.newoptions.alloptions.allowTypofuzzysort.goAsyncfuzzysort.highlight(result, callback)allowTypo as an optionkey/keys with custom weightsfuzzysort.highlightfuzzysort and moved them into fuzzysort.go optional paramsFAQs
Fast SublimeText-like fuzzy search for JavaScript
We found that fuzzysort demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
PyPI confirms no security flaws were exploited in the Ultralytics supply chain attack and highlights improvements for safer package publishing.
Security News
Research
The Socket Research Team breaks down a malicious wrapper package that uses obfuscation to harvest credentials and exfiltrate sensitive data.
Research
Security News
Attackers used a malicious npm package typosquatting a popular ESLint plugin to steal sensitive data, execute commands, and exploit developer systems.