Kurs JavaScript i TypeScript · Moduł 2: Funkcje, tablice i obiekty

Template literals i metody stringów

7 min czytania ·
W tej lekcji8

W laboratorium Parku Jurajskiego co godzinę powstają raporty: gatunek, waga, strefa, stan zdrowia. Sklejanie ich plusami szybko zamienia się w gąszcz cudzysłowów, a dane z czujników przychodzą z nadmiarowymi spacjami i w przypadkowej wielkości liter. Template literals i metody stringów to narzędzia, które porządkują tekst: od wstawiania zmiennych po przeszukiwanie i przekształcanie łańcuchów znaków.

Template literals - podstawy

Template literals to stringi otoczone grawisami, czyli odwróconymi apostrofami, a nie zwykłymi cudzysłowami. Wyrażenie JavaScript wstawiasz do nich składnią ${...}:

const species = 'T-Rex';
const weight = 8000;

// Stary sposób - konkatenacja
const old = 'Gatunek: ' + species + ', waga: ' + weight + ' kg';

// Template literal - znacznie czytelniej!
const report = `Gatunek: ${species}, waga: ${weight} kg`;
console.log(report); // "Gatunek: T-Rex, waga: 8000 kg"

Obie zmienne zawierają ten sam tekst, ale w szablonie od razu widać kształt zdania. To dlatego polecam template literals zawsze, gdy w tekście pojawia się choć jedna zmienna.

Wyrażenia wewnątrz ${}

Wewnątrz ${} można umieścić dowolne wyrażenie JavaScript, nie tylko zmienną. Działa tu operator warunkowy, arytmetyka, wywołanie metody, a nawet zagnieżdżony template literal:

const dino = { name: 'Rex', health: 85 };

console.log(`Status: ${dino.health > 50 ? 'stabilny' : 'krytyczny'}`);
// "Status: stabilny"

console.log(`Zdrowie: ${dino.health}%`);
// "Zdrowie: 85%"

console.log(`Podwójna dawka: ${dino.health * 2} jednostek`);
// "Podwójna dawka: 170 jednostek"

console.log(`Imię: ${dino.name.toUpperCase()}`);
// "Imię: REX"

JavaScript najpierw oblicza wyrażenie, potem zamienia wynik na tekst i wkleja go w miejsce ${}. Obiekt dino pozostaje przy tym nietknięty.

Wieloliniowe stringi

Template literals zachowują formatowanie wieloliniowe, więc nie trzeba wstawiać \n:

const dinoCard = `
╔════════════════════════╗
║  Gatunek: T-Rex        ║
║  Strefa: A             ║
║  Status: Aktywny       ║
╚════════════════════════╝
`;
console.log(dinoCard);

Każdy enter i każda spacja wewnątrz grawisów trafiają do wyniku, łącznie z pustą linią na początku.

Tagged templates

Tagged templates pozwalają przetworzyć szablon funkcją. Funkcja "tagująca" dostaje tablicę stałych fragmentów tekstu oraz wartości wyrażeń, a fragmentów jest zawsze o jeden więcej niż wartości:

function highlight(strings, ...values) {
  let result = '';
  strings.forEach((str, i) => {
    result += str;
    if (i < values.length) {
      result += '**' + values[i] + '**';
    }
  });
  return result;
}

const name = 'Rex';
const zone = 'A';
const tagged = highlight`Dinozaur ${name} w strefie ${zone}`;
console.log(tagged);
// "Dinozaur **Rex** w strefie **A**"

Zwróć uwagę, że tag wywołujemy bez nawiasów: nazwa funkcji stoi tuż przed grawisem. Praktyczne zastosowanie to budowanie zapytań do bazy, w którym wartości trafiają osobno od treści zapytania:

function sql(strings, ...values) {
  const query = strings.join('?');
  return { query, params: values };
}

const zoneId = 'A';
const minHealth = 80;
const query = sql`SELECT * FROM dinos WHERE zone = ${zoneId} AND health > ${minHealth}`;
// { query: "SELECT * FROM dinos WHERE zone = ? AND health > ?", params: ['A', 80] }

Wartości nie zostały wklejone do tekstu zapytania, tylko odłożone do params. Na tej zasadzie działają zapytania parametryzowane, które chronią bazę przed atakiem SQL injection.

Metody stringów - wyszukiwanie

Zacznijmy od wyszukiwania fragmentów w sekwencji DNA. Każda z tych metod tylko czyta tekst i zwraca odpowiedź:

const dnaSequence = 'ATCG-TTGA-ACGT-TTGA';

// indexOf() - zwraca indeks pierwszego wystąpienia (lub -1)
console.log(dnaSequence.indexOf('TTGA'));    // 5
console.log(dnaSequence.indexOf('XXXX'));    // -1
console.log(dnaSequence.lastIndexOf('TTGA')); // 15 - ostatnie wystąpienie

