如何检查字符串“ StartsWith”是否为另一个字符串?

2020/09/15 18:31 · javascript ·  · 0评论

如何String.StartsWith在JavaScript中编写等效于C#的代码

var haystack = 'hello world';
var needle = 'he';

haystack.startsWith(needle) == true

注意:这是一个古老的问题,正如注释ECMAScript 2015(ES6)中指出的那样,介绍了该.startsWith方法。但是,在撰写此更新(2015)时,浏览器支持还远远没有完成

您可以使用ECMAScript 6的String.prototype.startsWith()方法,但并非所有浏览器都支持该方法您将需要使用填充程序/填充来将其添加到不支持它的浏览器中。创建一个符合规范中所有细节的实现有点复杂。如果您想要忠实的垫片,请使用以下任一方法:

对方法进行填充后(或者如果您仅支持已具有该方法的浏览器和JavaScript引擎),则可以按以下方式使用它:

"Hello World!".startsWith("He"); // true

var haystack = "Hello world";
var prefix = 'orl';
haystack.startsWith(prefix); // false

另一种选择是.lastIndexOf

haystack.lastIndexOf(needle, 0) === 0

这看起来向后通过haystack为的发生needle,从指数开始0haystack换句话说,它仅检查是否haystack以开头needle

原则上,与其他方法相比,这应该具有性能优势:

  • 它不会搜索整个haystack
  • 它不会创建新的临时字符串,然后立即将其丢弃。
data.substring(0, input.length) === input

没有辅助函数,只需使用正则表达式的.test方法:

/^He/.test('Hello world')

为此,请使用动态字符串而不是硬编码的字符串(假设该字符串将不包含任何正则表达式控制字符):

new RegExp('^' + needle).test(haystack)

您应该检查一下Java中是否有RegExp.escape函数?如果有可能在字符串中出现正则表达式控制字符。

最佳解决方案:

function startsWith(str, word) {
    return str.lastIndexOf(word, 0) === 0;
}

这里是的endsWith如果你需要它:

function endsWith(str, word) {
    return str.indexOf(word, str.length - word.length) !== -1;
}

对于那些喜欢将其原型化为String的用户:

String.prototype.startsWith || (String.prototype.startsWith = function(word) {
    return this.lastIndexOf(word, 0) === 0;
});

String.prototype.endsWith   || (String.prototype.endsWith = function(word) {
    return this.indexOf(word, this.length - word.length) !== -1;
});

用法:

"abc".startsWith("ab")
true
"c".ensdWith("c") 
true

使用方法:

startsWith("aaa", "a")
true
startsWith("aaa", "ab")
false
startsWith("abc", "abc")
true
startsWith("abc", "c")
false
startsWith("abc", "a")
true
startsWith("abc", "ba")
false
startsWith("abc", "ab")
true

我只是想补充一下我的看法。

我认为我们可以这样使用:

var haystack = 'hello world';
var needle = 'he';

if (haystack.indexOf(needle) == 0) {
  // Code if string starts with this substring
}

这是CMS解决方案的一个小改进:

if(!String.prototype.startsWith){
    String.prototype.startsWith = function (str) {
        return !this.indexOf(str);
    }
}

"Hello World!".startsWith("He"); // true

 var data = "Hello world";
 var input = 'He';
 data.startsWith(input); // true

检查该功能是否已经存在,以防将来的浏览器以本机代码实现该功能或由另一个库实现。例如,原型库已经实现了此功能。

使用起来虽然不那么可读,但!速度更快,更简洁=== 0

还要查看underscore.string.js它附带了一堆有用的字符串测试和操作方法,包括一个startsWith方法。从文档:

以。。开始 _.startsWith(string, starts)

此方法检查是否string以开头starts

_("image.gif").startsWith("image")
=> true

我最近问自己同样的问题。

