Javascript 如何计算字符串中出现的字符串？_Javascript_Regex_String

Javascript 如何计算字符串中出现的字符串？

javascript regex string

Javascript 如何计算字符串中出现的字符串？,javascript,regex,string,Javascript,Regex,String,如何计算一个特定字符串在另一个字符串中出现的次数。例如，这就是我在Javascript中尝试做的事情： var temp = "This is a string."; alert(temp.count("is")); //should output '2' 正则表达式（global的缩写）中的g表示搜索整个字符串，而不仅仅是查找第一个匹配项。这将匹配两次is： var temp=“这是一个字符串。”；变量计数=（温度匹配（/is/g）| |[]）长度；控制台日志（计数）您可以使用matc

如何计算一个特定字符串在另一个字符串中出现的次数。例如，这就是我在Javascript中尝试做的事情：

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

正则表达式（global的缩写）中的

表示搜索整个字符串，而不仅仅是查找第一个匹配项。这将匹配两次

is

：

var temp=“这是一个字符串。”；
变量计数=（温度匹配（/is/g）| |[]）长度；
控制台日志（计数）您可以使用match
来定义此函数：
String.prototype.count = function(search) {
    var m = this.match(new RegExp(search.toString().replace(/(?=[.\\+*?[^\]$(){}\|])/g, "\\"), "g"));
    return m ? m.length:0;
}

只需编码高尔夫运动：-）
允许重叠
匹配项：
  foofoofoo
1 `----´
2    `----´

单元测试



基准
我做了一个基准测试，我的功能是10倍以上
比gumbo发布的regexp match函数更快。在我的测试中
字符串长度为25个字符。字符“o”出现两次。我
在狩猎中执行了100万次
Safari 5.1
基准测试>总执行时间：5617毫秒（regexp）
基准测试>总执行时间：881毫秒（我的功能快6.4倍）
Firefox4
基准测试>总执行时间：8547毫秒（Rexexp）
基准测试>总执行时间：634毫秒（我的功能快13.5倍）

编辑：我所做的更改

缓存子串长度
在字符串中添加类型转换
添加了可选的“allowOverlapping”参数
修复了“”空子字符串大小写的正确输出

主旨


您可以尝试以下方法：

var theString=“这是一个字符串。”；
log（字符串拆分（“is”）.length-1）
我认为regex的用途与indexOf大不相同。
indexOf
只需查找某个字符串的出现，而在正则表达式中，您可以使用通配符，如[a-Z]
，这意味着它将查找单词中的任何大写字符，而不说明实际字符
例如：

var index=“这是一个字符串”；
控制台日志（索引）；
var length=“这是一个字符串”。匹配（/[a-z]/g）；
//其中[a-z]是一个正则表达式通配符表达式，这就是它速度较慢的原因
控制台日志（长度）超级复制器很老了，但我今天需要做类似的事情，只是想在事后检查一下。对我来说效果很快
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 temp=“这是一个字符串。”；
函数countOcurrences（str，value）{
var regExp=新的regExp（值，“gi”）；
return（str.match（regExp）| |[]）.length；
}
console.log（countOcurrences（temp，'is'））这里是最快的函数
为什么速度更快

不逐字符检查字符（有1个例外）
使用while并递增1个变量（char count变量）和循环检查长度并递增2个变量（通常为变量i和带有char count的变量）
使用更少的变量
不使用正则表达式
使用（希望）高度优化的函数
所有操作尽可能地组合在一起，避免了由于多个操作而导致的减速
String.prototype.timesCharExist=function(c){var t=0,l=0,c=(c+'')[0];while(l=this.indexOf(c,l)+1)++t;return t};



下面是一个更慢、可读性更强的版本：
    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;
    };

由于计数器、长变量名和1变量的误用，这一个速度较慢
要使用它，只需执行以下操作：
    'The char "a" only shows up twice'.timesCharExist('a');

编辑：（2013/12/16）
不要与Opera 12.16或更高版本一起使用！这将比正则表达式解决方案多花2.5倍的时间
在chrome上，对于1000000个字符，此解决方案需要14毫秒到20毫秒
对于相同的量，regex解决方案需要11-14ms
使用函数（在String.prototype
）大约需要10-13毫秒
以下是使用的代码：
    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');

所有解决方案的结果应为100000
注意：如果希望此函数计数超过1个字符，请将其中的isc=（c+“”）[0]
更改为c=c+“”
试试
<?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>


var temp=“33,33,56,89,56,56”；
变量计数=温度匹配（/56/g）；
警报（计数长度）；
非正则表达式版本：

var string='这是一个字符串'，
searchFor='is'，
计数=0，
pos=字符串.indexOf（searchFor）；
而（位置>-1）{
++计数；
pos=string.indexOf（searchFor，++pos）；
}
console.log（计数）；//2
请参阅：-了解分步解释。
对于将来发现此线程的任何人，请注意，如果对其进行泛化，接受的答案将不会始终返回正确的值，因为它将阻塞正则表达式运算符，如$
和
。这里有一个更好的版本，可以处理任何针：

var temp=“这是一个字符串。”；
log（（temp.match（新RegExp（“is”，“g”））| |[]）长度）建立在@Vittim.us上面的答案之上。我喜欢他的方法给我的控件，使其易于扩展，但我需要添加不区分大小写的功能，并限制与整个单词的匹配，同时支持标点符号。（例如，“bath”在“take a bath.”中，但不是“bathing”）
标点符号regex来自：（）
函数关键字出现次数（字符串、子字符串、allowOverlapping、不区分大小写、wholeWord）
{
字符串+=“”；
子字符串+=“”；
if（subString.length=0）
{
var-matchPos=pos；
pos+=step；//无论发生什么情况，都要向前滑动位置指针
if（wholeWord）//只需要整词匹配
{
if（matchPos>0）//如果字符串不在最开始处，我们需要检查前一个字符是否为空格
{                        
如果（！/[\s\u2000-\u206F\u2E00-\u2E7F\\'！“\$%&\（\）*+，\-.\/：；？@[\]^{{124;}/.test（字符串[matchPos-1]）//忽略标点符号
{
continue；//那么这不匹配
}
}
var matchEnd=matchPos+subStringLength；
如果（匹配端String.prototype.timesCharExist=function(c){var t=0,l=0,c=(c+'')[0];while(l=this.indexOf(c,l)+1)++t;return t};

    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;
    };

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

    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');

<?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>

       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");

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

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;
}

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

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
}

let count = s.length - s.replace(/is/g, "").length;

   function findSubstringOccurrences(str, word) {
        let occurrences = 0;
        for(let i=0; i<str.length; i++){
            if(word[0] === str[i]){ // to make it faster and iterate less
                for(let j=0; j<word.length; j++){
                    if(str[i+j] !== word[j]) break;
                    if(j === word.length - 1) occurrences++;
                }
            }
        }
        return occurrences;
    }
    
    console.log(findSubstringOccurrences("jdlfkfomgkdjfomglo", "omg"));

//Try this code

const countSubStr = (str, search) => {
    let arrStr = str.split('');
    let i = 0, count = 0;

    while(i < arrStr.length){
        let subStr = i + search.length + 1 <= arrStr.length ?
                  arrStr.slice(i, i+search.length).join('') :
                  arrStr.slice(i).join('');
        if(subStr === search){
            count++;
            arrStr.splice(i, search.length);
        }else{
            i++;
        }
    }
    return count;
  }

function checkOccurences(string, word) {
      return string.split(word).length - 1;
}
const text="Let us see. see above, see below, see forward, see backward, see left, see right until we will be right"; 
const count=countOccurences(text,"see "); // 2