A karakterláncokkal (string típusú változók és konstansok) különböző műveleteket lehet végezni, amelyek segítenek ezek alakításában. Az esetek többségében kezelhetjük őket karakterek tömbjeként, ahogy a nevük is mutatja.
A karakterlánc hosszát a length tulajdonság adja meg:
let x = 'Kerebentelen';
console.log(x.length);
// Kimenet: 12Két karakterlánc összefűzését jeleni. Általános formája a + operátor segítségével valósul meg:
let x = 'alma', y = 'fa';
console.log(x + y);Ha egy karakterláncot olyen objektummal akarunk összefűzni, amely nem karakterlánc, az átalakul szintén karakterlánccá, mégpedig úgy, hogy háttérben meghívásra kerül a toString függvénye (erről majd később).
let obj = {
favicc: 'Deszkaaaaaaaaaaa'
};
let x = 'Ez egy objektum: ' + obj;
console.log(x);
// Kimenet: 'Ez egy objektum: [object Object]'Ez akkor is igaz, ha a függvényt mi magunk adjuk meg:
let obj = {
titkos: 'A hiriba az erdő sarkában van.',
toString: () => { return 'Nem mondom meg!'; }
}
let x = 'Hol a hiriba? ' + obj;
console.log(x);
// Kimenet: 'Hol a hiriba? Nem mondom meg!'Egy változót vagy konstans értéket szövegbe ágyazhatunk a következő notációval:
let x = 13;
let str = `A fenti szám a ${x}, remélhetőleg nem esik péntekre.`;
// Nem ' karakterek közé, hanem ` (backtick) közé kerül a szövegEgy adott karakterre a megszokott módon hivatkozunk, akárcsak a tömb egy eleménél: valtozo[index], szintén 0-tól számítva.
Egy konkrét alsorozatra (a szöveg egy részére) a substr(kezdő pozíció, darabszám) és a substring(kezdő pozíció, végső pozíció) függvényekkel utalunk:
let x = 'életveszély';
console.log(x.substr(4, 4)); // 'vesz'
console.log(x.substr(4)); // 'veszély'
// Egy paraméter esetén az összes maradék karaktert visszatéríti
console.log(x.substring(2, 5)); // 'etv'Ha meg akarjuk vizsgálni, hogy egy karakterlánc tartalmaz-e egy másikat, erre az includes(másik string) függvényét használjuk.
Ha meg akarjuk tudni, hogy hányadik pozíción kezdődik egy adott alsorozat, abban az indexOf(másik string) függvény segít.
Az első adott alsorozat helyettesítése a replace(keresett string, új string) függvénnyel történik:
let str = 'A kocsonya finom.';
str = str.replace('kocsonya', 'puding');
// 'A puding finom.'Az összes találó alsorozat helyettesítésére RegEx konstrukciót használunk:
let str = 'Az eperfán sok eper van.';
str = str.replace(/eper/g, 'alma');
// 'Az almafán sok alma van.'Ezekről bővebben itt olvashatsz, és itt tesztelheted őket.
Egy karakterláncot tömbökre oszthatunk:
let str = 'sas/holló/varjú/csóka/szarka';
let arr = str.split('/'); // Elválasztás a '/' karakter mentén
console.log(arr);
// Kimenet: ['sas', 'holló', 'varjú', 'csóka', 'szarka']A tömbökkel és minden leszármazottukkal (például karakterláncokkal is) végezhetünk általános műveleteket. Az indexOf() és hasonló függvények itt is működnek.
let arr = [3, 5, 7, 11];
arr.push(13); // A tömb végére kerül az új elem
arr.unshift(2); // A tömb elejére kerül az új elem
console.log(arr);
// Kimenet: [2, 3, 5, 7, 11, 13]Egyszerre több elem is hozzáadható az adott tömbhöz.
let arr = [2, 3, 5, 7, 11, 13];
arr.pop(); // Az utolsó elem (13) eltávolítása
arr.shift(); // Az első elem (2) eltávolítása
console.log(arr);
// Kimenet: [3, 5, 7, 11]Ezek a függvények visszatérítik azt az elemet, amelyet éppen eltávolítanak.
Egy tömb adott alsorozatát a slice(kezdő pozíció, végső pozíció) fügvénnyel kaphatjuk meg.
let arr = [1, 2, 3, 4];
arr = arr.slice(1, 3);
console.log(arr);
// Kimenet: [2, 3]Két tömböt egyesíthetünk a concat(második) függvénnyel. A függvény neve a konkatenációból jön.
let arr = [1, 2, 3];
arr = arr.concat([4, 5, 6]);
console.log(arr);
// Kimenet: [1, 2, 3, 4, 5, 6]Egy tömb elemeiből karakterláncot készíthetünk a join(elválasztás) függvénnyel.
let arr = [13, 'haha', true, 0.7];
let str = arr.join(' meg ');
console.log(str);
// Kimenet: '13 meg haha meg true meg 0.7'Az if utasítás elvégez egy adott kódrészt (blokkot), ha egy megadott feltétel igaz. Ha a feltétel hamis, elvégezhet egy másik kódrészt, de ez nem kötelező. Egy nagyon alapvető és gyakori utasítás, mindenféle programban használják. Általános formája:
if(feltétel){
végrehajtandó kód, ha a feltétel igaz
} else {
végrehajtandó kód, ha a feltétel hamis
}Több if utasítást is használhatunk, egymás után. Konkrét példa:
let hr = new Date().getHours(); // Jelenlegi óra
if(hr < 9){ // Ha 9 óra előtt vagyunk
console.log('Jó reggelt!');
} else if (hr > 20){ // Ha 20 óra után vagyunk
console.log('Jó estét!');
} else { // Különben
console.log('Jó napot!');
}Ha egy adott változó vagy konstans értékét szerenénk vizsgálni, ezt megtehetjük rengeteg if...else ággal, de sokkal rövidebb és célszerűbb, ha erre a switch utasítást használjuk, és esetekre bontjuk a lehetséges értékeket:
let allat;
// Itt mondjuk beolvashatjuk az értékét
switch(allat){ // Vizsgáljuk az allat változó értékét
case 'kutya': // Abban az esetben (case), ha az értéke 'kutya'
console.log('Az ember legjobb barátja');
break; // Kilépünk a switch részből
case 'denevér': // Ha az értéke 'denevér'
console.log('Raffy kedvenc állata');
break;
case 'pingvin': // Ha az értéke 'pingvin'
case 'veréb': // vagy 'veréb' (itt "átesünk" a következő esetbe, nincs break)
console.log('Ez egy madár. Mit csináljak vele?');
break;
default: // Ha nem teljesült egy előző feltétel sem
console.log('Nem ismerem ezt az állatot');
}A ciklus egy olyan kódrész vagy műveletsor, amely többször kerül elvégzsre. A for ciklus egy olyan konstrukció, amelynek általános esetben van egy ciklusváltozója (változó, aminek az értéke minden végrehajtáskor megváltozik), elvégzési feltétele, és változtatási kifejezése:
for(let ciklusváltozó = kezdeti érték; feltétel; változtatás){
ciklusmag
}Számoljunk el 1-től 5-ig for ciklus segítségével, és írjuk ki minden szám kétszeresét:
for(let i = 1; i <= 5; i++){
console.log(i * 2);
}A ciklusváltozónk itt az i, a feltételünk "i kisebb, vagy egyenlő 5-tel", és az i++ minden alkalommal növeli a változó értékét. Egy alkalmat, amikor a ciklusmag lefut, iterációnak nevezünk. Bontsuk fel a fenti ciklust táblázatként:
| i | i <= 5 | Kimenet | Magyarázat |
|---|---|---|---|
| 1 | igaz | 2 | Az i értéke 1 lesz, a feltétel igaz, tehát elkezdhetjük a ciklust |
| 2 | igaz | 4 | Az i++ miatt nőtt az i értéke |
| 3 | igaz | 6 | |
| 4 | igaz | 8 | |
| 5 | igaz | 10 | 5-re még igaz, hogy kisebb vagy egyenlő 5-tel |
| 6 | hamis | A feltétel hamis, tehát megáll a ciklus |
Írjuk ki egy tömb összes elemét új sorba:
let t = ['alma', 'körte', 'dió', 'szőlő'];
for(let i = 0; i < t.length; i++){
console.log(t[i]);
}Számoljuk ki egy tömb elemeinek szorzatát:
let s = 1,
t = [5, 8, -1, 7];
for(int i = 0; i < t.length; i++){
s *= t[i];
}
console.log(s);
// Kimenet: -280Ha egy objektum tulajdonságaival szeretnénk dolgozni, használhatjuk a hagyományos for ciklus helyett a for...in változtatot:
let valaki = {
hajszin: 'szőke',
magassag: 188,
tomeg: 73,
roplabda: true
};
for(tul in valaki){
console.log(tul);
}
// Kimenet: hajszin magassag tomeg roplabdaA tulajdonság neve a ciklusban nem módosítható, értéke viszont igen.
Ha egy tömb, vagy más iterálható objektum értékeivel akarunk dolgozni, arra for...of ciklust használunk:
let t = ['cement', 'patak', 'cukorrépa'];
for(let val of t){
console.log(val);
}
// Kimenet: cement patak cukorrépaHa hamarabb szeretnénk megállítani a ciklus lefolyását, mint azt a ciklus fejlécében levő feltétel engedi, használhatjuk a break parancsot. Ezt használhatjuk optimalizálásra. Keressünk meg egy elemet egy tömbben manuálisan:
let t = [17, 23, 6, 39, 0, 61, 43];
for(let i = 0; i < t.length(); i++){// i változó 0-tól a tömb hosszáig
if(t[i] == 0){ // Ha a jelenlegi elem a nullás
console.log(`A 0 a tömb ${i}. eleme`);
break; // Akkor kilépünk a ciklusból, a többi nem érdekel
}
}Ha a cikluson belül nem akarunk tovább vizsgálni egy elemet, használhatjuk a continue parancsot, ami befejezi az iterációt, de nem lép ki a ciklusból. Példának írjuk ki egy tömb 3-mal nem osztható elemeit:
let t = [1, 3, 12, 4, 37, 30, 41];
for(let val of t){
if(val % 3 == 0){ // Ha osztható hárommal
continue; // Nem végezzük tovább az utasításokat, vesszük a következőt
}
console.log(val);
}
// Kimenet: 1 4 37 41