可能有多种解决方案,这里有3种有效的解决方案:

  • s.indexOf(starter) === 0
  • s.substr(0,starter.length) === starter
  • s.lastIndexOf(starter, 0) === 0(在看到Mark Byers的回答后添加
  • 使用循环:

    function startsWith(s,starter) {
      for (var i = 0,cur_c; i < starter.length; i++) {
        cur_c = starter[i];
        if (s[i] !== starter[i]) {
          return false;
        }
      }
      return true;
    }

我还没有遇到使用循环的最后一个解决方案。

出人意料的是,该解决方案的性能大大优于前三个。


这是我为了得出此结论而执行的jsperf测试:
http ://jsperf.com/startswith2/2

和平

ps:ecmascript 6(和声)引入了startsWith字符串的本机方法。

只需考虑一下,如果他们考虑将这种急需的方法包括在初始版本本身中,将节省多少时间。

更新资料

正如Steve指出的那样(此答案的第一条评论),如果给定的前缀短于整个字符串,则上述自定义函数将引发错误他已修复此问题,并添加了循环优化功能,可以在http://jsperf.com/startswith2/4上进行查看

请注意,Steve包括2个循环优化,这两个循环中的第一个显示了更好的性能,因此我将在下面发布该代码:

function startsWith2(str, prefix) {
  if (str.length < prefix.length)
    return false;
  for (var i = prefix.length - 1; (i >= 0) && (str[i] === prefix[i]); --i)
    continue;
  return i < 0;
}

由于这种方法非常流行,因此我认为值得指出的是,ECMA 6中有一种方法可以实现,并且为防止将来出现问题和泪花,应使用“官方”填料。

幸运的是,Mozilla的专家为我们提供了一个:

https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith

if (!String.prototype.startsWith) {
    String.prototype.startsWith = function(searchString, position) {
        position = position || 0;
        return this.indexOf(searchString, position) === position;
    };
}

请注意,这样做的好处是在过渡到ECMA 6时会被忽略。

最好的性能解决方案是停止使用库调用,而只是识别您正在使用两个数组。与我在这里看到的所有其他解决方案相比,手动实施的实现既简短又快捷。

function startsWith2(str, prefix) {
    if (str.length < prefix.length)
        return false;
    for (var i = prefix.length - 1; (i >= 0) && (str[i] === prefix[i]); --i)
        continue;
    return i < 0;
}

有关性能比较(成功与失败),请参见http://jsperf.com/startswith2/4(确保您检查了可能胜过我的更高版本。)

我刚刚了解了这个字符串库:

http://stringjs.com/

包含js文件,然后使用如下S变量:

S('hi there').endsWith('hi there')

也可以通过安装它在NodeJS中使用:

npm install string

然后将其作为S变量:

var S = require('string');

如果您不喜欢该网页,则该网页还具有指向其他字符串库的链接。

  1. 这个问题有点老了,但是我想写这个答案来向您展示我根据此处提供的所有答案以及Jim Buck共享的jsperf所做的一些基准测试。

我基本上需要一种快速的方法来查找长草堆中是否有长针,除了最后一个字符,它们非常相似。

这是我编写的代码,对于每个函数(splice,substring,startsWith等),它们都会针对nestedString1.000.0001个字符的干草堆字符串()和1.000.000个虚假或真假的字符串返回false和true时进行测试字符(testParentStringFalsetestParentStringTrue,分别为):

// nestedString is made of 1.000.001 '1' repeated characters.
var nestedString = '...'

// testParentStringFalse is made of 1.000.000 characters,
// all characters are repeated '1', but the last one is '2',
// so for this string the test should return false.
var testParentStringFalse = '...'

// testParentStringTrue is made of 1.000.000 '1' repeated characters,
// so for this string the test should return true.
var testParentStringTrue = '...'

// You can make these very long strings by running the following bash command
// and edit each one as needed in your editor
// (NOTE: on OS X, `pbcopy` copies the string to the clipboard buffer,
//        on Linux, you would probably need to replace it with `xclip`):
// 
//     printf '1%.0s' {1..1000000} | pbcopy
// 

function testString() {
    let dateStart
    let dateEnd
    let avg
    let count = 100000
    const falseResults = []
    const trueResults = []

    /* slice */
    console.log('========> slice')
    dateStart = +new Date()
    var res
    for (let j = 0; j < count; j++) {
        res = nestedString.slice(0, testParentStringFalse.length) === testParentStringFalse
    }
    dateEnd = +new Date()
    avg = (dateEnd - dateStart)/count
    falseResults[falseResults.length] = {
        label: 'slice',
        avg
    }
    console.log(`testString() slice = false`, res, 'avg: ' + avg + 'ms')

    dateStart = +new Date()
    var res
    for (let j = 0; j < count; j++) {
        res = nestedString.slice(0, testParentStringTrue.length) === testParentStringTrue
    }
    dateEnd = +new Date()
    avg = (dateEnd - dateStart)/count
    trueResults[trueResults.length] = {
        label: 'slice',
        avg
    }
    console.log(`testString() slice = true`, res, 'avg: ' + avg + 'ms')
    console.log('<======== slice')
    console.log('')
    /* slice END */

    /* lastIndexOf */
    console.log('========> lastIndexOf')
    dateStart = +new Date()
    var res
    for (let j = 0; j < count; j++) {
        res = nestedString.lastIndexOf(testParentStringFalse, 0) === 0
    }
    dateEnd = +new Date()
    avg = (dateEnd - dateStart)/count
    falseResults[falseResults.length] = {
        label: 'lastIndexOf',
        avg
    }
    console.log(`testString() lastIndexOf = false`, res, 'avg: ' + avg + 'ms')

    dateStart = +new Date()
    var res
    for (let j = 0; j < count; j++) {
        res = nestedString.lastIndexOf(testParentStringTrue, 0) === 0
    }
    dateEnd = +new Date()
    avg = (dateEnd - dateStart)/count
    trueResults[trueResults.length] = {
        label: 'lastIndexOf',
        avg
    }
    console.log(`testString() lastIndexOf = true`, res, 'avg: ' + avg + 'ms')
    console.log('<======== lastIndexOf')
    console.log('')
    /* lastIndexOf END */

    /* indexOf */
    console.log('========> indexOf')
    dateStart = +new Date()
    var res
    for (let j = 0; j < count; j++) {
        res = nestedString.indexOf(testParentStringFalse) === 0
    }
    dateEnd = +new Date()
    avg = (dateEnd - dateStart)/count
    falseResults[falseResults.length] = {
        label: 'indexOf',
        avg
    }
    console.log(`testString() indexOf = false`, res, 'avg: ' + avg + 'ms')

    dateStart = +new Date()
    var res
    for (let j = 0; j < count; j++) {
        res = nestedString.indexOf(testParentStringTrue) === 0
    }
    dateEnd = +new Date()
    avg = (dateEnd - dateStart)/count
    trueResults[trueResults.length] = {
        label: 'indexOf',
        avg
    }
    console.log(`testString() indexOf = true`, res, 'avg: ' + avg + 'ms')
    console.log('<======== indexOf')
    console.log('')
    /* indexOf END */

    /* substring */
    console.log('========> substring')
    dateStart = +new Date()
    var res
    for (let j = 0; j < count; j++) {
        res = nestedString.substring(0, testParentStringFalse.length) === testParentStringFalse
    }
    dateEnd = +new Date()
    avg = (dateEnd - dateStart)/count
    falseResults[falseResults.length] = {
        label: 'substring',
        avg
    }
    console.log(`testString() substring = false`, res, 'avg: ' + avg + 'ms')

    dateStart = +new Date()
    var res
    for (let j = 0; j < count; j++) {
        res = nestedString.substring(0, testParentStringTrue.length) === testParentStringTrue
    }
    dateEnd = +new Date()
    avg = (dateEnd - dateStart)/count
    trueResults[trueResults.length] = {
        label: 'substring',
        avg
    }
    console.log(`testString() substring = true`, res, 'avg: ' + avg + 'ms')
    console.log('<======== substring')
    console.log('')
    /* substring END */

    /* startsWith */
    console.log('========> startsWith')
    dateStart = +new Date()
    var res
    for (let j = 0; j < count; j++) {
        res = nestedString.startsWith(testParentStringFalse)
    }
    dateEnd = +new Date()
    avg = (dateEnd - dateStart)/count
    falseResults[falseResults.length] = {
        label: 'startsWith',
        avg
    }
    console.log(`testString() startsWith = false`, res, 'avg: ' + avg + 'ms')

    dateStart = +new Date()
    var res
    for (let j = 0; j < count; j++) {
        res = nestedString.startsWith(testParentStringTrue)
    }
    dateEnd = +new Date()
    avg = (dateEnd - dateStart)/count
    trueResults[trueResults.length] = {
        label: 'startsWith',
        avg
    }
    console.log(`testString() startsWith = true`, res, 'avg: ' + avg + 'ms')
    console.log('<======== startsWith')
    console.log('')
    /* startsWith END */

    falseResults.sort((a, b) => a.avg - b.avg)
    trueResults.sort((a, b) => a.avg - b.avg)

    console.log('false results from fastest to slowest avg:', falseResults)
    console.log('true results from fastest to slowest avg:', trueResults)
}

我在Chrome 75Firefox 67Safari 12Opera 62上运行了此基准测试

我没有包括Edge和IE,因为我没有在这台计算机上使用它们,但是如果你们中的某人想要针对Edge和至少IE 9运行脚本并在此处共享输出,我将很好奇看到结果。

只需记住,您需要重新创建3个长字符串,并将脚本保存到文件中,然后在浏览器中打开该文件,因为在浏览器控制台上复制/粘贴将阻止该脚本,因为每个字符串的长度> = 1.000.000)。

