Jak sprawdzić, czy ciąg „StartsWith” inny ciąg?

Jak napisać odpowiednik C # String.StartsWithw JavaScript?

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

haystack.startsWith(needle) == true

Uwaga: jest to stare pytanie i jak wskazano w komentarzach ECMAScript 2015 (ES6) wprowadził tę .startsWithmetodę. Jednak w momencie pisania tej aktualizacji (2015 r.) Obsługa przeglądarki jest daleka od ukończenia .

Możesz użyć String.prototype.startsWith()metody ECMAScript 6 , ale nie jest ona jeszcze obsługiwana we wszystkich przeglądarkach . Będziesz chciał użyć podkładki / wypełnienia, aby dodać ją w przeglądarkach, które jej nie obsługują. Tworzenie implementacji zgodnej ze wszystkimi szczegółami określonymi w specyfikacji jest trochę skomplikowane. Jeśli chcesz wiernego podkładki, użyj jednego z poniższych:

• Matthias Bynens męska String.prototype.startsWithpodkładka , lub
• ES6-podkładki , które podkładki tyle spec ES6, jak to możliwe, w tym String.prototype.startsWith.

Po dostosowaniu metody (lub jeśli obsługujesz tylko przeglądarki i silniki JavaScript, które już ją mają), możesz użyć jej w następujący sposób:

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

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

Inna alternatywa z .lastIndexOf:

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

To wygląda do tyłu haystacko wystąpieniu needlepocząwszy od wskaźnika 0z haystack. Innymi słowy, sprawdza tylko, czy haystackzaczyna się od needle.

Zasadniczo powinno to mieć przewagę wydajności w stosunku do niektórych innych podejść:

• Nie przeszukuje całości haystack.
• Nie tworzy nowego łańcucha tymczasowego, a następnie natychmiast go odrzuca.

data.substring(0, input.length) === input

Bez funkcji pomocniczej, wystarczy użyć .testmetody regex :

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

Aby to zrobić za pomocą ciągu dynamicznego zamiast zakodowanego na stałe (zakładając, że ciąg nie będzie zawierał żadnych znaków kontrolnych wyrażenia regularnego):

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

Powinieneś sprawdzić Czy w JavaScript jest funkcja RegExp.escape? jeśli istnieje możliwość pojawienia się w ciągu znaków kontrolnych wyrażenia regularnego.

Najlepsze rozwiązanie:

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

A oto koniec: jeśli tego też potrzebujesz:

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

Dla tych, którzy wolą prototypować go w 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;
});

Stosowanie:

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

Z metodą:

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

Chciałem tylko dodać swoją opinię na ten temat.

Myślę, że możemy po prostu użyć w ten sposób:

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

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

Oto niewielka poprawa rozwiązania 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

Sprawdzanie, czy funkcja już istnieje, na wypadek, gdyby przyszła przeglądarka zaimplementowała ją w kodzie natywnym lub jeśli została zaimplementowana przez inną bibliotekę. Na przykład biblioteka prototypów już implementuje tę funkcję.

Korzystanie !jest nieco szybsze i bardziej zwięzłe niż === 0nie tak czytelne.

Sprawdź także underscore.string.js . Zawiera wiele użytecznych metod testowania i manipulacji ciągami, w tym startsWithmetodę. Z dokumentów:

zaczynać z _.startsWith(string, starts)

Ta metoda sprawdza, czy stringzaczyna się od starts.

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

Ostatnio zadałem sobie to samo pytanie.
Istnieje wiele możliwych rozwiązań, tutaj są 3 prawidłowe:

• s.indexOf(starter) === 0
• s.substr(0,starter.length) === starter
• s.lastIndexOf(starter, 0) === 0(dodał po obejrzeniu znak Byers męska odpowiedź )

• za pomocą pętli:

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

Nie spotkałem ostatniego rozwiązania, które wykorzystuje pętlę.
Nieoczekiwanie to rozwiązanie przewyższa pierwsze 3 o znaczny margines.
Oto test jsperf, który przeprowadziłem, aby dojść do tego wniosku: http://jsperf.com/startswith2/2

Pokój

ps: ecmascript 6 (harmonia) wprowadza natywną startsWithmetodę ciągów.
Pomyśl tylko, ile czasu by by zaoszczędzono, gdyby pomyśleli o włączeniu tej bardzo potrzebnej metody do samej początkowej wersji.

Aktualizacja

Jak zauważył Steve (pierwszy komentarz do tej odpowiedzi), powyższa funkcja niestandardowa zgłosi błąd, jeśli podany prefiks jest krótszy niż cały ciąg. Naprawił to i dodał optymalizację pętli, którą można obejrzeć na stronie http://jsperf.com/startswith2/4 .

Zauważ, że istnieją 2 optymalizacje pętli, które zawiera Steve, pierwsza z nich wykazała lepszą wydajność, dlatego opublikuję ten kod poniżej:

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

Ponieważ jest to tak popularne, myślę, że warto zauważyć, że istnieje implementacja tej metody w ECMA 6 i przygotowując się do tego, należy użyć „oficjalnej” polifill, aby zapobiec przyszłym problemom i łzom.

