String.StartsWith我将如何在 JavaScript 中编写相当于 C# 的代码？
var haystack = 'hello world';
var needle = 'he';
haystack.startsWith(needle) == true
注意：这是一个老问题，正如评论中指出的 ECMAScript 2015 (ES6) 介绍了该.startsWith方法。但是，在撰写此更新 (2015) 时，浏览器支持还远未完成。
sol
问问题
998909 次
19 回答
1838
您可以使用 ECMAScript 6 的String.prototype.startsWith()方法，但尚未在所有浏览器中都支持。您需要使用 shim/polyfill 将其添加到不支持它的浏览器上。创建一个符合规范中列出的所有细节的实现有点复杂。如果您想要一个忠实的垫片，请使用：
- Matthias Bynens 的
String.prototype.startsWith垫片，或 - es6 -shim，它尽可能多地填充 ES6 规范，包括
String.prototype.startsWith.
一旦你填充了这个方法（或者如果你只支持已经拥有它的浏览器和 JavaScript 引擎），你可以像这样使用它：
console.log("Hello World!".startsWith("He")); // true
var haystack = "Hello world";
var prefix = 'orl';
console.log(haystack.startsWith(prefix)); // false于 2009-03-14T20:19:13.077 回答
1305
另一种选择.lastIndexOf：
haystack.lastIndexOf(needle, 0) === 0
这会向后看，haystack以查找needle从 的索引开始0的事件haystack。换句话说，它只检查是否haystack以needle.
原则上，这应该比其他一些方法具有性能优势：
- 它不会搜索整个
haystack. - 它不会创建一个新的临时字符串然后立即丢弃它。
于 2011-01-02T16:14:42.457 回答
598
data.substring(0, input.length) === input
于 2009-03-14T20:14:12.107 回答
186
没有辅助函数，只需使用正则表达式的.test方法：
/^He/.test('Hello world')
要使用动态字符串而不是硬编码的字符串来执行此操作（假设字符串不包含任何正则表达式控制字符）：
new RegExp('^' + needle).test(haystack)
您应该查看JavaScript 中是否有 RegExp.escape 函数？如果存在正则表达式控制字符出现在字符串中的可能性。
于 2011-01-04T00:59:29.600 回答
72
最佳解决方案：
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
于 2016-04-26T21:56:14.360 回答
55
我只是想补充一下我对此的看法。
我认为我们可以这样使用：
var haystack = 'hello world';
var needle = 'he';
if (haystack.indexOf(needle) == 0) {
// Code if string starts with this substring
}
于 2016-02-12T14:47:19.157 回答
40
这是对 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可读性要快一些，也更简洁。
于 2009-05-27T02:54:51.353 回答
21
另请查看underscore.string.js。它带有一堆有用的字符串测试和操作方法，包括一个startsWith方法。从文档：
以。。开始
_.startsWith(string, starts)此方法检查是否
string以starts._("image.gif").startsWith("image") => true
于 2011-05-31T18:29:50.940 回答
15
我最近问自己同样的问题。
有多种可能的解决方案，这里有 3 个有效的解决方案：
s.indexOf(starter) === 0s.substr(0,starter.length) === starters.lastIndexOf(starter, 0) === 0（看到马克拜尔斯的回答后添加）使用循环：
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; }
我还没有遇到最后一个使用循环的解决方案。
令人惊讶的是，该解决方案的性能明显优于前 3 个。
这是我为得出这个结论而执行的 jsperf 测试：http: //jsperf.com/startswith2/2
和平
ps：ecmascript 6 (harmony)startsWith为字符串引入了原生方法。
试想一下，如果他们考虑在初始版本本身中包含这个急需的方法，将会节省多少时间。
更新
正如史蒂夫指出的那样（对此答案的第一条评论），如果给定的前缀比整个字符串短，上述自定义函数将引发错误。他已经解决了这个问题并添加了一个循环优化，可以在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;
}
于 2014-05-17T09:07:07.260 回答
11
由于这很受欢迎，我认为值得指出的是，在 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 时被优雅地忽略的优势。
于 2016-01-05T11:34:05.247 回答
5
最好的性能解决方案是停止使用库调用，而只是认识到您正在使用两个数组。与我在这里看到的所有其他解决方案相比，手动实现既短又快。
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。（确保您检查可能胜过我的更高版本。）
于 2014-07-15T01:39:46.940 回答
3
- 这个问题有点老了，但我想写这个答案来向你展示我根据这里提供的所有答案和 Jim Buck 分享的 jsperf 所做的一些基准测试。
我基本上需要一种快速的方法来确定一根长针是否在一个长长的大海捞针中，它们非常相似，除了最后一个字符。
这是我编写的代码，它为每个函数（拼接、子字符串、startsWith 等）测试它们在返回 false 和 true 时针对nestedString1.000.0001 个字符的 haystack 字符串 ( ) 和 1.000.000 的假或真针字符串字符（testParentStringFalse和testParentStringTrue，分别）：
// 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（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}
事实证明，每个浏览器都有自己的实现细节（除了基于 Chrome 的 Chromium 和 Blink 的 Opera）。
当然，可以并且应该对不同的用例进行进一步测试（例如，当针与干草堆相比真的很短时，当干草堆比针短时等等......），但在我的情况下，我需要比较非常长的字符串和想在这里分享。
于 2019-07-14T14:26:44.320 回答
2
我刚刚了解了这个字符串库：
包含 js 文件，然后S像这样使用变量：
S('hi there').endsWith('hi there')
它也可以通过安装在 NodeJS 中使用：
npm install string
然后要求它作为S变量：
var S = require('string');
如果您不喜欢这个网页，该网页还包含指向备用字符串库的链接。
于 2014-04-29T10:22:18.047 回答
1
var str = 'hol';
var data = 'hola mundo';
if (data.length >= str.length && data.substring(0, str.length) == str)
return true;
else
return false;
于 2012-05-04T14:04:52.403 回答
0
根据此处的答案，这是我现在正在使用的版本，因为它似乎提供了基于 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 开发人员网络页面中提到的“位置”参数，但这似乎不是 ECMAScript 提案的一部分。
于 2014-09-24T15:29:26.357 回答
0
我不确定javascript但在打字稿中我做了类似的事情
var str = "something";
(<String>str).startsWith("some");
我想它也应该适用于js。我希望它有帮助！
于 2019-07-11T09:09:47.443 回答
0
字符串对象具有诸如startsWith、endsWith 之类的方法并包含方法。
StartsWith 检查给定的字符串是否从开头开始。
endsWith 检查给定的字符串是否在末尾。
包括检查给定字符串是否存在于任何部分。
您可以在下面的 youtube 视频中找到这三者之间的完全区别
于 2020-08-02T05:32:23.083 回答
-2
如果您正在使用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
于 2012-10-21T06:07:57.867 回答
-3
您还可以通过为数组原型创建自己的原型/扩展来返回以字符串开头的数组的所有成员，即
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
于 2013-07-19T21:50:02.373 回答