// includes() - sprawdza czy string zawiera fragment (boolean)
console.log(dnaSequence.includes('ACGT'));   // true
console.log(dnaSequence.includes('ZZZZ'));   // false

// startsWith() / endsWith() - sprawdza początek/koniec
console.log(dnaSequence.startsWith('ATCG')); // true
console.log(dnaSequence.endsWith('TTGA'));   // true
console.log(dnaSequence.startsWith('TTGA', 5)); // true - od pozycji 5

// match() z wyrażeniem regularnym - wszystkie dopasowania
console.log(dnaSequence.match(/TTGA/g)); // ['TTGA', 'TTGA']

Wszystkie te metody rozróżniają wielkość liter, więc includes('acgt') zwróci false. Gdy pytasz tylko "czy jest?", wybierz includes(), bo czyta się jak zdanie, a indexOf() zostaw na sytuacje, gdy potrzebujesz pozycji.

Metody stringów - wycinanie i dzielenie

Wycinanie przydaje się, gdy z pełnej nazwy okazu potrzebujesz tylko części:

const specimen = 'Tyrannosaurus Rex';

// slice(start, end) - wycina fragment stringa
console.log(specimen.slice(0, 13));    // "Tyrannosaurus"
console.log(specimen.slice(14));       // "Rex"
console.log(specimen.slice(-3));       // "Rex" (od końca)

// split() - dzieli string na tablicę
const zones = 'A-B-C-D'.split('-');
console.log(zones); // ['A', 'B', 'C', 'D']

const words = 'Park Jurajski jest super'.split(' ');
console.log(words); // ['Park', 'Jurajski', 'jest', 'super']

slice nie obejmuje znaku o indeksie end, a ujemny indeks liczy od końca, więc slice(-3) to trzy ostatnie znaki. split zwraca tablicę, którą w następnej lekcji rozpakujesz destrukturyzacją.

Metody stringów - transformacje

Surowe dane z czujników trzeba oczyścić. Kluczowa zasada: stringi są niezmienne, więc każda metoda zwraca nowy string:

const dinoName = '  velociraptor  ';

// trim() - usuwa białe znaki z początku i końca
console.log(dinoName.trim());      // "velociraptor"
console.log(dinoName.trimStart()); // "velociraptor  "
console.log(dinoName.trimEnd());   // "  velociraptor"

// toUpperCase() / toLowerCase()
console.log('rex'.toUpperCase());         // "REX"
console.log('T-REX'.toLowerCase());       // "t-rex"

// replace() - zamienia pierwsze wystąpienie
const text = 'Zone A, Zone B, Zone A';
console.log(text.replace('Zone', 'Strefa'));  // "Strefa A, Zone B, Zone A"

// replaceAll() - zamienia wszystkie wystąpienia
console.log(text.replaceAll('Zone', 'Strefa')); // "Strefa A, Strefa B, Strefa A"

Po tych wywołaniach dinoName wciąż ma spacje, a text wciąż zawiera "Zone". Wynik zapisz w nowej zmiennej, jeśli chcesz go zachować. Różnica między replace i replaceAll dotyczy więc liczby zamian, a nie modyfikacji oryginału.

Metody stringów - dopełnianie

Metody padStart() i padEnd() dopełniają string do zadanej długości, a repeat() powiela go. Razem pozwalają wyrównać tabelę okazów:

// padStart(length, fillString) - dopełnia od początku
const dinoId = '42';
console.log(dinoId.padStart(5, '0'));  // "00042"
console.log(dinoId.padStart(5, '-'));  // "---42"

// padEnd(length, fillString) - dopełnia od końca
const label = 'Rex';
console.log(label.padEnd(10, '.'));    // "Rex......."

// repeat(count) - powiela string
console.log('-'.repeat(30));           // "------------------------------"

// Praktyczny przykład - formatowanie tabeli
const specimens = [
  { id: '1', name: 'T-Rex' },
  { id: '42', name: 'Velociraptor' },
  { id: '100', name: 'Triceratops' }
];

specimens.forEach(s => {
  const formattedId = s.id.padStart(4, '0');
  const formattedName = s.name.padEnd(15, ' ');
  console.log(`ID: ${formattedId} | Gatunek: ${formattedName}`);
});
// ID: 0001 | Gatunek: T-Rex
// ID: 0042 | Gatunek: Velociraptor
// ID: 0100 | Gatunek: Triceratops

Pierwszy argument to docelowa długość całego stringa, a nie liczba dodawanych znaków. Dlatego '42'.padStart(5, '0') dokleja trzy zera.

Łączenie metod (chaining)

Metody stringów można łączyć w łańcuchy, bo każda zwraca nowy string, na którym wywołujesz kolejną:

const messy = '  park JURAJSKI  jest  SUPER  ';
const clean = messy.trim().toLowerCase().replace(/\s+/g, ' ');
console.log(clean); // "park jurajski jest super"

