Fe-interview: [js] 第7天 统计某一字符或字符串在另一个字符串中出现的次数

[haizhilin2013]

第7天 统计某一字符或字符串在另一个字符串中出现的次数

[linghucq1]

function strCount(str, target) {
  let count = 0
  if (!target) return count
  while(str.match(target)) {
    str = str.replace(target, '')
    count++
  }
  return count
}

console.log(strCount('abcdef abcdef a', 'abc'))

[coderfe]

function substrCount(str, target) {
  let count = 0;
  while (str.includes(target)) {
    const index = str.indexOf(target);
    count++;
    str = str.substring(index + target.length);
  }
  return count;
}

[undefinedYu]

这里找到一个好方法。希望能有用。
function substrCount(str, target) {
if(Object.prototype.toString.call(str).slice(8,-1) === 'String' && !str)
alert("请填写字符串")；
else
return (str.match(new RegExp(target, 'g')).length);
}

[qqdnnd]

function getStrTimes(str,rule){
    return rule !=='' && str.match(new RegExp(rule,'g'))? str.match(new RegExp(rule,'g')).length : 0;
}

[Shoryukenbt]

var childInNums = parent.split(child).length - 1, 这个没毛病吧

[tiyunchen]

var childInNums = parent.split(child).length - 1, 这个没毛病吧

感觉没毛病

[myprelude]

fucntion repeat(str,parentStr){
  return parentStr.split(str).length - 1
}

[AricZhu]

// 递归，一行代码实现
function strRepeatCount (subStr, str, count=0) {

return str.indexOf(subStr) !== -1? strRepeatCount(subStr, str.substring(str.indexOf(subStr)+subStr.length), ++count): count;

}

[bWhirring]

function count(str, param) {
  const reg = new RegExp(param, 'g');
  return str.match(reg).length;
}

[Konata9]

const countAppears = (str, target) => {
  let count = 0;

  if (!str || !target) {
    return count;
  }

  const keyIndex = target.indexOf(str);
  if (keyIndex > -1) {
    count = 1 + countAppears(str, target.slice(keyIndex + 1));
  }

  return count;
};

const str = "abcaaadefg2333333333334abcddddea";

console.log(countAppears("2", str));
console.log(countAppears("b", str));
console.log(countAppears("d", str));
console.log(countAppears("a", str));
console.log(countAppears("f", str));

[poporeki]

var childInNums = parent.split(child).length - 1, 这个没毛病吧

这个好啊 又简单

[15190408121]

function strFind (str, target) {
var lengths = 0
if (!target) {
return lengths
}
while(str.match(target)) {
str = str.replace(target, '')
lengths++
}
return lengths
}
var str = "你好 萨达所大所多所多所问问二位无 你好 萨达所大所多 你好"
strFind(str, "你好")

[taiyangxingchen]

var childInNums = parent.split(child).length - 1, 这个没毛病吧

这个真心不错

[shufangyi]

const countString = (str, chars) => (
  (arr = str.match(new RegExp(chars, 'g'))), arr && chars ? arr.length : 0
)

[pythonqi]

fucntion repeat(str,parentStr){
  return parentStr.split(str).length - 1
}

function 关键字写错了

[wyx2014]

function getCount1(str, target,count = 0 ) { var index = str.indexOf(target); if(index!== -1){ return getCount1(str.substring(index+target.length),target,++count) }else { return count; } }

[Vi-jay]

function getTargetCount(arr, target) {
  return arr
    .reduce((group, v) => group.set(v, (group.get(v) || 0) + 1), new Map())
    .get(target);
}
console.log(getTargetCount([1,1,2,5],1));// 2

[wsb260]

// 方法1

var str = 'aabbcaacddaabbccdd'
var str2 = 'aa'

const contSvg = (s1,s2) => {
  var arr = [];
  arr = s1.split(s2);
  console.log(arr.length-1);
}

contSvg(str,str2) // 输出3

// 方法2

// eval() 函数可计算某个字符串，并执行其中的的 JavaScript 代码。
const strCount = (str, target) => {
  if (!target) return count
     return  str.match(eval("/"+target+"/g")).length
}

console.log(strCount('abcd abcde a', 'abc')) // 输出2

[nnnnnnnnnni]

var childInNums = parent.split(child).length - 1, 这个没毛病吧

哈哈哈哈和你的想法一样

[J1nvey]

const letter = "a";
const str = "abcaabccabcaa"
const time = (str, letter) => str.split(letter).length - 1;
console.log(time(str, letter)) // 6

不知道会不会有没有其他特殊情况，这样写的话。。。

[BobLiu1990]

function strCount(str, target) {
  let count = 0;
  while (str.includes(target)) {
    str = str.replace(target, "");
    count++;
  }
  return count;
}
function strCount(str, target) {
  return str.split(target).length - 1;
}
console.log(strCount("asdgqwidugasgdakisdggfjwdagasd", "gas"));

