JavaScript: String

A String (karakterlánc, füzér). A változó értékét aposztófok vagy időzőjelek között kell megadni.

A stringek szöveges formában ábrázolt adatok tárolására használhatók. Használható a stringen belül is idézőjel vagy aposztróf, az a lényeg, hogy ne ugyanazt használjuk, mint a string megadásakor!

Van még lehetőségünk a template literal használatára (sablon szöveg). Ebben az esetben nyugodtan használhatunk a szövegben idézőjelet, aposztrófot. Alkalmas többsoros szöveg tárolására is. Használhatunk benne iterpolációt is változók értékének megjelenítésére.

Használhatunk escape karaktert is, ez a \ -jel.

A „Template Literal” a hivatalos elnevezés, amelyet az ECMAScript 2015 (ES6) specifikáció bevezetett. A fejlesztők között azonban a „template string” kifejezés is széles körben elterjedt és elfogadott szinonima. Mindkét kifejezés arra a speciális string-típusra vonatkozik, amelyet a hagyományos aposztrófok (‘) vagy idézőjelek („) helyett visszafelé dőlő aposztrófok (`) közé írunk. (altgr+7)

template literal jellemzői:

Lehetővé teszi a stringek több sorba történő írását.
Interpoláció: Lehetővé teszi, hogy JavaScript változókat és kifejezéseket ágyazzunk a stringbe a ${expression} szintaktika segítségével.

String létrehozása:

let pelda1 = "Dacia Logan";  // Idézőjel
let pelda2 = 'Dacia Logan';  // Aposztróf

let pelda3= "Bon Jovi: It's my life";
let pelda4 = "Nevem: 'Johnny' mondtha Connor nevetve.";

//template string
let pelda5= `Bon Jovi oroginal name was "John Francis Bongiovi Jr". It's true.`;

const nev = "Péter";
const kor = 40;
const uzenet = `Szia, a nevem ${nev}, ${kor} éves vagyok.`;
console.log(uzenet); // Szia, a nevem Péter, 40 éves vagyok.

const nettoAr = 1000;
const afaKulcs = 0.27;
const bruttoAr = nettoAr * (1 + afaKulcs);
const uzenet = `A termék nettó ára: ${nettoAr} Ft.
Az ÁFA kulcs: ${afaKulcs * 100}%
A termék bruttó ára: ${bruttoAr} Ft.`;
console.log(uzenet);

//escape karakter
let pelda6= "Ez egy példa. Idézet \"valami\" idézet vége.";

// template string összetett példa
<div id="demo"></div>
<script>
let header = "Kedvenc Színek";
let colors = ["Piros", "Zöld", "Kék", "Sárga"];
let html = `<h2>${header}</h2><ul>`;
for (const color of colors) {
  html += `<li>${color}</li>`;
}
html += `</ul>`;
document.getElementById("demo").innerHTML = html;
</script>

let pelda1 = "Dacia Logan"; // Idézőjel

let pelda2 = 'Dacia Logan'; // Aposztróf

let pelda3= "Bon Jovi: It's my life";

let pelda4 = "Nevem: 'Johnny' mondtha Connor nevetve.";

//template string

let pelda5= `Bon Jovi oroginal name was "John Francis Bongiovi Jr". It's true.`;

const nev = "Péter";

const kor = 40;

const uzenet = `Szia, a nevem ${nev}, ${kor} éves vagyok.`;

console.log(uzenet); // Szia, a nevem Péter, 40 éves vagyok.

const nettoAr = 1000;

const afaKulcs = 0.27;

const bruttoAr = nettoAr * (1 + afaKulcs);

const uzenet = `A termék nettó ára: ${nettoAr} Ft.

Az ÁFA kulcs: ${afaKulcs * 100}%

A termék bruttó ára: ${bruttoAr} Ft.`;

console.log(uzenet);

//escape karakter

let pelda6= "Ez egy példa. Idézet \"valami\" idézet vége.";

// template string összetett példa

let header = "Kedvenc Színek";

let colors = ["Piros", "Zöld", "Kék", "Sárga"];

let html = `<h2>${header}</h2><ul>`;

for (const color of colors) {

html += `<li>${color}</li>`;

}

html += `</ul>`;

document.getElementById("demo").innerHTML = html;

</script>

Leggyakoribb string függvények, length tulajdonság

JavaScriptben a stringek immutábilisak (változtathatatlanok). Ez azt jelenti, hogy az összes string metódus (pl. toUpperCase(), slice(), concat()) NEM a meglévő stringet módosítja, hanem új stringet hoz létre a megváltoztatott értékkel!

let eredeti = "Hello";
let nagybetus = eredeti.toUpperCase();

1 2	let eredeti = "Hello"; let nagybetus = eredeti.toUpperCase();

length: String hosszának meghatározása. (nem függvény, tulajdonság!)

charAt(): a megadott indexen található karaktert adja vissza. Az index számozása 0-val kezdődik. Ha az index a karakterlánc hosszán kívül esik (például negatív szám vagy túl nagy érték), akkor a charAt üres karakterláncot ad vissza.

charCodeAt(): a megadott indexen található karakter unicode (utf16) kódját adja vissza. Ha az index a karakterlánc hosszán kívül esik (például negatív szám vagy túl nagy érték), akkor a charCodeAt NaN értéket ad vissza.

at(): a megadott indexűkaraktert adja vissza. Gyakorlatilag ugyanaz, mintha [] zárójelbe írnánk. Azonban az at függvény támogatja a negatív indexeket is, amelyek a karakterlánc vagy tömb végétől számítják az elemeket.

slice(): a string egy részét (szeletét) lehet „kivágni” vele, és új stringbe beletenni. A slice elfogad negatív indexet is. A slice függvény két paramétert fogad el: a kezdő indexet és az opcionális befejező indexet. A slice a kezdő indextől kezdve (beleértve) a befejező indexig (kizárva) kivágja a string megadott részét.

substring(): Majdnem ugyanaz, mint a slice, csak nem fogad el negatív indexet. A kezdő indexet beleértve, de a befejező indexet kizárva adja vissza a karakterlánc részét. A substring nem támogatja a negatív indexeket, és ha a kezdő index nagyobb, mint a befejező index, akkor felcseréli őket.

substr(): A kezdő poziciót, és a szelet hosszát kell neki megadni. Elavult, használjuk helyette a slice()-t!

const szoveg = "Helló, világ!";
const hossz = szoveg.length;
console.log(`A szöveg hossza: ${hossz}`); // A szöveg hossza: 13

const szoveg = "Hello, világ!";
const elsoKarakter = szoveg.charAt(0);
const negyedikKarakter = szoveg.charAt(3);
const utolsoKarakter = szoveg.charAt(szoveg.length - 1);
console.log(`Az első karakter: ${elsoKarakter}`); // Az első karakter: H
console.log(`A negyedik karakter: ${negyedikKarakter}`); // A negyedik karakter: l
console.log(`Az utolsó karakter: ${utolsoKarakter}`); // Az utolsó karakter: !

// charCodeAt
const szoveg = "Hello, világ!";
const unicode = szoveg.charCodeAt(0);
console.log(unicode); // 72

// at
const szoveg = "Hello, világ!";
const elsoKarakter = szoveg.at(0);
console.log(elsoKarakter); // H
const utolsoKarakter = szoveg.at(-1);
console.log(utolsoKarakter); // !

// string x. indexű karaktere hagyományos módszerrel:
const szoveg = "JavaScript";
const elsoKarakter = szoveg[0];
const utolsoKarakter = szoveg[szoveg.length - 1];
console.log(elsoKarakter); // J
console.log(utolsoKarakter); // t

// slice
const szoveg = "Hello, világ!";
const reszlet = szoveg.slice(7, 12);
console.log(reszlet); // világ
const reszlet2 = szoveg.slice(-6, -1); //negatív index
console.log(reszlet2); // világ

//substring elavult! Használd helyette a slice-t!
const szoveg = "Hello, világ!";
const reszlet = szoveg.substring(7, 12);
const reszlet2 = szoveg.substring(7);
console.log(reszlet); // világ
console.log(reszlet2); // világ!

//substr
const szoveg = "Hello, világ!";
const reszlet = szoveg.substr(7, 5);
const reszlet2 = szoveg.substr(7);
const reszlet3 = szoveg.substr(7, -2);
console.log(reszlet); // világ
console.log(reszlet2); // világ!
console.log(reszlet3); // vil

const szoveg = "Helló, világ!";

const hossz = szoveg.length;

console.log(`A szöveg hossza: ${hossz}`); // A szöveg hossza: 13

const szoveg = "Hello, világ!";

const elsoKarakter = szoveg.charAt(0);

const negyedikKarakter = szoveg.charAt(3);

const utolsoKarakter = szoveg.charAt(szoveg.length - 1);

console.log(`Az első karakter: ${elsoKarakter}`); // Az első karakter: H

console.log(`A negyedik karakter: ${negyedikKarakter}`); // A negyedik karakter: l

console.log(`Az utolsó karakter: ${utolsoKarakter}`); // Az utolsó karakter: !

// charCodeAt

const szoveg = "Hello, világ!";

const unicode = szoveg.charCodeAt(0);

console.log(unicode); // 72

// at

const szoveg = "Hello, világ!";

const elsoKarakter = szoveg.at(0);

console.log(elsoKarakter); // H

const utolsoKarakter = szoveg.at(-1);

console.log(utolsoKarakter); // !

// string x. indexű karaktere hagyományos módszerrel:

const szoveg = "JavaScript";

const elsoKarakter = szoveg[0];

const utolsoKarakter = szoveg[szoveg.length - 1];

console.log(elsoKarakter); // J

console.log(utolsoKarakter); // t

// slice

const szoveg = "Hello, világ!";

const reszlet = szoveg.slice(7, 12);

console.log(reszlet); // világ

const reszlet2 = szoveg.slice(-6, -1); //negatív index

console.log(reszlet2); // világ

//substring elavult! Használd helyette a slice-t!

const szoveg = "Hello, világ!";

const reszlet = szoveg.substring(7, 12);

const reszlet2 = szoveg.substring(7);

console.log(reszlet); // világ

console.log(reszlet2); // világ!

//substr

const szoveg = "Hello, világ!";

const reszlet = szoveg.substr(7, 5);

const reszlet2 = szoveg.substr(7);

const reszlet3 = szoveg.substr(7, -2);

console.log(reszlet); // világ

console.log(reszlet2); // világ!

console.log(reszlet3); // vil

toUpperCase(): szöveg átalakítása nagybetűssé

toLowerCase(): szöveg átalakítása kisbetűssé

concat(): stringek sszefűzése. A concat() függvényt használhatjuk több karakterlánc (string) vagy tömb egyesítésére, új karakterlánc létrehozásához. Ez a függvény nem módosítja a meglévő karakterláncokat, hanem új karakterláncot hoz létre, amely tartalmazza az összes összeillesztett elemet.

trim(), trimStart(), trimEnd(): függvények a felesleges szóközöket (vagy más white space karaktereket) távolítják el a karakterlánc elejéről, végéről, vagy mindkét végéről.

padStart(), padEnd(): függvények a karakterláncokat a megadott hosszúságúra egészítik ki úgy, hogy hozzáadnak szóközöket vagy más kitöltő karaktereket a karakterlánc elejéhez vagy végéhez.

repeat(): egy karakterláncot többször egymás után megismétli, új karakterlánccá alakítva.

replace(): Lecseréli a stringben az első előfordulását a keresett mintának (stringnek vagy regex-nek).

ReplaceAll(): a megadott stringet kicseréli mindenhol egy másik stringben.

normalize(): Normalizálja a string Unicode formáját. Akkor hasznos, ha különböző módon kódolt ékezetes vagy speciális karaktereket akarunk egységesen kezelni (pl. keresés előtt).

localeCompare(): Összehasonlít két stringet, figyelembe véve a nyelvi beállításokat (pl. magyarban az abc szerinti sorrend, ahol az a és á külön van). Egy számot ad vissza: -1 (ha az első van előbb), 1 (ha a második van előbb), vagy 0 (ha azonosak).

split(): függvény segítségével egy stringet szét lehet bontani a megadott karakternél, és a kapott részeket egy tömbbe kerülnek.

// toUpperCase(), toLowerCase()
const szoveg = "Helló, Világ!";
const nagybetus = szoveg.toUpperCase();
const kisbetus = szoveg.toLowerCase();
console.log(nagybetus); // HELLÓ, VILÁG!
console.log(kisbetus); // helló, világ!

// concat
const elso = "Hello";
const masodik = "World";
const harmadik = "!";
const egyesitett = elso.concat(" ", masodik, harmadik);
console.log(egyesitett); // Hello World!

// trim
const szoveg = "   Hello, világ!   ";
const trimmed = szoveg.trim();
console.log(trimmed); // "Hello, világ!"
const trimmedStart = szoveg.trimStart();
console.log(trimmedStart); // "Hello, világ!   "
const trimmedEnd = szoveg.trimEnd();
console.log(trimmedEnd); // "   Hello, világ!"

// pad
const szam = "42";
const kiegeszitettSzam = szam.padStart(5, "0");
console.log(kiegeszitettSzam); // "00042"
const szoveg = "Hello";
const kiegeszitettSzoveg = szoveg.padEnd(8, "!");
console.log(kiegeszitettSzoveg); // "Hello!!!"

// repeat
const szoveg = "Hello ";
const ismeteltSzoveg = szoveg.repeat(3);
console.log(ismeteltSzoveg); // "Hello Hello Hello "

// replaceAll()
const szoveg = "alma, körte, alma, barack";
const ujSzoveg = szoveg.replaceAll("alma", "szilva");
console.log(ujSzoveg); // "szilva, körte, szilva, barack"

// split()
const szoveg = "Hello, világ! Üdvözlet mindenkinek!";
const reszek = szoveg.split(" ");
console.log(reszek); // ["Hello,", "világ!", "Üdvözlet", "mindenkinek!"]

// replace()
const gyumolcsok = "alma, körte, alma, barack";
// Csak az ELSŐ találatot cseréli!
const ujGyumolcsok = gyumolcsok.replace("alma", "szilva");
console.log(ujGyumolcsok); // "szilva, körte, alma, barack"

// localeCompare() - magyar nyelvű rendezés
const szo1 = "csiga";
const szo2 = "cica";
// 'cs' a magyar ABC-ben a 'c' után van
const rendezes = szo1.localeCompare(szo2, 'hu');
console.log(rendezes); // Eredmény: 1 (mert a "csiga" a "cica" után van)

// toUpperCase(), toLowerCase()

const szoveg = "Helló, Világ!";

const nagybetus = szoveg.toUpperCase();

const kisbetus = szoveg.toLowerCase();

console.log(nagybetus); // HELLÓ, VILÁG!

console.log(kisbetus); // helló, világ!

// concat

const elso = "Hello";

const masodik = "World";

const harmadik = "!";

const egyesitett = elso.concat(" ", masodik, harmadik);

console.log(egyesitett); // Hello World!

// trim

const szoveg = " Hello, világ! ";

const trimmed = szoveg.trim();

console.log(trimmed); // "Hello, világ!"

const trimmedStart = szoveg.trimStart();

console.log(trimmedStart); // "Hello, világ! "

const trimmedEnd = szoveg.trimEnd();

console.log(trimmedEnd); // " Hello, világ!"

// pad

const szam = "42";

const kiegeszitettSzam = szam.padStart(5, "0");

console.log(kiegeszitettSzam); // "00042"

const szoveg = "Hello";

const kiegeszitettSzoveg = szoveg.padEnd(8, "!");

console.log(kiegeszitettSzoveg); // "Hello!!!"

// repeat

const szoveg = "Hello ";

const ismeteltSzoveg = szoveg.repeat(3);

console.log(ismeteltSzoveg); // "Hello Hello Hello "

// replaceAll()

const szoveg = "alma, körte, alma, barack";

const ujSzoveg = szoveg.replaceAll("alma", "szilva");

console.log(ujSzoveg); // "szilva, körte, szilva, barack"

// split()

const szoveg = "Hello, világ! Üdvözlet mindenkinek!";

const reszek = szoveg.split(" ");

console.log(reszek); // ["Hello,", "világ!", "Üdvözlet", "mindenkinek!"]

// replace()

const gyumolcsok = "alma, körte, alma, barack";

// Csak az ELSŐ találatot cseréli!

const ujGyumolcsok = gyumolcsok.replace("alma", "szilva");

console.log(ujGyumolcsok); // "szilva, körte, alma, barack"

// localeCompare() - magyar nyelvű rendezés

const szo1 = "csiga";

const szo2 = "cica";

// 'cs' a magyar ABC-ben a 'c' után van

const rendezes = szo1.localeCompare(szo2, 'hu');

console.log(rendezes); // Eredmény: 1 (mert a "csiga" a "cica" után van)

Keresés

indexOf(): Meghatározza egy keresett string első előfordulásának indexét egy másik stringben. Ha nem található meg a kerett érték, akkor -1 értéket ad vissza.
lastIndexOf(): Meghatározza egy keresett string utolsó előfordulásának indexét egy másik stringben. Ha nem található meg a kerett érték, akkor -1 értéket ad vissza.

search(): egy karakterláncot keres adott reguláris kifejezés alapján, és visszaadja az első találat indexét. Ha a találat nem sikerül, -1 értéket ad vissza.

match(): egy reguláris kifejezésre alkalmazva az összes találatot visszaadja. Ha a globális flaget (g) megadjuk, a függvény az összes találatot egy tömbben adja vissza.
matchAll(): egy iterátor objektumot ad vissza, amely tartalmazza az összes találatot egy adott reguláris kifejezésre a karakterláncban.

includes(): ellenőrzi, hogy egy adott érték megtalálható-e egy tömbben vagy karakterláncban. Ez a függvény true-t ad vissza, ha az érték megtalálható, és false-t, ha nem.

startsWith(), endsWith(): segítségükkel ellenőrizhető, hogy egy karakterlánc egy másik karakterlánccal kezdődik-e vagy végződik-e. Mindkét függvény logikai értéket ad vissza: true-t, ha az ellenőrzött karakterlánc megfelel a keresett mintának, és false-t, ha nem.

// indexOf, lastIndexOf
const szoveg = "Hello, világ!";
const index = szoveg.indexOf("o");
console.log(index); // 4
const index = szoveg.lastIndexOf("l");
console.log(index); // 10

// search
const szoveg = "Az almafa meggyümölcsöl.";
const index = szoveg.search(/alma/);
console.log(index); // 3

// match
const szoveg = "Az almafa és a körtefa szép virágokat hoz.";
const talalatok = szoveg.match(/fa/g);
console.log(talalatok); // ["fa", "fa"]

const szoveg = "Az almafa és a körtefa szép virágokat hoz.";
const talalatok = szoveg.matchAll(/(alm|kört)efa/g);
for (const talalat of talalatok) {
  console.log(talalat[0]); // Az aktuális találat teljes illeszkedő része
  console.log(talalat[1]); // Az aktuális találat azon része, ami a zárójelben van
}

// includes
const szoveg = "Hello, World!";
const includesHello = szoveg.includes("Hello");
console.log(includesHello); // true
const includesGoodbye = szoveg.includes("Goodbye");
console.log(includesGoodbye); // false

// startsWith, endsWith
const szoveg = "Hello, World!";
const startsWithHello = szoveg.startsWith("Hello");
const startsWithHola = szoveg.startsWith("Hola");
console.log(startsWithHola); // false
console.log(startsWithHello); // true

const endsWithWorld = szoveg.endsWith("World!");
console.log(endsWithWorld); // true
const endsWithMundo = szoveg.endsWith("Mundo!");
console.log(endsWithMundo); // false

// indexOf, lastIndexOf

const szoveg = "Hello, világ!";

const index = szoveg.indexOf("o");

console.log(index); // 4

const index = szoveg.lastIndexOf("l");

console.log(index); // 10

// search

const szoveg = "Az almafa meggyümölcsöl.";

const index = szoveg.search(/alma/);

console.log(index); // 3

// match

const szoveg = "Az almafa és a körtefa szép virágokat hoz.";

const talalatok = szoveg.match(/fa/g);

console.log(talalatok); // ["fa", "fa"]

const szoveg = "Az almafa és a körtefa szép virágokat hoz.";

const talalatok = szoveg.matchAll(/(alm|kört)efa/g);

for (const talalat of talalatok) {

console.log(talalat[0]); // Az aktuális találat teljes illeszkedő része

console.log(talalat[1]); // Az aktuális találat azon része, ami a zárójelben van

}

// includes

const szoveg = "Hello, World!";

const includesHello = szoveg.includes("Hello");

console.log(includesHello); // true

const includesGoodbye = szoveg.includes("Goodbye");

console.log(includesGoodbye); // false

// startsWith, endsWith

const szoveg = "Hello, World!";

const startsWithHello = szoveg.startsWith("Hello");

const startsWithHola = szoveg.startsWith("Hola");

console.log(startsWithHola); // false

console.log(startsWithHello); // true

const endsWithWorld = szoveg.endsWith("World!");

console.log(endsWithWorld); // true

const endsWithMundo = szoveg.endsWith("Mundo!");

console.log(endsWithMundo); // false

Egyéb példák:

A beírt név visszafelé:

var s = new String;
s = prompt('Írd be a neved');
for (i =s.length-1; i>=0 ; --i) { // string első karaktere a nulladik elem!
document.write(s.charAt(i)); }

var s = new String;

s = prompt('Írd be a neved');

for (i =s.length-1; i>=0 ; --i) { // string első karaktere a nulladik elem!

document.write(s.charAt(i)); }

Az ASCII kódtábla karaktereinek megjelenítése. A felhasznált „fromCharCode” függvény a paraméterként kapott számhoz (0..255) tartozó ASCII karaktert adja vissza.

for (i = 32; i <= 255; ++ i) {
document.write(i, '-->',String.fromCharCode(i),'<br>'); }

További példák:

var s = new String('Árvíztűrő tükörfúrógép');

// string kiírása nagybetűs alakban. Nem változtatja meg a változó tartalmát! Tehát az s változó továbbra is kisbetűs szöveget tartalmaz!
document.write(s.toUpperCase(),'<br>');

// string kiírása kisbetűs alakban. Nem változtatja meg a változó tartalmát!
document.write(s.toLowerCase(),'<br>');

// string részlet kivágása – első paraméter: kezdő pozíció; második: hossz
document.write(s.substr(10,5),'<br>');
document.write(s.substr(15,4),'<br>');

// keresés a stringben (első előfordulás) . ha nincs, akkor -1 –et ad vissza! Érzékeny a kis és nagybetűkre!
document.write(s.indexOf('tükör'),'<br>');

// keresés a stringben (utolsó előfordulás) – visszafelé keres
document.write(s.lastIndexOf('r'),'<br>');

// szóköz utáni karakterek kiíratása
var i = s.lastIndexOf(' ')+1;
document.write(s.substr(i),'!') ;

// írjuk ki a szóköz előtti szót nagybetűs alakban
document.write(s.substr(0,i).toUpperCase(),'<br>');

Példa: Felhasználó üdvözlése keresztnévvel, hibakezeléssel

<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<script language="JavaScript">
 
uresMezoHiba = new Error("A beviteli mező üres!");
nincsSpaceHiba = new Error("A beírt név nem tartalmaz szóközt!");
function Udvozles() {
    try {
        if (document.forms[0].bekertnev.value == "") {
            throw uresMezoHiba;
        }
		if (!document.forms[0].bekertnev.value.includes(" ")) {
            throw nincsSpaceHiba;
        }
        else{
	teljesnev = document.forms[0].bekertnev.value;
	//keresztnev = teljesnev.split(" ");
        //alert("Üdvözlöm " +keresztnev[1] +"!")
			
	var i = teljesnev.lastIndexOf(' ')+1;
	keresztnev=teljesnev.substr(i);
	alert("Üdvözlöm " +keresztnev +"!")
		}
    } catch (e) { 
        alert(e.message);
    }
}
</script>
</head>
<body>
<form onSubmit="Udvozles()">
Felhasználó teljes neve: <input type="text" name="bekertnev">
<input type="submit" name="submit" value="Küldés">
</form>
</body>
</html>

<html>

<head>

uresMezoHiba = new Error("A beviteli mező üres!");

nincsSpaceHiba = new Error("A beírt név nem tartalmaz szóközt!");

function Udvozles() {

try {

if (document.forms[0].bekertnev.value == "") {

throw uresMezoHiba;

}

if (!document.forms[0].bekertnev.value.includes(" ")) {

throw nincsSpaceHiba;

}

else{

teljesnev = document.forms[0].bekertnev.value;

//keresztnev = teljesnev.split(" ");

//alert("Üdvözlöm " +keresztnev[1] +"!")

var i = teljesnev.lastIndexOf(' ')+1;

keresztnev=teljesnev.substr(i);

alert("Üdvözlöm " +keresztnev +"!")

}

} catch (e) {

alert(e.message);

}

</script>

</head>

<body>

Felhasználó teljes neve: <input type="text" name="bekertnev">

</form>

</body>

</html>

Hányszor szerepel egy adott karakterlánc egy másikban?

var szoveg = 'Ez a szöveg amiben keresünk valamit! Ez a szöveg az!',
    keresettszo = 'ami',
    db = 0,
    pos = szoveg.indexOf(keresettszo);
while (pos > -1) {
    ++db;
    pos = szoveg.indexOf(keresettszo, ++pos);
}
document.write("A megadott szöveg:","<br>");
document.write("<i>",szoveg,"</i><br>");
if (db>0)
{
document.write("A keresett szó: (",keresettszo,") ennyiszer szerepel:",db);
//console.log(db);   // 2
}
else
{
document.write("A keresett szó nem szerepel a szövegben!");
}

var szoveg = 'Ez a szöveg amiben keresünk valamit! Ez a szöveg az!',

keresettszo = 'ami',

db = 0,

pos = szoveg.indexOf(keresettszo);

while (pos > -1) {

++db;

pos = szoveg.indexOf(keresettszo, ++pos);

}

document.write("A megadott szöveg:","<br>");

document.write("<i>",szoveg,"</i><br>");

if (db>0)

{

document.write("A keresett szó: (",keresettszo,") ennyiszer szerepel:",db);

//console.log(db); // 2

}

else

{

document.write("A keresett szó nem szerepel a szövegben!");

}

Feladat: alakíts át egy hexadecimális színkódot decimálisba! Ehhez felbontjuk tagokra – 2 karakterenként. Első kettő a piros, következő kettő a zöld, utolsó kettő a kék színért felel.

let szin = "FFFFFF";
        let R = parseInt(szin.substring(0, 2), 16);
        let G = parseInt(szin.substring(2, 4), 16);
        let B = parseInt(szin.substring(4, 6), 16);

        let R16 = R.toString(16);
        let G16 = G.toString(16);
        let B16 = B.toString(16);

        // Decimális! - tagonként
        document.write("R: ", R, "<br>");
        document.write("G: ", G, "<br>");
        document.write("B: ", B, "<br>");

        // Hexadecimális - tagonként, stringek!
        document.write("R: ", R16, "<br>");
        document.write("G: ", G16, "<br>");
        document.write("B: ", B16, "<br>");

        // simán össze lehet rakni újra!
        szin = R16 + G16 + B16;
        document.write("szin: ", szin, "<br>");

let szin = "FFFFFF";

let R = parseInt(szin.substring(0, 2), 16);

let G = parseInt(szin.substring(2, 4), 16);

let B = parseInt(szin.substring(4, 6), 16);

let R16 = R.toString(16);

let G16 = G.toString(16);

let B16 = B.toString(16);

// Decimális! - tagonként

document.write("R: ", R, "<br>");

document.write("G: ", G, "<br>");

document.write("B: ", B, "<br>");

// Hexadecimális - tagonként, stringek!

document.write("R: ", R16, "<br>");

document.write("G: ", G16, "<br>");

document.write("B: ", B16, "<br>");

// simán össze lehet rakni újra!

szin = R16 + G16 + B16;

document.write("szin: ", szin, "<br>");

Leggyakoribb string függvények, length tulajdonság

Keresés

Kategóriák

Friss bejegyzések

Playwright teszt

Python Lista, szótár és halmaz értelmezés (list comprehension, dict/set comprehension)