如何在JavaScript中编写与C#的String.StartsWith等效的代码?
var haystack = 'hello world';
var needle = 'he';
haystack.startsWith(needle) == true
注意:这是一个老问题,正如ECMAScript 2015(ES6)在评论中指出的那样,引入了.startsWith方法。然而,在编写此更新(2015年)时,浏览器支持还远未完成。
如何在JavaScript中编写与C#的String.StartsWith等效的代码?
var haystack = 'hello world';
var needle = 'he';
haystack.startsWith(needle) == true
注意:这是一个老问题,正如ECMAScript 2015(ES6)在评论中指出的那样,引入了.startsWith方法。然而,在编写此更新(2015年)时,浏览器支持还远未完成。
可以使用ECMAScript 6的String.product.startsWith()方法。所有主要浏览器都支持它。但是,如果您想在不受支持的浏览器中使用它,则需要使用shim/polyfill将其添加到这些浏览器中。创建一个符合规范中列出的所有细节的实现有点复杂。如果您想要一个忠实的垫片,请使用以下任一方法:
Matthias Bynens的String.prototype.startsWith垫片,或es6垫片,尽可能多地垫片es6规格,包括String.prototype.startsWith。
一旦你填充了这个方法(或者如果你只支持已经有它的浏览器和JavaScript引擎),你可以这样使用它:
console.log(“Hello World!”.startsWith(“He”));//真的var haystack=“你好世界”;var前缀='orl';console.log(haystalk.startsWith(前缀));//假的
以下是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稍快且更简洁,但不可读。
使用.lastIndexOf的另一种选择:
haystack.lastIndexOf(needle) === 0
这将在干草堆中向后查看针的出现情况,从干草堆的索引字符串长度开始返回到零。换句话说,它只检查大海捞针是否开始。lastIndexOf提供了第二个可选参数“fromIndex”。如果给定,则反向搜索从该给定索引位置开始,并返回索引零。但是我们不能指定除最后一个索引之外的任何其他fromIndex,否则搜索可能会忽略某些内容。
原则上,这应该比其他一些方法具有性能优势:
它不会搜索整个干草堆。它不会创建新的临时字符串,然后立即丢弃它。
如果没有助手函数,只需使用regex的.test方法:
/^He/.test('Hello world')
要使用动态字符串而不是硬编码字符串(假设字符串不包含任何正则表达式控制字符)执行此操作:
new RegExp('^' + needle).test(haystack)
你应该看看Javascript中是否有RegExp.escape函数?如果存在正则表达式控制字符出现在字符串中的可能性。
还可以查看underscore.string.js。它提供了一系列有用的字符串测试和操作方法,包括startsWith方法。从文档中:
startsWith_.startsWith(字符串,开始)此方法检查字符串是否以start开头。_(“image.gif”).startsWith(“image”)=>真
var str = 'hol';
var data = 'hola mundo';
if (data.length >= str.length && data.substring(0, str.length) == str)
return true;
else
return false;
如果使用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://stringjs.com/
包括js文件,然后像这样使用S变量:
S('hi there').endsWith('hi there')
它也可以通过安装在NodeJS中使用:
npm install string
然后要求它作为S变量:
var S = require('string');
如果你不喜欢这个字符串库的话,这个网页也有指向其他字符串库的链接。
我最近问了自己同样的问题。有多种可能的解决方案,以下是3种有效的解决方案:
s.indexOf(启动器)==0s.substr(0,starter.length)==启动器s.lastIndexOf(starter,0)==0(在看到Mark Byers的答案后添加)使用循环:函数startsWith(s,starter){对于(var i=0,cur_c;i<starter.length;i++){cur_c=启动器[i];如果(s[i]!==启动器[i]){return false;}}返回true;}
我还没有遇到使用循环的最后一个解决方案。令人惊讶的是,该解决方案以显著的优势优于前3个解决方案。下面是我为得出这个结论而执行的jsperf测试:http://jsperf.com/startswith2/2
和平
ps:ecmascript 6(harmony)为字符串引入了本机startsWith方法。试想一下,如果他们想到在初始版本中包含这个非常需要的方法,会节省多少时间。
使现代化
正如Steve所指出的(关于这个答案的第一条评论),如果给定的前缀短于整个字符串,上述自定义函数将抛出错误。他已经解决了这个问题,并添加了一个循环优化,可以在http://jsperf.com/startswith2/4.
请注意,Steve包含了两个循环优化,其中第一个显示了更好的性能,因此我将在下面发布代码:
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;
}
最好的性能解决方案是停止使用库调用,只需认识到您使用的是两个阵列。手动实现既短又快,比我在这里看到的其他解决方案都快。
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.(确保您检查了可能胜过我的更高版本。)
根据这里的答案,这是我现在使用的版本,因为它似乎基于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.我添加了一个小的调整,以实现微小的性能改进,此后还添加了一项检查,以检查比较字符串是否为空或未定义,并使用CMS答案中的技术将其转换为添加到字符串原型中。
注意,这个实现不支持Mozilla开发者网络页面中提到的“position”参数,但这似乎并不是ECMAScript建议的一部分。
由于这是如此流行,我认为值得指出的是,在ECMA 6中有一种实现该方法的方法,并且为了准备使用“官方”polyfill,以防止将来出现问题和撕裂。
幸运的是,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时可以优雅地忽略它。
我只是想补充一下我对此的看法。
我想我们可以这样使用:
var haystack = 'hello world';
var needle = 'he';
if (haystack.indexOf(needle) == 0) {
// Code if string starts with this substring
}
最佳解决方案:
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.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
我不确定javascript,但在typescript中我做了类似的事情
var str = "something";
(<String>str).startsWith("some");
我想它应该也适用于js。我希望这有帮助!
这个问题有点老了,但我想写这个答案来向您展示我根据这里提供的所有答案和吉姆·巴克分享的jsperf所做的一些基准测试。
我基本上需要一种快速的方法来发现一根长针是否在一个长长的草堆里,除了最后几个字符之外,它们都非常相似。
下面是我为每个函数(拼接、子字符串、startsWith等)编写的代码,当它们返回false和true时,会对1.000.0001个字符的草垛字符串(nestedString)和1.000.000个字符的伪针字符串(分别为testParentStringFalse和testParentString true)进行测试:
// 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 75、Firefox 67、Safari 12和Opera 62上运行了这个基准测试。
我没有包括Edge和IE,因为我在这台机器上没有它们,但如果你们中有人想对Edge和至少IE 9运行脚本并在这里共享输出,我会很好奇看到结果。
请记住,您需要重新创建3个长字符串,并将脚本保存在一个文件中,然后在浏览器中打开该文件,因为在浏览器控制台上复制/粘贴将阻止它,因为每个字符串的长度都大于等于1.000.000)。
以下是输出:
Chrome 75(子字符串获胜):
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(假结果时切片获胜,真结果时开始,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(子字符串获胜。结果与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}
事实证明,每个浏览器都有自己的实现细节(除了基于Chrome的Chromium和Blink的Opera)。
当然,可以也应该对不同的用例进行进一步的测试(例如,当针与干草堆相比真的很短时,干草堆比针短时,等等),但在我的案例中,我需要比较非常长的字符串,并希望在这里分享。