[funlee]

function count(str, string) {
  return Math.max(0, string.split(str).length - 1);
}

[liaoyf]

‘’aa‘’在“aaabcaaa”中出现几次？如果是两次上述答案没有问题，如果是四次
应该可以用零宽正向断言

function subCount(str,target){
  let matchs = str.match(new RegExp(`(?=${target})`, 'g'))
  return matchs ? matchs.length : 0
}

[Daniel-Fang]

fucntion repeat(str,parentStr){
  return parentStr.split(str).length - 1
}

function fn(str, substr) {
    if(substr === '') return 0;
    return str.split(substr).length - 1;
}

[JYone223]

const subStrTimes = (str, sub) => {
  return Array.from(str.matchAll(sub), m => m[0]).length;
}

[lijunren]

function getTimes(str1, str2) {
if (str2.indexOf(str1) === -1) {
return 0;
}
const arr = str2.splite(str1);
return arr.length - 1;
}

[username-xu]

var str = 'aabbccabcaabbccabcabc15114816181abc64641414tregfagfczfavacabaaabc6486';
var strArr = str.split('abc')

console.log(strArr.length -1)

[mopig]

function counter(str, subStr, num = 0, index = 0) {
    let tempIndex = str.indexOf(subStr, index)
    return tempIndex > -1 ? counter(str, subStr, ++num, ++tempIndex) : num
}

[censek]

var childInNums = parent.split(child).length - 1, 这个没毛病吧

👍

[wezzzyang]

function a(x,y) { x = x.split(${y}); return x.length - 1 }
a('124awf125awf12awf5','awf')

//'124125125'

[ducky-YFH]

function check(checkStr, str, len) {
  if(typeof str !== 'string'){
    return;
  }
  len = len || 0;
  let index = str.indexOf(checkStr);
  if (index !== -1) {
    len += 1;
    str = str.replace(checkStr, '');
    check(checkStr, str, len);
  } else {
    console.log(len);
    return;
  }
}
check('火狐', '火狐、谷歌、ie、360、火狐100')

[diandianzd]

function checkTimes(str, target) {
  return str.split(target).length - 1
}


console.log(checkTimes('abcabde', 'ab'))


function subCount(str,target){
  let matchs = str.match(new RegExp(`(?=${target})`, 'g'))
  return matchs ? matchs.length : 0
}

console.log(subCount('abcabde', 'ab'))

[sosamuel]

/**
 * @param {string} str
 * @param {string} target
 * @return {number}
 */
function count(str, target) {
  var n = 0,
    index = -1;
  while (index) {
    index = str.indexOf(target, index) + 1;
    index && n++;
  }
  return n;
}

[nikolausliu]

const countSub = (str, sub) => str.split(sub).length - 1

[crazyming9528]

function strCount(origin, str) {
    var reg = new RegExp(str, 'g');
   // console.log(origin.match(reg));
    return origin.match(reg).length;
}


function strCount2(origin, str) {
    return origin.split(str).length - 1;
}

[yyz841875845]

function count1 (str1, str2){
let arr = str2.split(str1)
return arr.length -1
}
count1('aa', 'aababacaaac')

[YeChang]

//第7天 统计某一字符或字符串在另一个字符串中出现的次数

function subStrCount(str, sub) {
  var count = 0;
  while (str.includes(sub)) {
    const index = str.indexOf(sub);
    count++;
    str = str.substring(index + sub.length);
  }
  return count;
}
var str = "hello hello hello hello";
console.log(subStrCount(str, "e"));

[zlqGitHub]

看了上面大家写的几种，有些多少会存在问题，没有将所有的情景考考进去。
我们应该只能将匹配到的字符第一个字符去掉，他的其他字符依旧可以参与运算中去

      function strCount(str, target) {
            var count = 0;
            if(!target) return count;
            while(str.match(target)) {
                count++;
                // 注意：一定要将当前匹配到的字符第一位及之前的的删除掉
                str = str.substr(str.indexOf(target)+1);

                // 这样处理有缺陷，没有将所有的情况考虑周全
                // str = str.replace(target, '');   
            } 
            return count;
        }
        console.log(strCount('abcdef abcdef a', 'abc'));   //2
        console.log(strCount('ababacdaba', 'aba'));   //3

[qq814927478]

````js
function fun(str, str1) {
let count = 0;
for (let item of str) {
if (item == str1) {
count++
}
}
return count;
}
console.log(fun('1asds1a1dasdq11wenkjz1xhj1kchgqsj1rge1', '1'))

[rni-l]

