如何在JavaScript中编写与C#的String.StartsWith等效的代码？
var haystack = 'hello world';
var needle = 'he';
haystack.startsWith(needle) == true
注意：这是一个老问题，正如ECMAScript 2015（ES6）在评论中指出的那样，引入了.startsWith方法。然而，在编写此更新（2015年）时，浏览器支持还远未完成。
当前回答
我最近问了自己同样的问题。有多种可能的解决方案，以下是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;
}
其他回答
我刚刚了解了这个字符串库：
http://stringjs.com/
包括js文件，然后像这样使用S变量：
S('hi there').endsWith('hi there')
它也可以通过安装在NodeJS中使用：
npm install string
然后要求它作为S变量：
var S = require('string');
如果你不喜欢这个字符串库的话，这个网页也有指向其他字符串库的链接。
data.substring(0, input.length) === input
最好的性能解决方案是停止使用库调用，只需认识到您使用的是两个阵列。手动实现既短又快，比我在这里看到的其他解决方案都快。
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.（确保您检查了可能胜过我的更高版本。）
如果没有助手函数，只需使用regex的.test方法：
/^He/.test('Hello world')
要使用动态字符串而不是硬编码字符串（假设字符串不包含任何正则表达式控制字符）执行此操作：
new RegExp('^' + needle).test(haystack)
你应该看看Javascript中是否有RegExp.escape函数？如果存在正则表达式控制字符出现在字符串中的可能性。
这个问题有点老了，但我想写这个答案来向您展示我根据这里提供的所有答案和吉姆·巴克分享的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）。
当然，可以也应该对不同的用例进行进一步的测试（例如，当针与干草堆相比真的很短时，干草堆比针短时，等等），但在我的案例中，我需要比较非常长的字符串，并希望在这里分享。