const dinoCode = 'trex-001';
const formatted = dinoCode.split('-')
  .map(part => part.toUpperCase())
  .join('-');
console.log(formatted); // "TREX-001"

/\s+/g to wyrażenie regularne oznaczające dowolny ciąg białych znaków, a flaga g każe zamienić wszystkie wystąpienia. Ten sam wzorzec tworzy przyjazne adresy raportów:

function formatReport(rawInput) {
  return rawInput
    .trim()
    .toLowerCase()
    .replace(/\s+/g, '-')       // spacje na myślniki
    .replace(/[^a-z0-9-]/g, '') // usuń znaki inne niż litery, cyfry i myślniki
    .slice(0, 50);             // maksymalnie 50 znaków
}

console.log(formatReport('  T-Rex Escape!! Zone A  '));
// "t-rex-escape-zone-a"

Każdy krok łańcucha robi jedną rzecz, więc łatwo go czytać i poprawiać. Polecam łamać długie łańcuchy tak jak tutaj, jedna metoda w linii.

Praktyka

W piaskownicy czekają szablony raportów, wyszukiwanie w DNA, slice, split, replace i dopełnianie. Zmieniaj argumenty i przewiduj wynik, zanim uruchomisz kod.

Kod do tej lekcji: index.js
// === TEMPLATE LITERALS I METODY STRINGÓW ===

// 1. Template literals - wstawianie wyrażeń
const species = 'T-Rex';
const weight = 8000;

console.log('=== Template Literals ===');
console.log(`Gatunek: ${species}, waga: ${weight} kg`);
console.log(`Zdrowie: ${weight > 5000 ? 'duży osobnik' : 'mały osobnik'}`);
console.log(`Podwójna dawka: ${weight * 0.05} kg`);

// 2. Wieloliniowe stringi
const card = `
=== KARTA DINOZAURA ===
Gatunek: ${species}
Waga: ${weight} kg
Status: aktywny
`;
console.log(card);

// 3. Metody wyszukiwania
console.log('=== Wyszukiwanie ===');
const dna = 'ATCG-TTGA-ACGT-TTGA';
console.log('indexOf TTGA:', dna.indexOf('TTGA'));
console.log('includes ACGT:', dna.includes('ACGT'));
console.log('startsWith ATCG:', dna.startsWith('ATCG'));
console.log('endsWith TTGA:', dna.endsWith('TTGA'));

// 4. Wycinanie i dzielenie
console.log('\n=== Slice i Split ===');
const specimen = 'Tyrannosaurus Rex';
console.log('slice(0,13):', specimen.slice(0, 13));
console.log('slice(-3):', specimen.slice(-3));
console.log('split:', 'A-B-C-D'.split('-'));

// 5. Transformacje
console.log('\n=== Transformacje ===');
console.log('trim:', '  rex  '.trim());
console.log('toUpperCase:', 'rex'.toUpperCase());
console.log('replace:', 'Zone A, Zone B'.replace('Zone', 'Strefa'));
console.log('replaceAll:', 'Zone A, Zone B'.replaceAll('Zone', 'Strefa'));

// 6. Dopełnianie (padding)
console.log('\n=== Padding ===');
console.log('padStart:', '42'.padStart(5, '0'));
console.log('padEnd:', 'Rex'.padEnd(10, '.'));

// 7. Chaining metod
console.log('\n=== Chaining ===');
const messy = '  park JURAJSKI  ';
const clean = messy.trim().toLowerCase();
console.log('Wynik:', clean);

Pamiętaj: template literal to etykieta z wolnymi polami na dane, a metody stringów to skalpele laboranta, które nigdy nie tną oryginalnej próbki, tylko tworzą jej kopię.

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Jakiego znaku używamy do otaczania template literals w JavaScript?

  2. 2. Jaka składnia pozwala wstawić wyrażenie JavaScript wewnątrz template literal?

  3. 3. Co zwróci 'Tyrannosaurus Rex'.slice(-3)?

  4. 4. Jaka jest różnica między replace() a replaceAll() w JavaScript?

  5. 5. Co zwróci 'A-B-C-D'.split('-')?

Zadania praktyczne w grze

  • Klikanie w kolejności

    Ułóż wywołanie, które sprawdza, czy dnaSequence zawiera fragment 'ACGT':

  • Układanie w poziomie

    Ułóż elementy wywołania padStart() do dopełnienia ID zerami:

  1. PytanieTemplate literals - składnia
  2. PytanieTemplate literals - wstawianie wyrażeń
  3. Kliknij w kolejnościMetoda includes() - składnia
  4. Ułóż w kolejnościMetoda padStart() - składnia
  5. PytanieMetoda slice() - ujemny indeks
  6. PytanieMetoda replace() vs replaceAll()
  7. PytanieMetoda split() - dzielenie stringa

Przydatne artykuły