Nightingale Posing Mischievously
Wondering what’s next for npm?Check out our public roadmap! »


0.0.10 • Public • Published


quick-score is a JavaScript string-scoring and fuzzy-matching library based on the Quicksilver algorithm, designed for smart auto-complete.

Build Status Code Coverage Dependencies Minzip Size MIT License

QuickScore improves on the original Quicksilver algorithm by tuning the scoring for long strings, such as webpage titles or URLs, so that the order of the search results makes more sense. It's used by the QuicKey extension for Chrome to enable users to easily find an open tab via search.

QuickScore is fast, dependency-free, and is less than 2KB when minified and gzipped.


See QuickScore in action, and compare its results to other scoring and matching libraries.


npm install --save quick-score

If you prefer to use the built library files directly instead of using npm, you can download them from

Or you can load a particular release of the minified script directly from, and then access the library via the quickScore global:

<script src=""></script>
<script type="text/javascript">
    console.log(quickScore.quickScore("thought", "gh"));


Calling quickScore() directly

You can import the quickScore() function from the ES6 module:

import {quickScore} from "quick-score";

Or from a property of the CommonJS module:

const quickScore = require("quick-score").quickScore;

You can then call quickScore() with a string and a query to score against that string. It will return a floating point score between 0 and 1. A higher score means that string is a better match for the query. A 1 means the query is the highest match for the string, though the two strings may still differ in case and whitespace characters.

quickScore("thought", "gh");   // 0.4142857142857143
quickScore("GitHub", "gh");    // 0.9166666666666666

Matching gh against GitHub returns a higher score than thought, because it matches the capital letters in GitHub, which are weighted more highly.

Sorting lists of strings with a QuickScore instance

A typical use-case for string scoring is auto-completion, where you want the user to get to the desired result by typing as few characters as possible. Instead of calling quickScore() directly for every item in a list and then sorting it based on the score, it's simpler to use an instance of the QuickScore class:

import {QuickScore} from "quick-score";

const qs = new QuickScore(["thought", "giraffe", "GitHub", "hello, Garth"]);
const results ="gh");

        "item": "GitHub",
        "score": 0.9166666666666666,
        "matches": [[0, 1], [3, 4]]
        "item": "hello, Garth",
        "score": 0.6263888888888888,
        "matches": [[7, 8], [11, 12]]

The results array is a list of objects that represent the results of matching the query against each string that was passed to the constructor. It's sorted high to low on each item's score. Strings with identical scores are sorted alphabetically and case-insensitively. In the simple case of scoring bare strings, each item in the results array has three properties:

  • item: the string that was scored
  • score: the floating point score of the string for the current query
  • matches: an array of arrays that specifies the character ranges where the query matched the string

This array could then be used to render a list of matching results as the user types a query.

Sorting lists of objects

Typically, you'll be sorting items more complex than a bare string. To tell QuickScore which of an object's keys to score a query against, pass an array of key names or dot-delimited paths as the second parameter to the QuickScore() constructor:

const bookmarks = [
        "title": "lodash documentation",
        "url": ""
        "title": "Supplying Images - Google Chrome",
        "url": ""
const qs = new QuickScore(bookmarks, ["title", "url"]);
const results ="devel");

        "item": {
            "title": "Supplying Images - Google Chrome",
            "url": ""
        "score": 0.9138888888888891,
        "scoreKey": "url",
        "scores": {
            "title": 0,
            "url": 0.9138888888888891
        "matches": {
            "title": [],
            "url": [[0, 5]]

Each item in the results array has a few more properties when matching against objects:

  • item: the object that was scored
  • score: the highest score from among the individual key scores
  • scoreKey: the name of the key with the highest score, which will be an empty string if they're all zero
  • scores: a hash of the individual scores for each key
  • matches: a hash of arrays that specify the character ranges of the query match for each key

When two items have the same score, they're sorted alphabetically and case-insensitively on the first key in the keys array. In the example above, that would be title.

Each result item also has a _ property, which caches transformed versions of the item's strings, and might contain additional internal metadata in the future. It can be ignored.

Ignoring diacritics and accents when scoring

If the strings you're matching against contain diacritics on some of the letters, like à or ç, you may want to count a match even when the query string contains the unaccented forms of those letters. The QuickScore library doesn't contain support for this by default, since it's only needed with certain strings and the code to remove accents would triple its size. But it's easy to combine QuickScore with other libraries to ignore diacritics.

One example is the latinize npm package, which will strip accents from a string and can be used in a transformString() function that's passed as an option to the QuickScore constructor. This function takes a string parameter and returns a transformed version of that string:

// including latinize.js on the page creates a global latinize() function 
import {QuickScore} from "quick-score";

const items = ["Café", "Cafeteria"];
const qs = new QuickScore(items, { transformString: s => latinize(s).toLowerCase() });
const results ="cafe");

        "item": "Café",
        "score": 1,
        "matches": [[0, 4]],
        "_": "cafe"

transformString() will be called on each of the searchable keys in the items array as well as on the query parameter to the search() method. The default function calls toLocaleLowerCase() on each string, for a case-insensitive search. In the example above, the basic toLowerCase() call is sufficient, since latinize() will have already stripped the accents.

Highlighting matched letters

Many search interfaces highlight the letters in each item that match what the user has typed. The matches property of each item in the results array contains information that can be used to highlight those matching letters.

This function is an example of how an item could be highlighted using React. It surrounds each sequence of matching letters in a <mark> tag and then returns the full string in a <span>. You could then style the <mark> tag to be bold or a different color to highlight the matches. (Something similar could be done by concatenating plain strings of HTML tags, though you'll need to be careful to escape the substrings.)

function highglight(string, matches) {
    const substrings = [];
    let previousEnd = 0;

    for (let [start, end] of matches) {
        const prefix = string.substring(previousEnd, start);
        const match = <mark>{string.substring(start, end)}</mark>;

        substrings.push(prefix, match);
        previousEnd = end;


    return <span>{React.Children.toArray(substrings)}</span>;

The QuickScore demo uses this approach to highlight the matches, via the MatchedString component.


See the API docs for a full description of the QuickScore class and the quickScore function.


MIT © John Dunning


npm i quick-score

DownloadsWeekly Downloads






Unpacked Size

113 kB

Total Files


Last publish


  • avatar