Fuzzy String Matching: similarity vs string-similarity vs string-similarity-js

When building search bars, auto-correct features, or data deduplication tools, exact string matches are rarely enough. Users make typos, and data comes in inconsistent formats. This is where fuzzy matching libraries come in. similarity, string-similarity, and string-similarity-js are the top contenders in the JavaScript ecosystem, but they solve the problem using different math and offer different levels of maintenance confidence.

🧮 Core Algorithms: Edit Distance vs. N-Grams

The most critical technical difference lies in the algorithm. This dictates how "similarity" is calculated and impacts performance on different string lengths.

similarity uses the Levenshtein Distance algorithm.

• It counts the minimum number of single-character edits (insertions, deletions, substitutions) required to change one word into the other.
• Better for detecting typos in longer strings where order matters significantly.
• Computationally heavier on very long strings (O(n*m) complexity).

// similarity: Levenshtein based
import similarity from 'similarity';

// Returns a number between 0 and 1
const score = similarity('kitten', 'sitting'); 
// Output: ~0.57 (3 edits needed)

string-similarity and string-similarity-js use the Sorensen-Dice Coefficient.

• They break strings into bigrams (pairs of characters) and compare the overlap.
• Faster on short to medium strings.
• Often yields more intuitive results for search suggestions and short queries.

// string-similarity: Dice Coefficient
import stringSimilarity from 'string-similarity';

const score = stringSimilarity.compareTwoStrings('kitten', 'sitting');
// Output: 0.666... (Based on bigram overlap)

// string-similarity-js: Dice Coefficient
import stringSimilarity from 'string-similarity-js';

const score = stringSimilarity.compareTwoStrings('kitten', 'sitting');
// Output: 0.666... (Same algorithm, different package)

🛠️ API Design and Features

While similarity offers a single function for direct comparison, the string-similarity family provides a richer API for handling lists of candidates, which is common in search UI.

similarity is minimal.

• Exports a single function.
• You must write your own loop to find the best match in an array.

// similarity: Manual best match
import similarity from 'similarity';

const target = 'apple';
const candidates = ['apply', 'banana', 'app'];

const best = candidates.reduce((prev, curr) => {
  return similarity(curr, target) > prev.score 
    ? { name: curr, score: similarity(curr, target) } 
    : prev;
}, { name: '', score: 0 });

string-similarity and string-similarity-js include helpers.

• compareTwoStrings: Direct comparison.
• findBestMatch: Automatically ranks an array of targets.
• Saves development time for autocomplete features.

// string-similarity: Built-in best match
import stringSimilarity from 'string-similarity';

const target = 'apple';
const candidates = ['apply', 'banana', 'app'];

const match = stringSimilarity.findBestMatch(target, candidates);
// Returns { bestMatch: ..., ratings: [...] }
console.log(match.bestMatch.target);

// string-similarity-js: Built-in best match
import stringSimilarity from 'string-similarity-js';

const target = 'apple';
const candidates = ['apply', 'banana', 'app'];

const match = stringSimilarity.findBestMatch(target, candidates);
// API is identical to original string-similarity
console.log(match.bestMatch.target);

⚠️ Maintenance and Security Status

For architectural decisions, package health is as important as code quality. A library that is no longer maintained poses a security and compatibility risk.

similarity

• Historically stable due to its simplicity.
• Low surface area for bugs.
• Verify current repo activity before adopting for critical infrastructure.

string-similarity

• Widely adopted but has faced periods of low maintenance activity.
• Past concerns about unmerged PRs and slow issue resolution led the community to seek alternatives.
• Use with caution in long-term enterprise projects.

string-similarity-js

• Created specifically to address maintenance concerns with the original.
• Actively maintained fork.
• Recommended for new projects requiring the Dice coefficient algorithm.

🌐 Real-World Scenarios

Scenario 1: Search Autocomplete

You need to match user input against a list of product names.

• ✅ Best choice: string-similarity-js
• Why? The findBestMatch helper saves code, and the Dice coefficient handles partial matches well. Active maintenance ensures stability.

import stringSimilarity from 'string-similarity-js';

function suggest(query, products) {
  return stringSimilarity.findBestMatch(query, products).bestMatch.target;
}

Scenario 2: Password Similarity Check

You need to ensure a new password is not too close to the old one (security policy).

• ✅ Best choice: similarity
• Why? Levenshtein distance is the standard for security policies regarding character changes. It is stricter and more predictable for this use case.

import similarity from 'similarity';

function validatePassword(old, newPwd) {
  if (similarity(old, newPwd) > 0.6) {
    throw new Error('Password too similar to previous one');
  }
}

Scenario 3: Data Deduplication

You have a list of company names ("Inc.", "Incorporated", "Ltd") and need to merge duplicates.

• ✅ Best choice: string-similarity-js
• Why? N-gram matching handles abbreviations and slight variations better than strict edit distance.

import stringSimilarity from 'string-similarity-js';

const score = stringSimilarity.compareTwoStrings('Acme Inc', 'Acme Incorporated');
// High score expected due to shared bigrams

📊 Summary Table

💡 The Big Picture

similarity is the specialist tool 🛠️ for when you care about exact character edits. It is mathematically rigorous for security or diffing tools but lacks convenience features for search UIs.

string-similarity is the veteran 🎖️ that popularized fuzzy matching in JS. While its API is excellent, the maintenance risk makes it hard to recommend for new greenfield projects in 2024 and beyond.

string-similarity-js is the modern successor 🚀. It keeps the API developers love while fixing the maintenance risks. For most frontend architects building search or suggestion features, this is the default choice.

Final Thought: Don't just pick the most downloaded package. Pick the one whose algorithm matches your data shape and whose maintenance status matches your risk tolerance. For most UI search tasks, string-similarity-js offers the best balance of features and safety.