String Matching, Sorting, and NLP Utilities in JavaScript
fuse.js, natural, string-natural-compare, and string-similarity address different aspects of string manipulation and matching in JavaScript applications. fuse.js specializes in fuzzy search, allowing users to find approximate matches in lists of data. natural is a comprehensive natural language processing (NLP) toolkit offering tokenizers, stemmers, and spellcheckers. string-natural-compare focuses on sorting strings in a human-friendly order (e.g., handling numbers within strings correctly). string-similarity provides algorithms to calculate the similarity score between two strings, often using Levenshtein distance. While they all deal with text, their use cases range from search bars to data sorting to linguistic analysis.
Npm Package Weekly Downloads Trend
Github Stars Ranking
Stat Detail
String Matching, Sorting, and NLP Utilities in JavaScript
When working with text data in JavaScript, developers often reach for utilities to handle searching, sorting, or analyzing strings. The packages fuse.js, natural, string-natural-compare, and string-similarity all operate in this space, but they solve fundamentally different problems. Understanding their specific strengths prevents over-engineering and ensures you pick the right tool for tasks like fuzzy search, natural sorting, or linguistic analysis.
๐ Search Strategy: Fuzzy Matching vs. Similarity Scoring
fuse.js is built for searching through a list of items. It indexes your data and allows you to query it with tolerance for misspellings.
// fuse.js: Search a list of objects
import Fuse from 'fuse.js';
const list = [
{ title: "The Right Way", author: "Goethe" },
{ title: "The Wrong Way", author: "Schiller" }
];
const fuse = new Fuse(list, { keys: ['title'] });
const results = fuse.search("rigth"); // Matches "Right" despite typo
string-similarity compares two specific strings and returns a score. It does not search a list; it tells you how close string A is to string B.
// string-similarity: Compare two strings
import stringSimilarity from 'string-similarity';
const target = "healed";
const input = "sealed";
const similarity = stringSimilarity.compareTwoStrings(target, input);
// Returns a number between 0 and 1 (e.g., 0.83)
natural includes spellcheckers and distance metrics but is part of a larger NLP suite. It is heavier if you only need simple similarity.
// natural: Levenshtein distance
import natural from 'natural';
const distance = natural.Levenshtein.distance("kitten", "sitting");
// Returns the number of edits required (e.g., 3)
string-natural-compare does not perform search or similarity scoring. It is strictly for ordering.
๐ Sorting Logic: Human-Friendly vs. ASCII
string-natural-compare solves the problem where standard sorting puts "file10" before "file2". It parses numbers inside strings.
// string-natural-compare: Sort with numbers
import naturalCompare from 'string-natural-compare';
const files = ["file2.txt", "file10.txt", "file1.txt"];
files.sort(naturalCompare);
// Result: ["file1.txt", "file2.txt", "file10.txt"]
natural also provides sorting capabilities but often requires more setup or is part of broader tokenization logic.
// natural: Sorting via tokenizer (more complex)
import natural from 'natural';
// Natural includes utilities but often developers use
// dedicated sort libs for simple array sorting tasks.
fuse.js and string-similarity do not handle sorting order. They return matches or scores, leaving the sorting to your application logic.
๐ง Linguistic Features: NLP vs. Simple Strings
natural is the only package here that acts as a full Natural Language Processing toolkit. It handles tokenization, stemming, and frequency analysis.
// natural: Tokenization and Stemming
import natural from 'natural';
const tokenizer = new natural.WordTokenizer();
const tokens = tokenizer.tokenize("Hello world, this is a test.");
// ["Hello", "world", "this", "is", "a", "test"]
const stemmer = natural.PorterStemmer;
const stemmed = stemmer.stem("running"); // "run"
fuse.js, string-similarity, and string-natural-compare treat strings as raw characters. They do not understand grammar, roots, or word boundaries.
// fuse.js: Treats text as characters for matching
// It does not stem "running" to "run" automatically unless configured
// with specific tokenizers, but primarily relies on character patterns.
โ๏ธ Configuration and Weighting
fuse.js offers deep configuration for search relevance. You can weight specific fields higher than others.
// fuse.js: Weighted search
const fuse = new Fuse(list, {
keys: [
{ name: "title", weight: 0.7 },
{ name: "author", weight: 0.3 }
],
threshold: 0.4 // Lower is stricter
});
string-similarity is straightforward with no configuration. It uses a standard algorithm (dice coefficient by default for similarity, Levenshtein for distance in natural).
// string-similarity: No config
const score = stringSimilarity.compareTwoStrings("apple", "appl");
// Fixed algorithm behavior
string-natural-compare has minimal options, mostly focused on case sensitivity.
// string-natural-compare: Case insensitive option
import naturalCompare from 'string-natural-compare';
// Default is case-insensitive, but behavior is consistent
// without complex configuration objects.
๐ Real-World Scenarios
Scenario 1: Implementing a Search Bar
You need a search bar that finds "iphone" even if the user types "ifone".
- โ
Best choice:
fuse.js - Why? It is optimized for searching lists of objects with typo tolerance.
const fuse = new Fuse(products, { keys: ['name'] });
const results = fuse.search(query);
Scenario 2: Sorting File Lists
You are displaying a list of versioned files like "v1.0", "v1.10", "v1.2".
- โ
Best choice:
string-natural-compare - Why? Standard sort will place "v1.10" before "v1.2". This package fixes that.
versions.sort(naturalCompare);
Scenario 3: Deduplicating User Inputs
Users submit tags, and you want to merge "javascript" and "javasript".
- โ
Best choice:
string-similarity - Why? You need to compare specific pairs to decide if they are close enough to merge.
if (stringSimilarity.compareTwoStrings(tag1, tag2) > 0.9) {
// Merge tags
}
Scenario 4: Analyzing Text Sentiment or Frequency
You need to count word frequencies or stem words for a search index.
- โ
Best choice:
natural - Why? It provides the NLP primitives (tokenizers, stemmers) required for analysis.
const tfidf = new natural.TfIdf();
tfidf.addDocument("this document is about node");
๐ Summary Table
| Feature | fuse.js | natural | string-natural-compare | string-similarity |
|---|---|---|---|---|
| Primary Goal | Fuzzy Search | NLP Toolkit | Natural Sorting | Similarity Score |
| Input Type | List of Objects | Strings/Text | Strings | Two Strings |
| Output | Matched Items | Tokens/Metrics | Sort Order (-1, 0, 1) | Score (0-1) or Distance |
| Typo Tolerance | โ Yes (Configurable) | โ Yes (via distance) | โ No | โ Yes (via score) |
| NLP Features | โ No | โ Yes (Stem, Tokenize) | โ No | โ No |
๐ก Final Recommendation
These libraries do not compete directly; they complement each other in a text-heavy application.
- Use
fuse.jsfor search interfaces. It is the industry standard for client-side fuzzy search. - Use
string-natural-comparefor UI lists involving versions, filenames, or numbered items. - Use
string-similarityfor data cleaning or validation where you compare specific pairs. - Use
naturalfor text analysis pipelines where you need to understand the content linguistically.
Final Thought: Avoid using natural for simple search tasks if fuse.js suffices, as natural brings significant overhead. Conversely, do not try to build a sorter using string-similarity; stick to the tool designed for the specific job.
How to Choose: fuse.js vs natural vs string-natural-compare vs string-similarity
- fuse.js:
Choose
fuse.jswhen you need to implement a client-side search feature that tolerates typos or partial matches. It is ideal for filtering lists of objects (like contacts or products) where exact string matching is too rigid. It offers extensive configuration for weighting fields and setting match thresholds. - natural:
Choose
naturalif your application requires broader natural language processing capabilities beyond simple matching, such as tokenization, stemming, or spellchecking. It is suitable for projects that need to analyze text structure or frequency, rather than just searching or sorting it. - string-natural-compare:
Choose
string-natural-comparewhen you need to sort arrays of strings containing numbers in a way that feels natural to humans (e.g., 'image2.jpg' before 'image10.jpg'). It is a lightweight utility specifically for sorting logic where standard alphabetical sorting fails. - string-similarity:
Choose
string-similaritywhen you need to calculate a numerical score representing how close two strings are to each other. It is best for deduplication tasks or suggesting corrections where you need to compare specific pairs of strings rather than searching a large dataset.
Popular Comparisons
README for fuse.js
Fuse.js
Fuse.js is a lightweight, zero-dependency fuzzy-search library written in TypeScript. It works in the browser and on the server, and is designed for searching small-to-medium datasets on the client side where you can't rely on a dedicated search backend.
โจ What's New: Token Search
Multi-word fuzzy search with relevance ranking. Type "javascrpt paterns" and find "JavaScript Patterns" โ typo tolerance, multiple words, and smart ranking all at once.
const fuse = new Fuse(docs, {
useTokenSearch: true,
keys: ['title', 'author', 'description']
})
fuse.search('javascrpt paterns')
// โ [{ item: { title: 'JavaScript Patterns', ... } }]
See Token Search below for details.
Web Workers
Search large datasets without freezing the UI. FuseWorker splits your data across multiple Web Workers and searches in parallel โ ~5x faster on 100K documents.
import { FuseWorker } from 'fuse.js/worker'
const fuse = new FuseWorker(docs, {
keys: ['title', 'author', 'description']
})
const results = await fuse.search('query')
fuse.terminate()
Same options and results as Fuse โ just async. Function-valued options (sortFn, getFn, keys[].getFn) aren't supported because functions can't be transferred to a worker; everything else carries over. See the Web Workers docs for the interactive demo and full API.
Installation
npm install fuse.js
yarn add fuse.js
Or include directly via CDN:
<script src="https://cdn.jsdelivr.net/npm/fuse.js/dist/fuse.min.mjs"></script>
Quick Start
import Fuse from 'fuse.js'
const books = [
{ title: "Old Man's War", author: 'John Scalzi' },
{ title: 'The Lock Artist', author: 'Steve Hamilton' },
{ title: 'HTML5', author: 'Remy Sharp' },
{ title: 'JavaScript: The Good Parts', author: 'Douglas Crockford' }
]
const fuse = new Fuse(books, {
keys: ['title', 'author']
})
fuse.search('javscript')
// โ [{ item: { title: 'JavaScript: The Good Parts', ... }, ... }]
Features
Fuzzy Search
The core of Fuse.js. Uses the Bitap algorithm for approximate string matching โ handles typos, misspellings, and partial matches out of the box.
fuse.search('javscript')
// โ [{ item: { title: 'JavaScript: The Good Parts', author: 'Douglas Crockford' } }]
Weighted Keys
Search across multiple fields with different importance levels. Title matches can rank higher than description matches.
const fuse = new Fuse(docs, {
keys: [
{ name: 'title', weight: 2 },
{ name: 'description', weight: 1 }
]
})
Extended Search
Use operators for precise control: exact match (=), prefix (^), suffix (!), and more. Enable with useExtendedSearch: true.
const fuse = new Fuse(list, {
useExtendedSearch: true,
keys: ['title']
})
fuse.search('=exact match') // exact match
fuse.search('^prefix') // starts with
fuse.search('!term') // does not include
Token Search
Splits multi-word queries into individual terms, fuzzy-matches each independently, and ranks results using BM25-style IDF weighting. Enable with useTokenSearch: true.
const fuse = new Fuse(docs, {
useTokenSearch: true,
keys: ['title', 'body']
})
fuse.search('express midleware rout')
// Finds "Express Middleware" and "Express Routing Guide" despite typos
- Typo tolerance per word โ each term is fuzzy-matched independently
- Relevance ranking โ rare terms are weighted higher than common ones
- Word order independent โ
"patterns javascript"and"javascript patterns"return identical results - No query length limit โ long multi-word queries work naturally since each term is searched separately
- AND or OR โ
tokenMatch: 'all'returns only records matching every word (filtering); the default'any'matches any word - Custom tokenizer โ pass a regex or function via
tokenizefor tokens with internal punctuation (node.js,c++), or useIntl.Segmenterfor CJK / Thai word segmentation. Unicode-aware by default
Available in the full build. See the Token Search docs for details and performance benchmarks.
Logical Search
Combine conditions with $and and $or for complex queries. Available in the full build.
fuse.search({
$and: [
{ title: 'javascript' },
{ author: 'crockford' }
]
})
Match Highlighting
Get character-level match indices for highlighting search results in your UI.
const fuse = new Fuse(list, {
includeMatches: true,
keys: ['title']
})
const result = fuse.search('javscript')
// result[0].matches[0].indices โ [[0, 9]]
Single String Matching
Use Fuse.match() to fuzzy-match a pattern against a single string without creating an index. Useful for one-off comparisons or custom filtering.
const result = Fuse.match('javscript', 'JavaScript: The Good Parts')
// โ { isMatch: true, score: 0.04, indices: [[0, 9]] }
Fuse.match() does not support useTokenSearch โ token search requires corpus-level statistics (df, fieldCount) that a one-off string comparison can't provide. Passing useTokenSearch: true throws an explicit error. Use new Fuse(docs, { useTokenSearch: true }).search(query) for token-search behavior.
Dynamic Collections
Add and remove documents from a live index without rebuilding.
fuse.add({ title: 'New Book', author: 'New Author' })
fuse.remove((doc) => doc.title === 'Old Book')
Builds
Fuse.js ships in two variants:
| Build | Includes | Min + gzip |
|---|---|---|
| Full | Fuzzy + Extended + Logical + Token search | ~8.6 kB |
| Basic | Fuzzy search only | ~6.8 kB |
Use the basic build if you only need fuzzy search and want the smallest bundle size.
Documentation
For the full API reference, configuration options, scoring theory, and interactive demos, visit fusejs.io.
Official ports
- fuse-swift: Swift port for iOS, macOS, tvOS, watchOS, visionOS, and Linux. Byte-equivalent results, idiomatic Swift API, syncs with each upstream release. Currently in 2.0.0-rc.1.
Supporting Fuse.js
- Become a backer or sponsor on GitHub
- Become a backer or sponsor on Patreon
- One-time donation via PayPal
Develop
See DEVELOPERS.md for setup, scripts, and project structure.
Contribute
See CONTRIBUTING.md for guidelines on issues and pull requests.