以下是输出:

Chrome 75(substring获胜):

false results from fastest to slowest avg:
1)  {"label":"substring","avg":0.08271}
2)  {"label":"slice","avg":0.08615}
3)  {"label":"lastIndexOf","avg":0.77025}
4)  {"label":"indexOf","avg":1.64375}
5)  {"label":"startsWith","avg":3.5454}

true results from fastest to slowest avg:
1)  {"label":"substring","avg":0.08213}
2)  {"label":"slice","avg":0.08342}
3)  {"label":"lastIndexOf","avg":0.7831}
4)  {"label":"indexOf","avg":0.88988}
5)  {"label":"startsWith","avg":3.55448}

Firefox 67(indexOf获胜):

false results from fastest to slowest avg
1)  {"label":"indexOf","avg":0.1807}
2)  {"label":"startsWith","avg":0.74621}
3)  {"label":"substring","avg":0.74898}
4)  {"label":"slice","avg":0.78584}
5)  {"label":"lastIndexOf","avg":0.79668}

true results from fastest to slowest avg:
1)  {"label":"indexOf","avg":0.09528}
2)  {"label":"substring","avg":0.75468}
3)  {"label":"startsWith","avg":0.76717}
4)  {"label":"slice","avg":0.77222}
5)  {"label":"lastIndexOf","avg":0.80527}

Safari 12(slice以虚假结果startsWith获胜,以真实结果获胜,就执行整个测试的总时间而言,Safari也是最快的):

false results from fastest to slowest avg:
1) "{\"label\":\"slice\",\"avg\":0.0362}"
2) "{\"label\":\"startsWith\",\"avg\":0.1141}"
3) "{\"label\":\"lastIndexOf\",\"avg\":0.11512}"
4) "{\"label\":\"substring\",\"avg\":0.14751}"
5) "{\"label\":\"indexOf\",\"avg\":0.23109}"

true results from fastest to slowest avg:
1) "{\"label\":\"startsWith\",\"avg\":0.11207}"
2) "{\"label\":\"lastIndexOf\",\"avg\":0.12196}"
3) "{\"label\":\"substring\",\"avg\":0.12495}"
4) "{\"label\":\"indexOf\",\"avg\":0.33667}"
5) "{\"label\":\"slice\",\"avg\":0.49923}"

Opera 62(substring获胜。结果类似于Chrome,由于Opera基于Chromium和Blink,因此我并不感到惊讶):

false results from fastest to slowest avg:
{"label":"substring","avg":0.09321}
{"label":"slice","avg":0.09463}
{"label":"lastIndexOf","avg":0.95347}
{"label":"indexOf","avg":1.6337}
{"label":"startsWith","avg":3.61454}

