JavaScript Sträng innehåller delsträng: Den kompletta guiden

Att kontrollera om en sträng innehåller en annan (substring search) är fortfarande en av de vanligaste strängoperationerna i JavaScript-utveckling. Oavsett om du validerar användarinmatning, implementerar sökfilter i React/Vue-appar, analyserar API-svar, bygger funktioner för autokomplettering eller bearbetar loggar i Node.js, förekommer den här kontrollen överallt.

Från och med februari 2026 är ECMAScript 2026 (ES2026) den nuvarande eller kommande standarden (färdigställd i mitten av 2026). Kärnan String.prototyp metoder för detektering av substring - includes(), indexOf(), search(), och regex .test() - förblir oförändrade från ES2015/ES6 och framåt. Inga större nya strängsökningsmetoder landade i ES2025 eller ES2026; fokus ligger kvar på prestanda, läsbarhet, Unicode-korrekthet och moderna bästa metoder i motorer som V8 (Node 22+/Chrome 130+), SpiderMonkey (Firefox 135+) och JavaScriptCore (Safari 19+).

Den här guiden täcker alla praktiska tekniker, prestandarealiteter 2026, edge cases, säkerhetsaspekter och produktionsfärdiga rekommendationer.

Varför kontroller av substrängar finns överallt

• UI/UX: Live-sökning, taggfiltrering, formulärvalidering
• Backend: Loggtolkning, ruttmatchning, innehållsmoderering
• Databehandling: Filtrering av matriser av strängar/objekt
• säkerhet: Detektering av skadliga mönster (XSS-nyttolast, förbjudna ord)
• Prestanda-känslig: Autokomplettering (miljontals kontroller/sek), övervakning i realtid

Små ineffektiviteter multipliceras snabbt i loopar eller stora datamängder.

1. Modern standard: String.prototype.includes()

Den bästa metoden sedan ES2015 - ren, avslöjande och kraftigt optimerad.

Underskrift

js
str.includes(searchString, position?)

• searchString: delsträng att hitta (tvingad till sträng; RegExp kastar)
• position (valfritt): startindex (standard 0; klämd ≥0)

Avkastning: boolean

Exempel

js
const phrase = "JavaScript år 2026 är kraftfullt och snabbt";
console.log(phrase.includes("2026"));          // sant
console.log(phrase.includes("2025"));          // falskt
console.log(phrase.includes("script"));        // sant (skiftlägeskänsligt)
console.log(phrase.includes(""));              // sant ← tomt matchar alltid
console.log(phrase.includes("fast", 30));      // sant
console.log(phrase.includes("fast", 40));      // falskt

Varför föredrar inkluderar() år 2026?

• Maximal läsbarhet: uttrycker tydligt “innehåller den?”
• Motoroptimerad (V8/SpiderMonkey använder snabba Boyer-Moore- eller tvåvägsalgoritmer)
• Universellt stöd: 100% i moderna webbläsare/Node sedan ~2017

Nackdelar

• Endast boolean (inget index)
• Alltid skiftlägeskänsligt

2. Klassisk och positionsmedveten: String.prototype.indexOf()

Arbetshäst före ES6 - fortfarande utmärkt när du behöver platsen.

Underskrift

js
str.indexOf(searchString, frånIndex?)

Avkastning: första index ≥ frånIndex eller -1

Existenskontroll

js
if (phrase.indexOf("2026") !== -1) { /* hittades */ }
// Föredragen stil:
if (phrase.indexOf("2026") >= 0) { /* hittades */ }

Hitta alla förekomster

js
låt positioner = [];
låt idx = -1;
while ((idx = phrase.indexOf("a", idx + 1)) !== -1) {
  positioner.push(idx);
}
console.log(positioner);  // [1, 4, 11, ...]

2026 verklighet: inkluderar() och indexOf() har nästan samma hastighet för booleska kontroller - välj inkluderar() för tydlighetens skull om du inte behöver indexet.

3. Case-Insensitive Checks (vanligaste behovet i verkligheten)

Det finns ingen inbyggd flagga som inte tar hänsyn till skiftlägesskillnader för includes()/indexOf().

Bästa praxis 2026: Normalisera fall

js
function containsIgnoreCase(text, term) {
  if (text == null || term == null) return false;
  return text.toLowerCase().includes(term.toLowerCase());
  // Eller lokalmedveten (rekommenderas för produktion):
  // text.toLocaleLowerCase('en').includes(term.toLocaleLowerCase('en'));
}

console.log(containsIgnoreCase(phrase, "POWERFUL"));  // sant

Varför tillKleinbokstav() vinner vanligtvis

• Snabbare än regex för bokstavliga sökningar
• Tillfälliga strängar är billiga i modern GC
• Undviker overhead för kompilering/escape av regex

