Kurs JavaScript i TypeScript · Moduł 2: Funkcje, tablice i obiekty
Template literals i metody stringów
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: TriceratopsPierwszy 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. Jakiego znaku używamy do otaczania template literals w JavaScript?
2. Jaka składnia pozwala wstawić wyrażenie JavaScript wewnątrz template literal?
3. Co zwróci 'Tyrannosaurus Rex'.slice(-3)?
4. Jaka jest różnica między replace() a replaceAll() w JavaScript?
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: