Làm thế nào để đếm sự xuất hiện chuỗi trong chuỗi?

Làm thế nào tôi có thể đếm số lần một chuỗi cụ thể xảy ra trong một chuỗi khác. Ví dụ: đây là những gì tôi đang cố gắng thực hiện trong Javascript:

var temp = "This is a string.";
alert(temp.count("is")); //should output '2'

Các gtrong biểu thức chính quy (viết tắt của toàn cầu ) cho biết để tìm kiếm trên toàn bộ chuỗi thay vì chỉ tìm thấy sự xuất hiện đầu tiên. Điều này khớp ishai lần:

var temp = "This is a string.";
var count = (temp.match(/is/g) || []).length;
console.log(count);

Và, nếu không có kết quả khớp, nó sẽ trả về 0:

var temp = "Hello World!";
var count = (temp.match(/is/g) || []).length;
console.log(count);

/** Function that count occurrences of a substring in a string;
 * @param {String} string               The string
 * @param {String} subString            The sub string to search for
 * @param {Boolean} [allowOverlapping]  Optional. (Default:false)
 *
 * @author Vitim.us https://gist.github.com/victornpb/7736865
 * @see Unit Test https://jsfiddle.net/Victornpb/5axuh96u/
 * @see http://stackoverflow.com/questions/4009756/how-to-count-string-occurrence-in-string/7924240#7924240
 */
function occurrences(string, subString, allowOverlapping) {

    string += "";
    subString += "";
    if (subString.length <= 0) return (string.length + 1);

    var n = 0,
        pos = 0,
        step = allowOverlapping ? 1 : subString.length;

    while (true) {
        pos = string.indexOf(subString, pos);
        if (pos >= 0) {
            ++n;
            pos += step;
        } else break;
    }
    return n;
}

Sử dụng

occurrences("foofoofoo", "bar"); //0

occurrences("foofoofoo", "foo"); //3

occurrences("foofoofoo", "foofoo"); //1

allowOverlaps

occurrences("foofoofoo", "foofoo", true); //2

Diêm:

  foofoofoo
1 `----´
2    `----´

Kiểm tra đơn vị

• https://jsfiddle.net/Victornpb/5axuh96u/

Điểm chuẩn

Tôi đã thực hiện một bài kiểm tra điểm chuẩn và chức năng của tôi nhanh hơn 10 lần so với chức năng so khớp regrec được đăng bởi gumbo. Trong chuỗi thử nghiệm của tôi là 25 ký tự dài. với 2 lần xuất hiện của nhân vật 'o'. Tôi đã thực hiện 1 000 000 lần trong Safari.

Safari 5.1

Điểm chuẩn> Tổng thời gian thực hiện: 5617 ms (regrec)

Điểm chuẩn> Tổng thời gian thực hiện: 881 ms (chức năng của tôi nhanh hơn 6,4 lần)

Firefox 4

Điểm chuẩn> Tổng thời gian thực hiện: 8547 ms (Rexapi)

Điểm chuẩn> Tổng thời gian thực hiện: 634 ms (chức năng của tôi nhanh hơn 13,5 lần)

---

Chỉnh sửa: những thay đổi tôi đã thực hiện

• chiều dài chuỗi con được lưu trữ

• thêm kiểu đúc vào chuỗi.

• đã thêm tham số 'allowOverlicking' tùy chọn

• đã sửa lỗi đầu ra chính xác cho "" trường hợp chuỗi con trống.

• https://gist.github.com/victornpb/7736865

function countInstances(string, word) {
   return string.split(word).length - 1;
}

Bạn có thể thử điều này:

var theString = "This is a string.";
console.log(theString.split("is").length - 1);

Giải pháp của tôi:

var temp = "This is a string.";

function countOcurrences(str, value) {
  var regExp = new RegExp(value, "gi");
  return (str.match(regExp) || []).length;
}

console.log(countOcurrences(temp, 'is'));

Bạn có thể sử dụng matchđể xác định chức năng đó:

String.prototype.count = function(search) {
    var m = this.match(new RegExp(search.toString().replace(/(?=[.\\+*?[^\]$(){}\|])/g, "\\"), "g"));
    return m ? m.length:0;
}

Phiên bản không regex:

 var string = 'This is a string',
    searchFor = 'is',
    count = 0,
    pos = string.indexOf(searchFor);

while (pos > -1) {
    ++count;
    pos = string.indexOf(searchFor, ++pos);
}

console.log(count);   // 2

Chỉ cần mã chơi golf Rebecca Chernoff 's giải pháp :-)

alert(("This is a string.".match(/is/g) || []).length);

String.prototype.Count = function (find) {
    return this.split(find).length - 1;
}

console.log("This is a string.".Count("is"));

Điều này sẽ trở lại 2.

Đây là chức năng nhanh nhất!

Tại sao nó nhanh hơn?

• Không kiểm tra char bằng char (với 1 ngoại lệ)
• Sử dụng một lúc và tăng 1 var (số đếm char) so với vòng lặp for kiểm tra độ dài và tăng 2 vars (thường là var i và var với số char)
• Sử dụng CÁCH ít vars
• Không sử dụng regex!
• Sử dụng một chức năng (hy vọng) được tối ưu hóa cao

• Tất cả các hoạt động được kết hợp như có thể, tránh bị chậm lại do nhiều hoạt động

  String.prototype.timesCharExist=function(c){var t=0,l=0,c=(c+'')[0];while(l=this.indexOf(c,l)+1)++t;return t};

Đây là một phiên bản chậm hơn và dễ đọc hơn:

    String.prototype.timesCharExist = function ( chr ) {
        var total = 0, last_location = 0, single_char = ( chr + '' )[0];
        while( last_location = this.indexOf( single_char, last_location ) + 1 )
        {
            total = total + 1;
        }
        return total;
    };

Cái này chậm hơn vì bộ đếm, tên var dài và sử dụng sai 1 var.

Để sử dụng nó, bạn chỉ cần làm điều này:

    'The char "a" only shows up twice'.timesCharExist('a');

Chỉnh sửa: (2013/12/16)

KHÔNG sử dụng với Opera 12.16 trở lên! nó sẽ mất gần 2,5 lần so với giải pháp regex!

Trên chrome, giải pháp này sẽ mất từ ​​14ms đến 20ms cho 1.000.000 ký tự.

Giải pháp regex mất 11-14ms cho cùng một lượng.

Sử dụng một chức năng (bên ngoài String.prototype) sẽ mất khoảng 10-13ms.

Đây là mã được sử dụng:

    String.prototype.timesCharExist=function(c){var t=0,l=0,c=(c+'')[0];while(l=this.indexOf(c,l)+1)++t;return t};

    var x=Array(100001).join('1234567890');

    console.time('proto');x.timesCharExist('1');console.timeEnd('proto');

    console.time('regex');x.match(/1/g).length;console.timeEnd('regex');

    var timesCharExist=function(x,c){var t=0,l=0,c=(c+'')[0];while(l=x.indexOf(c,l)+1)++t;return t;};

    console.time('func');timesCharExist(x,'1');console.timeEnd('func');

Kết quả của tất cả các giải pháp nên là 100.000!

Lưu ý: nếu bạn muốn chức năng này đếm nhiều hơn 1 char, hãy thay đổi vị trí c=(c+'')[0]thànhc=c+''

Tôi nghĩ mục đích của regex khác nhiều so với indexOf. indexOfchỉ cần tìm sự xuất hiện của một chuỗi nhất định trong khi trong regex, bạn có thể sử dụng các ký tự đại diện như thế [A-Z]có nghĩa là nó sẽ tìm thấy bất kỳ ký tự viết hoa nào trong từ mà không nêu rõ ký tự thực tế.

Thí dụ:

 var index = "This is a string".indexOf("is");
 console.log(index);
 var length = "This is a string".match(/[a-z]/g).length;
 // where [a-z] is a regex wildcard expression thats why its slower
 console.log(length);

Super duper cũ, nhưng tôi cần phải làm một cái gì đó như thế này ngày hôm nay và chỉ nghĩ sẽ kiểm tra SO sau đó. Hoạt động khá nhanh đối với tôi.

String.prototype.count = function(substr,start,overlap) {
    overlap = overlap || false;
    start = start || 0;

    var count = 0, 
        offset = overlap ? 1 : substr.length;

    while((start = this.indexOf(substr, start) + offset) !== (offset - 1))
        ++count;
    return count;
};

       var myString = "This is a string.";
        var foundAtPosition = 0;
        var Count = 0;
        while (foundAtPosition != -1)
        {
            foundAtPosition = myString.indexOf("is",foundAtPosition);
            if (foundAtPosition != -1)
            {
                Count++;
                foundAtPosition++;
            }
        }
        document.write("There are " + Count + " occurrences of the word IS");

Tham khảo: - đếm một chuỗi con xuất hiện trong chuỗi để giải thích từng bước.

Dựa trên câu trả lời @ Vittim.us ở trên. Tôi thích phương pháp điều khiển mà phương pháp của anh ấy mang lại cho tôi, giúp dễ dàng mở rộng, nhưng tôi cần thêm độ nhạy cảm trường hợp và giới hạn khớp với toàn bộ từ với sự hỗ trợ cho dấu câu. (ví dụ: "tắm" là trong "tắm". nhưng không "tắm")

Regex chấm câu xuất phát từ: https://stackoverflow.com/a/25575009/497745 ( Làm cách nào tôi có thể loại bỏ tất cả dấu chấm câu từ một chuỗi trong JavaScript bằng regex? )

function keywordOccurrences(string, subString, allowOverlapping, caseInsensitive, wholeWord)
{

    string += "";
    subString += "";
    if (subString.length <= 0) return (string.length + 1); //deal with empty strings

    if(caseInsensitive)
    {            
        string = string.toLowerCase();
        subString = subString.toLowerCase();
    }

    var n = 0,
        pos = 0,
        step = allowOverlapping ? 1 : subString.length,
        stringLength = string.length,
        subStringLength = subString.length;

    while (true)
    {
        pos = string.indexOf(subString, pos);
        if (pos >= 0)
        {
            var matchPos = pos;
            pos += step; //slide forward the position pointer no matter what

            if(wholeWord) //only whole word matches are desired
            {
                if(matchPos > 0) //if the string is not at the very beginning we need to check if the previous character is whitespace
                {                        
                    if(!/[\s\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&\(\)*+,\-.\/:;<=>?@\[\]^_`{|}~]/.test(string[matchPos - 1])) //ignore punctuation
                    {
                        continue; //then this is not a match
                    }
                }

                var matchEnd = matchPos + subStringLength;
                if(matchEnd < stringLength - 1)
                {                        
                    if (!/[\s\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&\(\)*+,\-.\/:;<=>?@\[\]^_`{|}~]/.test(string[matchEnd])) //ignore punctuation
                    {
                        continue; //then this is not a match
                    }
                }
            }

            ++n;                
        } else break;
    }
    return n;
}

Xin vui lòng sửa đổi và cấu trúc lại câu trả lời này nếu bạn phát hiện ra lỗi hoặc cải tiến.

Đối với bất kỳ ai tìm thấy chủ đề này trong tương lai, lưu ý rằng câu trả lời được chấp nhận sẽ không luôn trả về giá trị chính xác nếu bạn khái quát hóa nó, vì nó sẽ bóp nghẹt các toán tử regex như $và .. Đây là phiên bản tốt hơn, có thể xử lý bất kỳ kim nào :

function occurrences (haystack, needle) {
  var _needle = needle
    .replace(/\[/g, '\\[')
    .replace(/\]/g, '\\]')
  return (
    haystack.match(new RegExp('[' + _needle + ']', 'g')) || []
  ).length
}

function get_occurrence(varS,string){//Find All Occurrences
        c=(string.split(varS).length - 1);
        return c;
    }
    temp="This is a string.";
    console.log("Total Occurrence is "+get_occurrence("is",temp));

Sử dụng get_occurrence (varS, chuỗi) để tìm sự xuất hiện của cả hai ký tự và chuỗi trong Chuỗi.

Thử nó

<?php 
$str = "33,33,56,89,56,56";
echo substr_count($str, '56');
?>

<script type="text/javascript">
var temp = "33,33,56,89,56,56";
var count = temp.match(/56/g);  
alert(count.length);
</script>

Phiên bản đơn giản không có regex:

var temp = "This is a string.";

var count = (temp.split('is').length - 1);

alert(count);

Không ai sẽ thấy điều này, nhưng thật tốt khi mang lại chức năng đệ quy và mũi tên một lần nữa (ý định chơi chữ tuyệt vời)

String.prototype.occurrencesOf = function(s, i) {
 return (n => (n === -1) ? 0 : 1 + this.occurrencesOf(s, n + 1))(this.indexOf(s, (i || 0)));
};

Thử cái này

let allData =  "This is a string.";
let searchString = 'is';
let regularExp = new RegExp(searchString, 'g');
let occurArray = allData.match(regularExp);
let count = (occurArray || []).length;
alert(count); 

Liên kết Fiddle: https://jsfiddle.net/rajaramtt/gn0dtsjc/1/

Bây giờ đây là một chủ đề rất cũ mà tôi đã gặp nhưng như nhiều người đã đưa ra câu trả lời của họ, đây là của tôi với hy vọng giúp được ai đó với mã đơn giản này.

var search_value = "This is a dummy sentence!";
var letter = 'a'; /*Can take any letter, have put in a var if anyone wants to use this variable dynamically*/
letter = letter && "string" === typeof letter ? letter : "";
var count;
for (var i = count = 0; i < search_value.length; count += (search_value[i++] == letter));
console.log(count);

Tôi không chắc đó có phải là giải pháp nhanh nhất hay không nhưng tôi thích nó vì đơn giản và không sử dụng regex (tôi chỉ không thích sử dụng chúng!)

Hàm này trả về số lần xuất hiện của một từ trong văn bản.

Lưu ý, chúng tôi sử dụng toLowerCase để tính số lần xuất hiện bất kể định dạng (chữ hoa, chữ hoa ...) của từ và văn bản

wordCount(text, word) {
    if (!text || !word) {
      return 0;
    }
    text = text.toLowerCase();
    word = word.toLowerCase();
    return ( text.split( word ).length - 1 );
}

Trả lời cho Leandro Batista: chỉ là một vấn đề với biểu thức regex.

 "use strict";
 var dataFromDB = "testal";
 
  $('input[name="tbInput"]').on("change",function(){
	var charToTest = $(this).val();
	var howManyChars = charToTest.length;
	var nrMatches = 0;
	if(howManyChars !== 0){
		charToTest = charToTest.charAt(0);
		var regexp = new RegExp(charToTest,'gi');
		var arrMatches = dataFromDB.match(regexp);
		nrMatches = arrMatches ? arrMatches.length : 0;
	}
		$('#result').html(nrMatches.toString());

  });

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<div class="main">
What do you wanna count <input type="text" name="tbInput" value=""><br />
Number of occurences = <span id="result">0</span>
</div>

Hơi muộn nhưng, giả sử chúng ta có chuỗi sau:

var temp = "This is a string.";

Đầu tiên chúng tôi chia ra bất cứ thứ gì bạn muốn khớp, điều này sẽ trả về một chuỗi các chuỗi.

var array = temp.split("is");

Sau đó, chúng tôi nhận được chiều dài của nó và trừ đi 1 cho nó kể từ khi chia mặc định thành một mảng có kích thước 1 và do đó tăng kích thước của nó mỗi lần nó xuất hiện.

var occurrenceCount = array.length - 1;
alert(occurrenceCount); //should output '2'

Bạn cũng có thể làm tất cả điều này trong một dòng như sau:

alert("This is a string.".split("is").length - 1); //should output '2'

Hy vọng nó sẽ giúp: D

Giải pháp này dựa trên .replace() phương thức chấp nhận RegEx làm tham số đầu tiên và chức năng là tham số thứ hai mà chúng ta có thể sử dụng làm bao đóng để tăng bộ đếm ...

/**
 * Return the frequency of a substring in a string
 * @param {string} string - The string.
 * @param {string} string - The substring to count.
 * @returns {number} number - The frequency.
 * 
 * @author Drozerah https://gist.github.com/Drozerah/2b8e08d28413d66c3e63d7fce80994ce
 * @see https://stackoverflow.com/a/55670859/9370788
 */
const subStringCounter = (string, subString) => {

    let count = 0
    string.replace(new RegExp(subString, 'gi'), () => count++)
    return count
}

Sử dụng

subStringCounter("foofoofoo", "bar"); //0

subStringCounter("foofoofoo", "foo"); //3

đã đi qua bài viết này.

let str = 'As sly as a fox, as strong as an ox';

let target = 'as'; // let's look for it

let pos = 0;
while (true) {
  let foundPos = str.indexOf(target, pos);
  if (foundPos == -1) break;

  alert( `Found at ${foundPos}` );
  pos = foundPos + 1; // continue the search from the next position
}

Thuật toán tương tự có thể được trình bày ngắn hơn:

let str = "As sly as a fox, as strong as an ox";
let target = "as";

let pos = -1;
while ((pos = str.indexOf(target, pos + 1)) != -1) {
  alert( pos );
}

substr_count được dịch sang Javascript từ php

• Locutus (Gói dịch Php sang JS)
• struct_count (trang chính thức, mã được sao chép bên dưới)

function substr_count (haystack, needle, offset, length) { 
  // eslint-disable-line camelcase
  //  discuss at: https://locutus.io/php/substr_count/
  // original by: Kevin van Zonneveld (https://kvz.io)
  // bugfixed by: Onno Marsman (https://twitter.com/onnomarsman)
  // improved by: Brett Zamir (https://brett-zamir.me)
  // improved by: Thomas
  //   example 1: substr_count('Kevin van Zonneveld', 'e')
  //   returns 1: 3
  //   example 2: substr_count('Kevin van Zonneveld', 'K', 1)
  //   returns 2: 0
  //   example 3: substr_count('Kevin van Zonneveld', 'Z', 0, 10)
  //   returns 3: false

  var cnt = 0

  haystack += ''
  needle += ''
  if (isNaN(offset)) {
    offset = 0
  }
  if (isNaN(length)) {
    length = 0
  }
  if (needle.length === 0) {
    return false
  }
  offset--

  while ((offset = haystack.indexOf(needle, offset + 1)) !== -1) {
    if (length > 0 && (offset + needle.length) > length) {
      return false
    }
    cnt++
  }

  return cnt
}

Kiểm tra chức năng dịch vụ của Phut của Locutus

Thử cái này:

function countString(str, search){
    var count=0;
    var index=str.indexOf(search);
    while(index!=-1){
        count++;
        index=str.indexOf(search,index+1);
    }
    return count;
}