Question

所以我需要实现一个javascript方法，它将返回true或false，具体取决于masterString是否包含subString。

我做了类似的事情，但不确定这是否是正确的方法：

function contains(masterString, subString) {
if(subString.length > masterString.length){
    return false;
}
for(var i=subString.length-1; i<masterString.length; i++){
    if(concatString(i - subString.length-1, i, masterString) === subString){
        return true;
    }
}
  return false;

}

function concatString(index1, index2, string){
    var conString = '';
  console.log(index1, index2-1, string);
    for(var i=index1; i<index2-1; i++){
        conString += string[i];
    }
  console.log(conString);
    return conString;
}


contains('abcd', 'bc');

但它并没有正常工作。

我们可以实施吗？谢谢:)）

Answer 1

对于每个可能的索引，测试subString是否在masterString的索引上。

var indexOf = function(masterString,subString){
    for(var i = 0 ; i < masterString.length - subString.length + 1; i++){
        var match = true;
        for(var j = 0; j < subString.length; j++){
            if(masterString[i + j] !== subString[j]){
                match = false;
                break;
            }
        }
        if(match)
            return i;
    }   
    return -1;
}       

var contains = function(master,sub){ 
    return indexOf(master,sub) !== -1; 
}

注意：像Knuth-Morris-Pratt这样可以实现更快的算法。

Answer 2

您可以使用嵌套循环：

function contains(masterString, subString) {
  outerloop:
  for(var i=0; i <= masterString.length-subString.length; ++i) {
    for(var j=0; j<subString.length; ++j)
      if(masterString[i + j] !== subString[j]) continue outerloop;
    return true;
  }
  return false;
}

当然，使用本机方法可以获得更好的性能。

Answer 3

你有一个很好的解决方案。但我认为我的比较容易。

顺便说一句：我认为.length也是一个javascript函数。

＆＃13;

function length(string){
  var count = 0;
  while(string[count] != undefined)
     count++;
  return count;
}

function contains(masterString, subString) {
    var masterStringLength = length(masterString);
    var subStringLength = length(subString);
    for(var i = 0; i <= masterStringLength - subStringLength; i++)
    {
        var count = 0;
        for(var k = 0; k < subStringLength; k++)
        {
            if(masterString[i + k] == subString[k])
               count++;
            else
               break;
        }
        if(count == subStringLength)
            return true;

    }
    return false;
}

console.log(contains('abcdefgh', 'bcde'));
console.log(contains('abcdefgh', 'ab'));
console.log(contains('abcdefgh', 'fgh'));

＆＃13;

Answer 4

这类似于最长的公共子序列See this。此代码解决了您的问题。

function contains(masterString, subString) {
        if (findCommonSubsequence(masterString, subString) == subString)
            alert(true);
        else
            alert(false);
    }

    function findCommonSubsequence(a, b) {

        var table = [],
            aLen = a.length,
            bLen = b.length;
        squareLen = Math.max(aLen, bLen);
        // Initialize a table of zeros
        for (var i = 0; i <= squareLen ; i++) {
            table.push([]);
            for (var j = 0; j <= squareLen; j++) {
                table[i][j] = 0;
            }
        }
        // Create a table of counts
        for (var i = 1; i <= aLen; i++) {
            for (var j = 1; j <= bLen; j++) {
                if (a[i - 1] == b[j - 1]) {
                    table[i][j] = table[i - 1][j - 1] + 1;
                } else {
                    table[i][j] = Math.max(table[i - 1][j], table[i][j - 1]);
                }
            }
        }

        // Move backwards along the table
        i = aLen, j = bLen, LCS = [];
        while (i > 0 && j > 0) {
            if (a[i - 1] == b[j - 1]) {
                LCS.push(a[i - 1]);
                i -= 1;
                j -= 1;
            } else {
                if (table[i][j - 1] >= table[i - 1][j]) {
                    j -= 1;
                } else {
                    i -= 1;
                }
            }
        }
        return(LCS.reverse().join(''));
    }

Answer 5

你的问题没有足够的奇怪约束，所以我们来做吧在ES6的帮助下，没有for循环。

＆＃13;

// Cf. Array.prototype.some
const any = (f, [x,...xs]) =>
    x === undefined ? false : f(x) || any(f,xs);

// Return true if the first iterable is a prefix of the second.
const isprefix = ([x,...xs], [y,...ys]) =>
    x === undefined ? true : x == y && isprefix(xs,ys);

// tails('abc') --> [['a','b','c'], ['b','c'], ['c']]
const tails = ([x,...xs]) =>
    x === undefined ? [] : [[x,...xs],...tails(xs)];

// If needle is empty, or is a prefix of any of tails(haystack), return true.
const contains = (haystack, needle) =>
    needle.length ? any(bale => isprefix(needle, bale), tails(haystack)) : true;

const tests = [
    ['aaafoobar', 'foo'],
    ['foo', 'foo'],
    ['fo', 'foo'],
    ['', 'f'],
    ['f', ''],
    ['', '']
];

tests.forEach(test => console.log(JSON.stringify(test), contains(test[0], test[1])));

＆＃13;

Answer 6

你可以这样做

＆＃13;

var  substr = "test",
  masterstr = "test1",
checksubstr = (ms,ss) => !!~ms.indexOf(ss);

console.log(checksubstr(masterstr,substr));

＆＃13;

不使用任何标准JavaScript方法检查字符串是否包含子字符串？

6 个答案: