JavaScript-merkkijono sisältää osajonon: String String String: Täydellinen opas

Sen tarkistaminen, sisältyykö yksi merkkijono toiseen (osamerkkijonohaku), on edelleen yksi yleisimmistä merkkijono-operaatioista JavaScript-kehityksessä. Olipa kyseessä sitten käyttäjän syöttämien tietojen tarkistaminen, hakusuodattimien toteuttaminen React- tai Vue-sovelluksissa, API-vastausten jäsentäminen, automaattisen täydennystoiminnon rakentaminen tai lokitiedostojen käsittely Node.js:ssä, tämä tarkistus esiintyy kaikkialla.

Helmikuussa 2026 ECMAScript 2026 (ES2026) on voimassa oleva tai pian voimaan tuleva standardi (valmistuu vuoden 2026 puolivälissä). Ydin String.prototype menetelmät osamerkkijonojen tunnistamiseksi — includes(), indexOf(), search(), ja säännöllinen lauseke .test() — ovat pysyneet muuttumattomina ES2015/ES6:sta lähtien. ES2025:een tai ES2026:een ei ole lisätty merkittäviä uusia merkkijonojen hakumenetelmiä; painopiste on edelleen suorituskyvyssä, luettavuudessa, Unicode-yhteensopivuudessa ja nykyaikaisissa parhaissa käytännöissä moottoreissa kuten V8 (Node 22+/Chrome 130+), SpiderMonkey (Firefox 135+) ja JavaScriptCore (Safari 19+).

Tässä oppaassa käsitellään kaikkia käytännön tekniikoita, vuoden 2026 suorituskykyolosuhteita, poikkeustapauksia, tietoturva-asioita sekä tuotantokäyttöön sopivia suosituksia.

Miksi osajonotarkistuksia käytetään kaikkialla

• UI/UX: Reaaliaikainen haku, tunnisteiden suodatus, lomakkeiden validointi
• Backend: Lokien jäsentäminen, reittien tunnistaminen, sisällön moderointi
• Tietojenkäsittely: Merkkijonojen ja objektien taulukoiden suodattaminen
• Turvallisuus: Haitallisten mallien tunnistaminen (XSS-hyökkäykset, kielletyt sanat)
• Suorituskykyriippuvainen: Automaattinen täydennys (miljoonia tarkistuksia sekunnissa), reaaliaikainen seuranta

Pienet tehottomuudet kertyvät nopeasti silmukoissa tai suurissa tietojoukoissa.

1. Nykyaikainen standardi: String.prototype.includes()

ES2015:n jälkeen suosituin menetelmä — selkeä, tarkoituksen ilmaiseva ja tehokkaasti optimoitu.

Allekirjoitus

js
str.includes(hakusana, sijainti?)

• hakusana: etsittävä merkkijono (muunnetaan merkkijonoksi; RegExp heittää poikkeuksen)
• asema (valinnainen): aloitusindeksi (oletusarvo 0; rajoitettu arvoon ≥0)

Palautukset: boolean

Esimerkkejä

js
const phrase = "JavaScript vuonna 2026 on tehokas ja nopea";
console.log(phrase.includes("2026"));          // true
console.log(phrase.includes("2025"));          // false
console.log(phrase.includes("script"));        // true (kirjainkokoa erottava)
console.log(phrase.includes(""));              // true  ← ”empty” vastaa aina
console.log(phrase.includes("fast", 30));      // true
console.log(phrase.includes("fast", 40));      // false

Miksi valita includes() vuonna 2026?

• Paras luettavuus: ilmaisee selkeästi “sisältääkö se?”
• Moottorille optimoitu (V8/SpiderMonkey käyttävät nopeita Boyer-Moore- tai kaksisuuntaisia algoritmeja)
• Yleinen tuki: 100% nykyaikaisissa selaimissa ja Node.js:ssä noin vuodesta 2017 lähtien

Haitat

• Vain boolean (ei indeksiä)
• Aina kirjainkokoa erottava

2. Klassinen ja sijaintiin perustuva: String.prototype.indexOf()

ES6:ta edeltävä työjuhta — edelleen erinomainen valinta, kun tarvitset sijaintitietoa.

Allekirjoitus

js
str.indexOf(searchString, fromIndex?)

Palautukset: ensimmäinen hakemisto ≥ fromIndex tai -1

Olemassaolon tarkistus

js
if (phrase.indexOf("2026") !== -1) { /* löytyi */ }
// Suositeltava tyyli:
if (phrase.indexOf("2026") >= 0) { /* löytyi */ }

Kaikkien esiintymien etsiminen

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

Vuoden 2026 todellisuus: includes() ja indexOf() niiden nopeus on lähes sama boolen arvojen tarkistuksissa — valitse includes() selvyyden vuoksi, ellei hakemistoa tarvita.

3. Suur- ja pienkirjaimia erottamattomat tarkistukset (yleisin käytännön tarve)

Includes()- ja indexOf()-funktioille ei ole olemassa sisäänrakennettua lippua, joka ei erottelisi isoja ja pieniä kirjaimia.

Paras käytäntö 2026: Kirjainkokoa yhdenmukaistaminen

js
function containsIgnoreCase(text, term) {
  if (text == null || term == null) return false;
  return text.toLowerCase().includes(term.toLowerCase());
  // Tai kieliasetukset huomioon ottava (suositellaan tuotantokäyttöön):
  // text.toLocaleLowerCase('en').includes(term.toLocaleLowerCase('en'));
}

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

Miksi toLowerCase() voittaa yleensä

• Nopeampi kuin säännölliset lausekkeet kirjaimellisissa hauissa
• Väliaikaiset merkkijonot ovat edullisia nykyaikaisessa GC:ssä
• Välttää säännöllisten lausekkeiden kääntämisestä ja pako-merkistöjen käytöstä aiheutuvan ylimääräisen työmäärän

Paikallinen varoitus — turkki ("I".toLowerCase() → "ı") tai muut kielet saattavat yllättää. Käytä toLocaleLowerCase() käyttämällä nimenomaista kieliasetusta, kun kansainvälistys on tärkeää.

Säännöllisen lausekkeen vaihtoehto (joustava, mutta hitaampi)

js
function containsIgnoreCaseRegex(text, term) {
  if (!term) return true;
  // Pakene erikoismerkit, jos termi on käyttäjän syöttämä
  const escaped = term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
  return new RegExp(escaped, 'i').test(text);
}

Tai yhden rivin komento (vain luotetut termit):

js
/2026/i.test(phrase);  // true

Milloin kannattaa valita säännöllinen lauseke

• Tarvitaan sanarajoja (\bterm\b)
• Vaihtelu (kissa|koira)
• Lookarounds tai muut kuvioinnit

Suorituskykyvinkki: Käännä säännöllinen lauseke kerran ulkopuoliset silmukat/kuumat reitit.

4. Muut menetelmät ja niiden käyttöajankohdat

• String.prototype.search(regexp)
  Palauttaa ensimmäisen vastaavuuden indeksin tai -1. Nykyään harvoin käytetty — includes() tai .test() ovat selkeämpiä.
• String.prototype.match() / matchAll()
  Otteluiden hakemiseksi, ei pelkän olemassaolon todentamiseksi.
• startsWith() / endsWith() (ES2015)
  Erityistarkistukset — etuliitteiden ja jälkiliitteiden osalta nopeammin.

js
phrase.startsWith("Java");   // true
lause.päättyySanaan("fast");     // true

5. Suorituskyky vuonna 2026: Moottorit

Arvioidut suhteelliset nopeudet (V8/Node 22+, pitkä merkkijono ~10k merkkiä, kirjaimellinen haku):

Tärkein johtopäätös: Käytä includes() literaalien osalta. Normalisoi kirjainkoko, jos kirjainkokoa ei erotella, ellei säännöllisten lausekkeiden ominaisuuksia tarvita. Säännöllisten lausekkeiden käyttö on 2–5 kertaa hitaampaa, mutta se on hyväksyttävää, ellei kyseessä ole tiukkoja silmukoita.

6. Poikkeustapaukset ja sudenkuopat (ratkaisevan tärkeitä vuonna 2026)

• includes("") → true (tyhjä osajono löytyy kaikkialta)
• null/määrittelemätön haystack/needle → TypeError
• Korvausmerkkiparit ja emojit → käsitellään oikein (UTF-16)

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

• Kielteinen asema → käsitellään arvona 0
• Erittäin pitkät merkkijonot → hakukoneet käyttävät tehokkaita algoritmeja (keskimäärin O(n))
• Käyttäjän syöttämä tieto → ei koskaan muodosta säännöllinen lauseke käyttäjän syöttämistä raakamerkkijonoista ilman pako-merkkejä

7. Tuotannon avustajat ja parhaat käytännöt

Null-turvallinen apuohjelma (TypeScript-yhteensopiva):

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

Suositukset vuodelle 2026

• Oletusarvo: includes() selvyyden vuoksi
• Käytä kirjainkokoa normalisoimalla sen sijaan, että käyttäisit säännöllisiä lausekkeita, kun haluat yksinkertaisesti sivuuttaa kirjainkokoa
• Välimuistin säännöllisten lausekkeiden mallit
• Mittaa todellisia työmääriä (vältä liikaa keskittymistä mikrotestituloksiin)
• Käytä kirjastoja (lodash _.sisältää, Fuse.js) vain silloin, kun tarvitset sumeaa tai edistynyttä hakua

Johtopäätös

Vuonna 2026 merkkijonon sisältämän osamerkkijonon tarkistaminen JavaScriptissä on edelleen harhaanjohtavan yksinkertainen toimenpide, joka perustuu erittäin optimoituihin sovellusliittymiin. String.prototype.includes() on edelleen ensisijainen valinta useimmissa tilanteissa — se tarjoaa selkeyttä, suorituskykyä ja ilmeikästä luettavuutta. Kun tarkistuksissa ei oteta huomioon kirjainkokoa, normalisointi käyttämällä toLowerCase() (tai tarvittaessa kieliasetuksen huomioivat vaihtoehdot) tarjoaa luotettavan ja tehokkaan lähestymistavan. Säännöllisiä lausekkeita tulisi käyttää vain tilanteissa, joissa tarvitaan mallitasolla joustavuutta, jota kirjaimellinen vastaavuus ei tarjoa.

Kehittäjien yleisesti käyttämät mallit:

• Kirjaimellinen boolean-tarkistus → str.includes(sub)
• Aseman/indeksin avulla → str.indexOf(sub) >= 0
• Älä ota kirjainkokoa huomioon → str.toLowerCase().includes(sub.toLowerCase())
• Monimutkaiset tarpeet → Tallennettu välimuistiin RegExp.test()

Sopivan menetelmän valitseminen ja poikkeustapausten – kuten tyhjien arvojen, nollasyötteiden, Unicode-käsittelyn ja käyttäjän luomien tietojen – huomioon ottaminen takaa, että koodi on sekä vikaa sietävää että skaalautuvaa.

Carmatec auttaa organisaatioita kehittämään suorituskykyisiä JavaScript-pohjaisia sovelluksia, joissa tällaisten perustavanlaatuisten yksityiskohtien huomioiminen vaikuttaa suoraan luotettavuuteen, nopeuteen ja ylläpidettävyyteen laajassa mittakaavassa.