Fatal编程技术网
  • javascript/
  • Javascript 如何检查字符串；用“开始”；再来一根绳子？

Javascript 如何检查字符串；用“开始”；再来一根绳子？

javascript string

Javascript 如何检查字符串；用“开始”；再来一根绳子？,javascript,string,startswith,Javascript,String,Startswith,我如何用JavaScript编写C#的等价物 var haystack = 'hello world'; var needle = 'he'; haystack.startsWith(needle) == true 注：这是一个老问题，正如ECMAScript 2015（ES6）介绍该方法的评论中所指出的。但是，在编写本更新时（2015年）。您可以使用ECMAScript 6的方法，但它是一种新方法。您需要使用填充/多边形填充在不支持它的浏览器上添加它。创建符合的实现有点复杂。如果需要可靠的

我如何用JavaScript编写C#的等价物

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

haystack.startsWith(needle) == true
注：这是一个老问题，正如ECMAScript 2015（ES6）介绍该方法的评论中所指出的。但是，在编写本更新时（2015年）。

您可以使用ECMAScript 6的方法，但它是一种新方法。您需要使用填充/多边形填充在不支持它的浏览器上添加它。创建符合的实现有点复杂。如果需要可靠的垫片，请使用以下任一方法：

  • ，或
  • 它尽可能多地填充ES6规范，包括
    String.prototype.startsWith
一旦填充了该方法（或者如果您只支持已有的浏览器和JavaScript引擎），就可以这样使用它：

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

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

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

console.log（“你好，世界！”.startsWith（“他”）；//真的
var haystack=“你好世界”；
var前缀='orl'；

console.log（haystack.startsWith（前缀））；//false
以下是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
稍快且更简洁，但可读性较差。

另一种选择是：

这将从
haystack
的索引
0
开始，通过
haystack
向后查看
needle
的出现情况。换句话说，它只检查
haystack
是否以
needle
开头

原则上，这应该比其他一些方法具有性能优势：

  • 它不会搜索整个
    干草堆
  • 它不会创建一个新的临时字符串，然后立即丢弃它
      • 没有辅助函数，仅使用regex的方法：

      要使用动态字符串而不是硬编码字符串执行此操作（假设该字符串不包含任何regexp控制字符）：

      您应该检查是否存在regexp控制字符出现在字符串中的可能性。

      也请检查。它附带了一系列有用的字符串测试和操作方法，包括
      startsWith
      方法。从文档中：

      startsWith
      \u.startsWith（字符串，开始）

      此方法检查
      字符串
      是否以
      开始
      开始

      _("image.gif").startsWith("image")
=> true
      如果使用的是
      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;
};
      我刚刚了解了这个字符串库：

      包括js文件，然后像下面这样使用
      S
      变量：

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

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

if (haystack.indexOf(needle) == 0) {
  // Code if string starts with this substring
}
      通过安装它，也可以在NodeJS中使用它：

      npm install string
      然后要求它作为
      S
      变量：

      var S = require('string');
      如果您不喜欢这个字符串库，该网页还提供了指向其他字符串库的链接。

      我最近问了自己同样的问题。
      有多种可能的解决方案，以下是3种有效的解决方案：

      • s.indexOf（起动机）==0
      • s.substr（0，starter.length）==starter
      • s.lastIndexOf（起动机，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;
}
        最好的性能解决方案是停止使用库调用，只需认识到您使用的是两个阵列。手动实现比我在这里看到的任何其他解决方案都要短，而且速度更快

        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;
}

        函数startsWith2（str，前缀）{
if（str.length=0）和&（str[i]==prefix[i]）；--i）
继续；
返回i<0；
}
        有关性能比较（成功与失败），请参阅。（请确保检查可能优于我的更高版本。）

        根据这里的答案，这是我现在使用的版本，因为它似乎提供了基于JSPerf测试的最佳性能（据我所知，它在功能上是完整的）

        if（typeof String.prototype.startsWith！=“function”）{
String.prototype.startsWith=函数（str）{
if（str==null）返回false；
var i=str.length；
如果（this.length=0）&（此[i]==str[i]）；--i）继续；
返回i<0；
}
}
        这是基于StartWith2的，从这里开始：。我添加了一个小的调整来提高性能，并且此后还添加了一个检查比较字符串是否为null或未定义，并使用CMS答案中的技术将其转换为添加到字符串原型中

        请注意，此实现不支持本页中提到的“位置”参数，但无论如何，这似乎不是ECMAScript提案的一部分。

        由于这种方法非常流行，我认为值得指出的是，ECMA 6中有一种实现这种方法的方法，在准备这种方法时，应该使用“官方”多边形填充，以防将来出现问题和撕裂

        幸运的是，Mozilla的专家为我们提供了一个：

        请注意，这有一个优点，就是在过渡到ECMA 6时会被优雅地忽略。

        我只是想补充一下我的观点

        我想我们可以这样使用：

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

        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
        用法：

        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");

        var str=“某物”；
（str）.开始使用（“部分”）；
        我想 
        "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 str = "something";
(<String>str).startsWith("some");

        // 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)
}


        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}

        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}

        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}"

        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}