Na szczęście eksperci Mozilli zapewniają nam jeden:

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

Należy pamiętać, że ma to tę zaletę, że zostaje wdzięcznie zignorowane po przejściu na ECMA 6.

Najlepszym rozwiązaniem jest zaprzestanie używania wywołań bibliotecznych i po prostu rozpoznanie, że pracujesz z dwiema tablicami. Ręcznie wdrożona implementacja jest zarówno krótka, jak i szybsza niż każde inne rozwiązanie, jakie tu widziałem.

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

Dla porównania wydajności (sukces i porażka) zobacz http://jsperf.com/startswith2/4 . (Upewnij się, że sprawdziłeś późniejsze wersje, które mogły być atutem mojej).

Właśnie dowiedziałem się o tej bibliotece ciągów:

http://stringjs.com/

Dołącz plik js, a następnie użyj Szmiennej w następujący sposób:

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

Można go również użyć w NodeJS, instalując go:

npm install string

Wymagając go jako Szmiennej:

var S = require('string');

Strona internetowa zawiera również linki do alternatywnych bibliotek ciągów, jeśli ta nie przypadnie Ci do gustu.

2019. Pytanie jest nieco stare, ale chciałem napisać tę odpowiedź, aby pokazać kilka testów porównawczych, które wykonałem na podstawie wszystkich podanych tutaj odpowiedzi i jsperf udostępnionego przez Jima Bucka.

Zasadniczo potrzebowałem szybkiego sposobu na sprawdzenie, czy długa igła znajduje się w długim stogu siana i czy są bardzo podobne, z wyjątkiem ostatnich postaci.

Oto kod, który napisałem, który dla każdej funkcji (splice, podłańcuch, startWith itp.) Testuje zarówno, gdy zwracają wartość false i true względem ciągu stogu siana ( nestedString) o wartości 1.000.0001 znaków oraz ciągu fałszywej lub prawdziwej igły 1.000.000 znaki ( testParentStringFalsei testParentStringTrueodpowiednio):

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

Ten test porównawczy przeprowadziłem w Chrome 75 , Firefox 67 , Safari 12 i Opera 62 .

Nie zawarłem Edge i IE, ponieważ nie mam ich na tym komputerze, ale jeśli ktoś z was chce uruchomić skrypt przeciwko Edge i przynajmniej IE 9 i udostępnić wyniki tutaj, byłbym bardzo ciekawy, aby zobaczyć wyniki.

Pamiętaj tylko, że musisz odtworzyć 3 długie łańcuchy i zapisać skrypt w pliku, który następnie otworzysz w przeglądarce, ponieważ kopiowanie / wklejanie w konsoli przeglądarki zablokuje go, ponieważ długość każdego łańcucha wynosi> = 1.000.000).

Oto wyniki:

Chrome 75 ( substringwygrywa):

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 ( indexOfwygrywa):

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 ( slicewygrywa dla fałszywych wyników, startsWithwygrywa dla prawdziwych wyników, również Safari jest najszybszym pod względem całkowitego czasu na wykonanie całego testu):

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 ( substringwygrywa. Wyniki są podobne do Chrome i nie jestem zaskoczony, ponieważ Opera oparta jest na Chromium i 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}

Okazuje się, że każda przeglądarka ma własne szczegóły implementacji (oprócz Opery, która jest oparta na Chromium i Blink Chrome).

Oczywiście można i należy wykonać dalsze testy z różnymi przypadkami użycia (np. Gdy igła jest naprawdę krótka w porównaniu do stogu siana, gdy stóg siana jest krótszy niż igła itp.), Ale w moim przypadku musiałem porównać bardzo długie struny i chciałem się tym tutaj podzielić.

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

W oparciu o odpowiedzi tutaj używam tej wersji, ponieważ wydaje się, że zapewnia najlepszą wydajność w oparciu o testy JSPerf (i jest funkcjonalnie kompletna, o ile mi wiadomo).

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

Zostało to oparte na opensWith2 stąd: http://jsperf.com/startswith2/6 . Dodałem małe ulepszenie w celu drobnego ulepszenia wydajności, i od tego czasu dodałem również sprawdzanie, czy łańcuch porównawczy jest zerowy lub niezdefiniowany, i przekonwertowałem go, aby dodać do prototypu ciągu przy użyciu techniki w odpowiedzi CMS.

Zauważ, że ta implementacja nie obsługuje parametru „pozycja”, który jest wymieniony na tej stronie Mozilla Developer Network , ale i tak nie wydaje się być częścią propozycji ECMAScript.

Nie jestem pewien co do javascript, ale w maszynopisie zrobiłem coś takiego

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

Myślę, że to też powinno działać na js. Mam nadzieję, że to pomoże!

Jeśli pracujesz startsWith()i endsWith()musisz uważać na wiodące spacje. Oto kompletny przykład:

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

Możesz także zwrócić wszystkich członków tablicy, które zaczynają się od ciągu, tworząc własny prototyp / rozszerzenie do prototypu tablicy, czyli

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

I aby go użyć:

var myArray = ['Hello', 'Helium', 'Hideout', 'Hamster'];
var myResult = myArray.mySearch('Hel');
// result -> Hello, Helium