Lokal försiktighet - Turkiska ("I".toLowerCase() → "ı") eller andra språk kan överraska. Använd tillLocaleLowerCase() med explicit locale när internationalisering är viktigt.

Regex-alternativ (flexibelt men långsammare)

js
function containsIgnoreCaseRegex(text, term) {
  if (!term) returnerar true;
  // Escape specialtecken om termen kommer från användaren
  const escaped = term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
  return new RegExp(escaped, 'i').test(text);
}

Eller one-liner (endast betrodda termer):

js
/2026/i.test(fras);  // sant

När ska man välja regex

• Behöver ordgränser (\btermterm\b)
• Alternation (katt|hund)
• Omvägar eller andra mönster

Tips om prestanda: Kompilera regex en gång utanför slingor / heta vägar.

4. Andra metoder och när de ska användas

• String.prototype.search(regexp)
  Returnerar första matchningsindex eller -1. Används sällan idag - inkluderar() eller .test() är tydligare.
• String.prototype.match() / matchAll()
  För att extrahera tändstickor, inte bara existera.
• startsWith() / slutarMed() (ES2015)
  Specialiserade kontroller - snabbare för prefix/suffix.

js
phrase.startsWith("Java");   // sant
phrase.endsWith("snabb");     // sant

5. Prestanda i 2026 års motorer

Ungefärliga relativa hastigheter (V8/Node 22+, stor sträng ~10k tecken, bokstavlig sökning):

Viktig information att ta med sig: Användning inkluderar() för bokstavstecken. Normalisera fall för ignore-fall om inte regex-funktioner krävs. Regex är 2-5× långsammare men acceptabelt om det inte är i snäva loopar.

6. Edge Cases & Gotchas (kritiska år 2026)

• includes("") → true (tom substring matchar överallt)
• noll/odefinierad höskulle/nål → TypeError
• Surrogatpar och emojis → hanteras korrekt (UTF-16)

  js
  "Hello 🌍 2026".includes("🌍"); // true

• Negativt läge → position behandlas som 0
• Mycket långa strängar → motorer använder effektiva algoritmer (genomsnitt O(n))
• Användarens inmatning →. aldrig bygga regex från råa användarsträngar utan escaping

7. Produktionsassistenter och bästa praxis

Null-säkert verktyg (TypeScript-vänligt):

ts
function contains(
  haystack: string | null | undefined,
  needle: string | null | undefined,
  options: { ignoreCase?: boolean; from?: number } = {}
): boolean {
  if (haystack == null || needle == null) return false;
  const { ignoreCase = false, from = 0 } = options;

  const h = ignoreCase ? haystack.toLowerCase() : haystack;
  const n = ignoreCase ? needle.toLowerCase() : needle;
  return h.includes(n, from);
}

// Usage
contains("JavaScript 2026", "script", { ignoreCase: true });  // true

2026 Rekommendationer

• Standard till inkluderar() för tydlighetens skull
• Normalisera fall istället för regex för enkel ignorering av fall
• Cache regex-mönster
• Mät verkliga arbetsbelastningar (undvik mikrobenchmark-obsession)
• Använd bibliotek (lodash _.inkluderar, Fuse.js) endast när du behöver luddig/avancerad sökning

Slutsats

Att kontrollera om en sträng innehåller en delsträng i JavaScript är 2026 fortfarande en bedrägligt enkel operation som drivs av mycket optimerade API:er. String.prototype.includes() fortsätter att vara det bästa valet för de flesta scenarier - det ger klarhet, prestanda och uttrycksfull läsbarhet. För kontroller som inte tar hänsyn till skiftlägesskillnader normaliseras med tillKleinbokstav() (eller lokalanpassade alternativ vid behov) ger en tillförlitlig och effektiv metod. Reguljära uttryck bör reserveras för situationer som kräver flexibilitet på mönsternivå utöver bokstavsmatchning.

Vanliga mönster som utvecklare förlitar sig på:

• Bokstavlig boolesk kontroll → str.includes(sub)
• Med position/index → str.indexOf(sub) >= 0
• Ignorera fallet → str.toLowerCase().includes(sub.toLowerCase())
• Komplexa behov → Cached RegExp.test()

Genom att välja lämplig metod och ta hänsyn till extrema fall - t.ex. tomma värden, null-ingångar, Unicode-hantering och användargenererade data - får du en kod som är både robust och skalbar.

Carmatec hjälper organisationer att bygga högpresterande JavaScript-drivna applikationer där uppmärksamhet på sådana grundläggande detaljer direkt bidrar till tillförlitlighet, hastighet och underhållsmässighet i stor skala.