function getTotal(str, target) {
  const targetLen = target.length
  const targetArray = str.split('')
  return targetArray.reduce((acc, cur, curIndex) => {
    let temp = ''
    for (let i = 0; i <= targetLen - 1; i++) {
      temp += targetArray[i + curIndex]
    }
    if (temp === target) {
      return ++acc
    }
    return acc;
  }, 0)
}
getTotal('hahahahsfdsfdfsda','ha') // 3

[zcCodeWarehouse]

function stringStatistics(str,target,num){
  let count=num?num:0
  const index= target.indexOf(str)
  if(index<0) return count
  count++
  target=target.slice(index+str.length)   //这里也可以用空格替换字符串  我用的是直接删掉了前面的字符串
  return stringStatistics(str,target,count)
} 

[gaoryrt]

不是，楼上各位想用 split 实现的，我就问一句

aaaa 中 aa 出现的次数是不是3

[FJY111]

function searchStr (str, word) {
  if (!str.includes(word)) return 0
  let reg = new RegExp(`(?=${word})`, 'g')
  return str.match(reg).length
}

[blueRoach]

function repeatCount(target, code){
  if(typeof target != 'string' || typeof code != 'string'){
    return
  }
  let index = 0, regexp = new RegExp(code, 'g')
  target.replace(regexp, (a) => index++)
  return index
}

大佬的这个确实牛逼
parent.split(child).length - 1

[gaoryrt]

最高票用 split 的错了！

请思考一下，ababa 里面出现 aba 的次数是多少？
再思考一下，'ababa'.split('aba').length - 1 是多少？

楼上去年就说过这个问题了：https://github.com/haizlin/fe-interview/issues/21#issuecomment-569169790

我五月份也回了个贴就在上面：https://github.com/haizlin/fe-interview/issues/21#issuecomment-596319941

楼上还在「确实牛逼」呢……
单元测试用例多想几个，或者是看看回复都不会出现这种问题

[1415333545]

好多正则得也有问题呢

[giggleCYT]

        function fn(str, tag) {
            var num = 0;
            var reg = new RegExp(tag);
            while (reg.test(str)) {
                str = str.replace(reg, '')
                num++;
            }
            return num;
        }

[gaoryrt]

        function fn(str, tag) {
            var num = 0;
            var reg = new RegExp(tag);
            while (reg.test(str)) {
                str = str.replace(reg, '')
                num++;
            }
            return num;
        }

fn('ababa', 'aba') // 1
should be 2

[Fengzhen8023]

function strShowCount(sourceStr, targetStr) {
let reg = RegExp(targetStr, "g");
let timer = 0;
while(reg.exec(sourceStr)) {
timer++;
}
return timer;
}

console.log(strShowCount("AllenFengeeeeeeFengALlenFen", "Feng"));

[LancelotSaki]

这题出得不太严谨吧，若考虑到里面的字符被复用，那得出的结果不是不一样了。

[Alex-Li2018]

'abc abce fghabc abc'.match(/abc/g)

[hou499]

整理了一下前面正确的方法

function searchStr(str, target) {
    if (!target || !str.includes(target)) return 0;
    let reg = new RegExp(`(?=${target})`, 'g');
    return str.match(reg).length;
}

function strCount(str, target) {
    var count = 0;
    if (!target) return count;
    while (str.match(target)) {
        count++;
        str = str.substr(str.indexOf(target) + 1);
    }
    return count;
}

function count(str, target) {
    var n = 0,
        index = -1;
    while (index) {
        index = str.indexOf(target, index) + 1;
        index && n++;
    }
    return n;
}

function counter(str, subStr, num = 0, index = 0) {
    let tempIndex = str.indexOf(subStr, index);
    return tempIndex > -1 ? counter(str, subStr, ++num, ++tempIndex) : num;
}

function getTotal(str, target) {
    const targetLen = target.length;
    const targetArray = str.split('');
    return targetArray.reduce((acc, cur, curIndex) => {
        let temp = '';
        for (let i = 0; i <= targetLen - 1; i++) {
            temp += targetArray[i + curIndex];
        }
        if (temp === target) {
            return ++acc;
        }
        return acc;
    }, 0);
}

[laboonly]

function somestr (str, target) {

let length = str.length;
let count = target.length;
let sum = 0;
for(let i = 0; i < length - count; i++) {
    if(str.slice(i,i + count) == target) {
        sum++
    }
}
return sum;

}

let sum = somestr('aabbccdbbcdebbceff', 'c');

[yangyingwx]

let i = 0
let reg = /abc/g
while(reg.test(str)){
  ++i
}
console.log(i)

[ascreamz]

function getTotal(str,target){
return str.match(new RegExp(target,'g')).length;
}

[knwceas]

function count(str1, str2) {
  let s = 0;
  for (let i = 0; i <= str2.length-str1.length; i++) {
    if (str1 === str2.substring(i, i + str1.length )) s++;
  }  
  return s;
}

[Liszter]

function getTargetNum (str, target) {
return str.split(target).length - 1
}