文字列を比較するJavascriptは%of Likelyを返します


87

2つの文字列を比較して、それらが類似している可能性を返すことができるJavaScript関数を探しています。私はsoundexを見てきましたが、それは複数の単語の文字列や名前以外の場合にはあまり適していません。私は次のような関数を探しています:

function compare(strA,strB){

}

compare("Apples","apple") = Some X Percentage.

この関数は、数値、複数単語の値、名前など、すべてのタイプの文字列で機能します。おそらく、私が使用できる簡単なアルゴリズムがありますか?

Ultimately none of these served my purpose so I used this:

 function compare(c, u) {
        var incept = false;
        var ca = c.split(",");
        u = clean(u);
        //ca = correct answer array (Collection of all correct answer)
        //caa = a single correct answer word array (collection of words of a single correct answer)
        //u = array of user answer words cleaned using custom clean function
        for (var z = 0; z < ca.length; z++) {
            caa = $.trim(ca[z]).split(" ");
            var pc = 0;
            for (var x = 0; x < caa.length; x++) {
                for (var y = 0; y < u.length; y++) {
                    if (soundex(u[y]) != null && soundex(caa[x]) != null) {
                        if (soundex(u[y]) == soundex(caa[x])) {
                            pc = pc + 1;
                        }
                    }
                    else {
                        if (u[y].indexOf(caa[x]) > -1) {
                            pc = pc + 1;
                        }
                    }
                }
            }
            if ((pc / caa.length) > 0.5) {
                return true;
            }
        }
        return false;
    }

    // create object listing the SOUNDEX values for each letter
    // -1 indicates that the letter is not coded, but is used for coding
    //  0 indicates that the letter is omitted for modern census archives
    //                              but acts like -1 for older census archives
    //  1 is for BFPV
    //  2 is for CGJKQSXZ
    //  3 is for DT
    //  4 is for L
    //  5 is for MN my home state
    //  6 is for R
    function makesoundex() {
        this.a = -1
        this.b = 1
        this.c = 2
        this.d = 3
        this.e = -1
        this.f = 1
        this.g = 2
        this.h = 0
        this.i = -1
        this.j = 2
        this.k = 2
        this.l = 4
        this.m = 5
        this.n = 5
        this.o = -1
        this.p = 1
        this.q = 2
        this.r = 6
        this.s = 2
        this.t = 3
        this.u = -1
        this.v = 1
        this.w = 0
        this.x = 2
        this.y = -1
        this.z = 2
    }

    var sndx = new makesoundex()

    // check to see that the input is valid
    function isSurname(name) {
        if (name == "" || name == null) {
            return false
        } else {
            for (var i = 0; i < name.length; i++) {
                var letter = name.charAt(i)
                if (!(letter >= 'a' && letter <= 'z' || letter >= 'A' && letter <= 'Z')) {
                    return false
                }
            }
        }
        return true
    }

    // Collapse out directly adjacent sounds
    // 1. Assume that surname.length>=1
    // 2. Assume that surname contains only lowercase letters
    function collapse(surname) {
        if (surname.length == 1) {
            return surname
        }
        var right = collapse(surname.substring(1, surname.length))
        if (sndx[surname.charAt(0)] == sndx[right.charAt(0)]) {
            return surname.charAt(0) + right.substring(1, right.length)
        }
        return surname.charAt(0) + right
    }

    // Collapse out directly adjacent sounds using the new National Archives method
    // 1. Assume that surname.length>=1
    // 2. Assume that surname contains only lowercase letters
    // 3. H and W are completely ignored
    function omit(surname) {
        if (surname.length == 1) {
            return surname
        }
        var right = omit(surname.substring(1, surname.length))
        if (!sndx[right.charAt(0)]) {
            return surname.charAt(0) + right.substring(1, right.length)
        }
        return surname.charAt(0) + right
    }

    // Output the coded sequence
    function output_sequence(seq) {
        var output = seq.charAt(0).toUpperCase() // Retain first letter
        output += "-" // Separate letter with a dash
        var stage2 = seq.substring(1, seq.length)
        var count = 0
        for (var i = 0; i < stage2.length && count < 3; i++) {
            if (sndx[stage2.charAt(i)] > 0) {
                output += sndx[stage2.charAt(i)]
                count++
            }
        }
        for (; count < 3; count++) {
            output += "0"
        }
        return output
    }

    // Compute the SOUNDEX code for the surname
    function soundex(value) {
        if (!isSurname(value)) {
            return null
        }
        var stage1 = collapse(value.toLowerCase())
        //form.result.value=output_sequence(stage1);

        var stage1 = omit(value.toLowerCase())
        var stage2 = collapse(stage1)
        return output_sequence(stage2);

    }

    function clean(u) {
        var u = u.replace(/\,/g, "");
        u = u.toLowerCase().split(" ");
        var cw = ["ARRAY OF WORDS TO BE EXCLUDED FROM COMPARISON"];
        var n = [];
        for (var y = 0; y < u.length; y++) {
            var test = false;
            for (var z = 0; z < cw.length; z++) {
                if (u[y] != "" && u[y] != cw[z]) {
                    test = true;
                    break;
                }
            }
            if (test) {
    //Don't use & or $ in comparison
                var val = u[y].replace("$", "").replace("&", "");
                n.push(val);
            }
        }
        return n;
    }


私はこれをテストしていますが、まだ完璧なものを見つけるのに苦労しています。これらを破る古典的な例。質問は「最初の2人の大統領は何ですか?」と言います。そして誰かが「アダムスとワシントン」と答えます。「ジョージ・ワシントンのジョン・アダムズ」との文字列の比較は、約50%になるはずです。
ブラッドルーダーマン2012年

oof、jQueryに依存しますか?
ShawnWhinnery18年

回答:


138

レーベンシュタイン距離に基づく回答は次のとおりですhttps://en.wikipedia.org/wiki/Levenshtein_distance

function similarity(s1, s2) {
  var longer = s1;
  var shorter = s2;
  if (s1.length < s2.length) {
    longer = s2;
    shorter = s1;
  }
  var longerLength = longer.length;
  if (longerLength == 0) {
    return 1.0;
  }
  return (longerLength - editDistance(longer, shorter)) / parseFloat(longerLength);
}

編集距離の計算に

function editDistance(s1, s2) {
  s1 = s1.toLowerCase();
  s2 = s2.toLowerCase();

  var costs = new Array();
  for (var i = 0; i <= s1.length; i++) {
    var lastValue = i;
    for (var j = 0; j <= s2.length; j++) {
      if (i == 0)
        costs[j] = j;
      else {
        if (j > 0) {
          var newValue = costs[j - 1];
          if (s1.charAt(i - 1) != s2.charAt(j - 1))
            newValue = Math.min(Math.min(newValue, lastValue),
              costs[j]) + 1;
          costs[j - 1] = lastValue;
          lastValue = newValue;
        }
      }
    }
    if (i > 0)
      costs[s2.length] = lastValue;
  }
  return costs[s2.length];
}

使用法

similarity('Stack Overflow','Stack Ovrflw')

0.8571428571428571を返します


あなたはそれを以下で遊ぶことができます:


いくつかの単語の改善:var類似性2 = function(s1、s2){var split1 = s1.split( ''); var split2 = s2.split( ''); var sum = 0; var max = 0; var temp = 0; for(var i = 0; i <split1.length; i ++){max = 0; for(var j = 0; j <split2.length; j ++){temp =類似性(split1 [i]、split2 [j]); if(max <temp)max = temp; } console.log(max); 合計+ =最大/split1.length; }合計を返します。};
infinito84 2017年

@ overlord1234上記の方法は次のような文字列で機能しますか?
hyperfkcb 2017年

セマンティクスが付加されていない文字列でも機能します。インラインコードスニペットを試して実行してください(Davidに感謝します)。前述の文字列を入力すると、0.17857142857142858の類似性が得られます。
overlord1234 2017年

@hyperfkcb彼は編集距離アルゴリズムを実装しています。これは、間違った位置にある文字の数をカウントするため(多かれ少なかれ)、パーセンテージを計算するために、可能な限り長い編集距離値(longerLength)を取得し、(longerLength-editDistance)/を実行します。 longLength。
infinito84 2018

ただし、長い文字列には遅すぎます。
1

14

これは、比較を行い、同等性に基づいてパーセンテージを返す非常に単純な関数です。考えられるすべてのシナリオでテストされているわけではありませんが、開始するのに役立つ場合があります。

function similar(a,b) {
    var equivalency = 0;
    var minLength = (a.length > b.length) ? b.length : a.length;    
    var maxLength = (a.length < b.length) ? b.length : a.length;    
    for(var i = 0; i < minLength; i++) {
        if(a[i] == b[i]) {
            equivalency++;
        }
    }
    

    var weight = equivalency / maxLength;
    return (weight * 100) + "%";
}
alert(similar("test","tes"));   // 75%
alert(similar("test","test"));  // 100%
alert(similar("test","testt")); // 80%
alert(similar("test","tess"));  // 75%

9
これに伴う問題は、「atest」と「test」が0%を返すことですが、これは正しくないことがわかっています。
peresisUser 2016年

8

文字列の類似性のためにこのライブラリを使用することは、私にとって魅力のように機能しました!

これが例です-

var similarity = stringSimilarity.compareTwoStrings("Apples","apple");    // => 0.88

6
stringSimilarityにlodashと呼ばれる依存関係があり、文字列の類似性を取得できるように、プロジェクトに1,000を超えるファイルが含まれていることを除けば、これはすばらしいことです。
GrumpyCrouton 2018

2
ええ、それはローカルでパッケージを追加している間に起こります。ただし、代わりに、CDNを使用してバンドルサイズを小さくすることができます。-ここではCDNのリンクですjsdelivr.com/package/npm/lodash - jsdelivr.com/package/npm/string-similarity
Tushar Walzade

2
彼らはlodashを含め、ほとんどの依存関係を削除した
ロベンクランズ

7

私がすぐに書いたものだけで、あなたの目的には十分かもしれません:

function Compare(strA,strB){
    for(var result = 0, i = strA.length; i--;){
        if(typeof strB[i] == 'undefined' || strA[i] == strB[i]);
        else if(strA[i].toLowerCase() == strB[i].toLowerCase())
            result++;
        else
            result += 4;
    }
    return 1 - (result + 4*Math.abs(strA.length - strB.length))/(2*(strA.length+strB.length));
}

これは、同じであるが異なるケースの文字の重さを、完全に異なるか欠落している文字の4分の1の重さです。0から1までの数値を返します。1は文字列が同一であることを意味します。0は、類似性がないことを意味します。例:

Compare("Apple", "Apple")    // 1
Compare("Apples", "Apple")   // 0.8181818181818181
Compare("Apples", "apple")   // 0.7727272727272727
Compare("a", "A")            // 0.75
Compare("Apples", "appppp")  // 0.45833333333333337
Compare("a", "b")            // 0

6
そう正確ではない:比較( "アップル"、 "Applez")= 0.84比較しながら、( "アップル"、 "zApple")は、0.07を=
Kousha

3
@Kousha、それは定位置です。「Apple」と「zApple」の共通文字は1つだけです(2番目p)。
ポール

2
@Paulpro AppleとzAppleには、論理的に共通の5文字があります。それはあなたの実装のせいです。Apple、zApple、Applezは似ています。
kousha 2016年

2
@ Kousha、zAppleは位置的であるため、このアルゴリズムによると類似していません。それはアルゴリズムを不正確にすることはありません。
ポール

8
@Paulpro:それはあなたのアルゴリズムを不正確にするわけではありませんが、この質問に対する答えは良くありません...
MarcoS 2017年

6

PHP.jsライブラリの関数similar_textはどうですか?

これは、同じ名前のPHP関数に基づいています。

function similar_text (first, second) {
    // Calculates the similarity between two strings  
    // discuss at: http://phpjs.org/functions/similar_text

    if (first === null || second === null || typeof first === 'undefined' || typeof second === 'undefined') {
        return 0;
    }

    first += '';
    second += '';

    var pos1 = 0,
        pos2 = 0,
        max = 0,
        firstLength = first.length,
        secondLength = second.length,
        p, q, l, sum;

    max = 0;

    for (p = 0; p < firstLength; p++) {
        for (q = 0; q < secondLength; q++) {
            for (l = 0;
            (p + l < firstLength) && (q + l < secondLength) && (first.charAt(p + l) === second.charAt(q + l)); l++);
            if (l > max) {
                max = l;
                pos1 = p;
                pos2 = q;
            }
        }
    }

    sum = max;

    if (sum) {
        if (pos1 && pos2) {
            sum += this.similar_text(first.substr(0, pos2), second.substr(0, pos2));
        }

        if ((pos1 + max < firstLength) && (pos2 + max < secondLength)) {
            sum += this.similar_text(first.substr(pos1 + max, firstLength - pos1 - max), second.substr(pos2 + max, secondLength - pos2 - max));
        }
    }

    return sum;
}

1
一致する文字に基づいて類似性が返されますか?類似性をどのように評価しますか
hyperfkcb 2017年

3

2つの文字列間の類似度を見つけるには; 1つまたは2つ以上の方法を使用できますが、私は主にダイス係数使用に傾倒しています。どちらがいいですか!私の知識では、レーベンシュタイン距離を使用するよりもよく

npmのこの「string-similarity」パッケージを使用すると、上記で述べたことに取り組むことができます。

簡単な使用例は次のとおりです。

var stringSimilarity = require('string-similarity');

var similarity = stringSimilarity.compareTwoStrings('healed', 'sealed'); 

var matches = stringSimilarity.findBestMatch('healed', ['edward', 'sealed', 'theatre']);

詳細については、上記のリンクをご覧ください。ありがとうございました。


1
ソリューションへのリンクは大歓迎ですが、それがなくても回答が役立つことを確認してください。リンクの周りにコンテキストを追加して、他のユーザーがそれが何であるか、なぜそこにあるのかを理解できるようにしてから、ページの最も関連性の高い部分を引用してください。ターゲットページが利用できない場合に再リンクします。リンクに過ぎない回答は削除される場合があります
デビッドバック

1

fuzzyset -javascript用のあいまい文字列セット。fuzzysetは、データに対して全文検索に似た処理を実行して、スペルミスの可能性とおおよその文字列一致を判別するデータ構造です。これはPythonライブラリのJavaScriptポートであることに注意してください。

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.