true results from fastest to slowest avg:
1)  {"label":"substring","avg":0.08855}
2)  {"label":"slice","avg":0.12227}
3)  {"label":"indexOf","avg":0.79914}
4)  {"label":"lastIndexOf","avg":1.05086}
5)  {"label":"startsWith","avg":3.70808}

事实证明,每个浏览器都有自己的实现细节(Opera,它基于Chrome的Chromium和Blink)。

当然,可以并且应该在不同的用例下进行进一步的测试(例如,当针比干草堆短时,当干草堆比针短时,等等...),但是在我的情况下,我需要比较长的字符串和想在这里分享。

var str = 'hol';
var data = 'hola mundo';
if (data.length >= str.length && data.substring(0, str.length) == str)
    return true;
else
    return false;

根据此处的答案,这是我正在使用的版本,因为它似乎基于JSPerf测试提供了最佳性能(据我所知,它在功能上是完整的)。

if(typeof String.prototype.startsWith != 'function'){
    String.prototype.startsWith = function(str){
        if(str == null) return false;
        var i = str.length;
        if(this.length < i) return false;
        for(--i; (i >= 0) && (this[i] === str[i]); --i) continue;
        return i < 0;
    }
}

这是基于以下位置的startsWith2:http : //jsperf.com/startswith2/6我添加了一个小的调整以改善性能,此后还添加了对比较字符串是否为null或undefined的检查,并使用CMS的答案中的技术将其转换为String原型。

请注意,此实现不支持此Mozilla开发人员网络页面中提到的“ position”参数,但是无论如何,这似乎并不是ECMAScript提议的一部分。

我不确定使用JavaScript,但在打字稿中我做了类似的事情

var str = "something";
(<String>str).startsWith("some");

我猜它也应该在js上工作。希望对您有所帮助!

字符串对象具有startsWith,endsWith之类的方法,并包含一些方法。

  • StartsWith检查给定的字符串是否以开头开头。

  • EndsWith检查给定的字符串是否在结尾。

  • 包括检查给定的字符串是否存在于任何部分。

您可以在下面的YouTube视频中找到这三者的完全区别

https://www.youtube.com/watch?v=E-hyeSwg0PA

如果您正在与之合作startsWith()endsWith()那么您必须注意前导空格。这是一个完整的示例:

var str1 = " Your String Value Here.!! "; // Starts & ends with spaces    
if (str1.startsWith("Your")) { }  // returns FALSE due to the leading spaces…
if (str1.endsWith("Here.!!")) { } // returns FALSE due to trailing spaces…

var str2 = str1.trim(); // Removes all spaces (and other white-space) from start and end of `str1`.
if (str2.startsWith("Your")) { }  // returns TRUE
if (str2.endsWith("Here.!!")) { } // returns TRUE

您还可以通过创建自己的原型/数组原型扩展名(也称为数组)来返回以字符串开头的数组的所有成员。

Array.prototype.mySearch = function (target) {
    if (typeof String.prototype.startsWith != 'function') {
        String.prototype.startsWith = function (str){
        return this.slice(0, str.length) == str;
      };
    }
    var retValues = [];
    for (var i = 0; i < this.length; i++) {
        if (this[i].startsWith(target)) { retValues.push(this[i]); }
    }
    return retValues;
};

并使用它:

var myArray = ['Hello', 'Helium', 'Hideout', 'Hamster'];
var myResult = myArray.mySearch('Hel');
// result -> Hello, Helium
本文地址:http://javascript.askforanswer.com/ruhejianchazifuchuan-startswithshifouweilingyigezifuchuan.html
文章标签: ,   ,  
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

上一篇:
下一篇:

评论已关闭!