2024. szeptember 24., kedd

Express használata

// Az Express.js keretrendszer betöltése

const express = require('express');

// A body-parser csomag betöltése, amely segít a bejövő adatok feldolgozásában

const bodyParser = require('body-parser');

// Egy Express alkalmazás példányának létrehozása

const app = express();

// A port, amelyen a szerver futni fog

const PORT = 3000;

 

// Middleware beállítása a POST kérések feldolgozásához JSON formátumban

app.use(bodyParser.urlencoded({ extended: true }));

app.use(bodyParser.json());

 

// Egyszerű adatbázis (tömb) a felhasználók tárolására

let users = [];

 

// GET kérés: A főoldal és a felhasználói űrlap megjelenítése

app.get('/', (req, res) => {

    res.send(`

        <h1>Felhasználó regisztráció</h1>

        <form id="registrationForm" action="/user" method="POST">

            <label for="email">Email:</label>

            <input type="email" id="email" name="email" required><br><br>

            <label for="name">Név:</label>

            <input type="text" id="name" name="name" required><br><br>

            <button type="submit">Küldés</button>

        </form>

        <br>

        <a href="/users">Felhasználók listája</a>

        <script>

            // Az űrlap elküldésének eseménykezelője

            document.getElementById('registrationForm').addEventListener('submit', function(event) {

                event.preventDefault(); // Megakadályozza az alapértelmezett űrlap küldést

 

                fetch(this.action, {

                    method: this.method,

                    body: new URLSearchParams(new FormData(this)).toString(),

                    headers: { 'Content-Type': 'application/x-www-form-urlencoded' }

                })

                .then(response => response.json())

                .then(data => {

                    if (data.message === 'Felhasználó sikeresen hozzáadva!') {

                        // Sikeres felhasználó hozzáadás esetén átirányít a felhasználók listájára

                        window.location.href = '/users';

                    } else {

                        // Hibaüzenet megjelenítése

                        alert(data.message);

                    }

                })

                .catch(error => {

                    // Hiba kezelés

                    console.error('Hiba a kérés során:', error);

                });

            });

        </script>

    `);

});

 

// POST kérés: Új felhasználó hozzáadása

app.post('/user', (req, res) => {

    const { email, name } = req.body;

 

    // Ellenőrizzük, hogy létezik-e már a felhasználó

    const existingUser = users.find(user => user.email === email);

    if (existingUser) {

        return res.status(400).json({ message: 'A felhasználó már létezik!' });

    }

 

    // Új felhasználó hozzáadása az adatbázishoz

    users.push({ email, name });

    res.status(201).json({ message: 'Felhasználó sikeresen hozzáadva!', users });

});

 

// GET kérés: A felhasználók listájának megjelenítése törlés gombbal

app.get('/users', (req, res) => {

    let userListHTML = `

        <h1>Felhasználók listája</h1>

        <ul>

    `;

 

    // A felhasználók listájának összeállítása HTML formátumban

    users.forEach(user => {

        userListHTML += `

            <li>

                ${user.name} (${user.email})

                <button onclick="deleteUser('${user.email}')">Törlés</button>

            </li>

        `;

    });

 

    userListHTML += `

        </ul>

        <br>

        <a href="/">Vissza a főoldalra</a>

        <script>

            // A felhasználó törlésére szolgáló funkció

            function deleteUser(email) {

                fetch(\`/user?email=\${email}\`, {

                    method: 'DELETE'

                })

                .then(response => response.json())

                .then(data => {

                    alert(data.message);

                    window.location.reload(); // Az oldal újratöltése a frissített lista megjelenítéséhez

                })

                .catch(error => {

                    // Hiba kezelés

                    console.error('Hiba a törlés során:', error);

                });

            }

        </script>

    `;

 

    res.send(userListHTML);

});

 

// PUT kérés: Létező felhasználó adatainak frissítése

app.put('/user', (req, res) => {

    const { email, name } = req.body;

 

    // Az adott email alapján keresünk a felhasználók között

    const userIndex = users.findIndex(user => user.email === email);

    if (userIndex === -1) {

        return res.status(404).json({ message: 'Felhasználó nem található!' });

    }

 

    // A felhasználó nevének frissítése

    users[userIndex].name = name;

    res.json({ message: 'Felhasználó sikeresen frissítve!', users });

});

 

// DELETE kérés: Felhasználó törlése email alapján query paraméterrel

app.delete('/user', (req, res) => {

    const email = req.query.email;

 

    // Az email alapján keresünk a felhasználók között

    const userIndex = users.findIndex(user => user.email === email);

    if (userIndex === -1) {

        return res.status(404).json({ message: 'Felhasználó nem található!' });

    }

 

    // A felhasználó eltávolítása az adatbázisból

    users.splice(userIndex, 1);

    res.json({ message: 'Felhasználó törölve!', users });

});

 

// A szerver indítása a megadott porton

app.listen(PORT, () => {

    console.log(`Szerver fut a következő porton: http://localhost:${PORT}`);

});

2024. szeptember 23., hétfő

13 backend - implode() függvény használata űrlap feldolgozás esetén 2024.09.24.

Az implode() egy hasznos PHP függvény, amely tömb elemeit egy sztringgé (karakterlánccá) egyesíti. A függvény megadja, hogy milyen elválasztó karaktert (például vesszőt, szóközt vagy más karaktert) szeretnénk használni a tömb elemei között a sztringben. Ez gyakran hasznos például checkboxok vagy többválasztásos elemek feldolgozásakor, ahol a felhasználó több elemet is választhat.

Szintaxis:

string implode ( string $separator , array $array )
  • $separator: Ez az az elválasztó karakter vagy karakterlánc, amit a tömb elemei közé helyezünk.
  • $array: A tömb, amelynek elemeit szeretnénk egyesíteni.

Példa:

Tegyük fel, hogy van egy tömbünk, ami tartalmazza a felhasználó által választott tananyagokat:

$tananyagok = ["HTML", "CSS", "JavaScript"];

Ha ezt a tömböt vesszővel elválasztva szeretnénk egy sztringgé alakítani, az alábbi módon használhatjuk az implode() függvényt:

$eredmeny = implode(", ", $tananyagok);
echo $eredmeny;

Ez kiírja: HTML, CSS, JavaScript

Magyarázat:

  1. Tömb elemeinek egyesítése: Az implode() függvény a tömb minden egyes elemét egyesíti egy sztringbe, és az elemek közé beteszi a megadott elválasztót.
  2. Rugalmasság: Az elválasztó karakter lehet bármi, amit meg szeretnél adni, például vessző, szóköz, pont vagy akár szavak is.
  3. Üres tömb kezelése: Ha a tömb üres, az implode() egy üres sztringet ad vissza.

További példák:

Szóközzel elválasztva:

$eredmeny = implode(" ", $tananyagok);
echo $eredmeny;

Eredmény: HTML CSS JavaScript

Ponttal elválasztva:

$eredmeny = implode(". ", $tananyagok);
echo $eredmeny;

Eredmény: HTML. CSS. JavaScript

Elválasztó nélkül:

$eredmeny = implode("", $tananyagok);
echo $eredmeny;

Eredmény: HTMLCSSJavaScript

Példa az űrlapok feldolgozásában:

Amikor több checkboxot használsz egy űrlapban, a PHP tömbként kezeli azokat. Az implode() ilyenkor segít a kiválasztott elemek egyesítésében és megjelenítésében. Például:

if (isset($_POST['anyag']) && is_array($_POST['anyag'])) {
    $anyagok = implode(", ", $_POST['anyag']);
    echo "A választott tananyagok: $anyagok";
} else {
    echo "Nem választottál tananyagot!";
}

Ez esetben, ha a felhasználó HTML-t és PHP-t választ, a kimenet a következő lesz:

A választott tananyagok: HTML, PHP

Az implode() függvény rendkívül hasznos, ha tömb elemeit szeretnéd egyszerűen, tetszőleges elválasztóval egy sztringbe fűzni. A tömbben lévő elemek rendezésére, megjelenítésére és más hasonló műveletekre nagyszerű eszköz.

7.2. Feladat

Hozz létre egy űrlapot, amelyben a felhasználó megadhatja a nevét, választhat egy napot rádiógombokkal, több tananyagot checkboxokkal, és kiválaszthat egy csoportot egy legördülő menü segítségével. Az űrlap adatainak feldolgozásához PHP-t használunk, amely ellenőrzi a bevitt adatokat, és visszajelzést ad a felhasználónak.

  1. HTML űrlap létrehozása:
    • Hozz létre egy HTML oldalt, amely az alábbi elemeket tartalmazza:
      • Egy szövegmezőt a név megadásához.
      • Két rádiógombot, amelyekkel a felhasználó a napok közül választhat (Hétfő, Kedd).
      • Két checkboxot, amelyekkel a felhasználó a tananyagok közül választhat (HTML, PHP).
      • Egy legördülő menüt, amelyben csoportot választhat (Első, Második).
    • Az űrlap az adatokat egy PHP fájlhoz küldje POST metódussal.
  2. Adatok feldolgozása PHP-ben:
    • A PHP fájl ellenőrizze, hogy a névmező kitöltött-e.
    • Ellenőrizze, hogy a napok közül választott-e a felhasználó, és a megfelelő napot jelenítse meg.
    • A tananyagok közül választhat több opciót is a felhasználó; ezeket egy sztringben listázd ki.
    • Ellenőrizze, hogy a csoportot választotta-e, és adjon visszajelzést a kiválasztott csoport alapján.

Részletes követelmények:

1.     HTML oldalon:

    • A név mező legyen kötelezően kitöltendő.
    • A rádiógombokkal biztosítsd, hogy csak egy napot lehessen kiválasztani.
    • A checkboxok segítségével több tananyag is választható.
    • A legördülő menü első eleme a „Válassz csoportot” legyen, ami nem választható érvényes opcióként.

2.     PHP feldolgozó fájl:

    • Ellenőrizze a POST kérelem típusát.
    • Ellenőrizze a név mezőt, és ha üres, adjon visszajelzést („Nem adtad meg a neved!”).
    • Ellenőrizze, hogy választottak-e napot, és írja ki a választott nap nevét („Hétfő” vagy „Kedd”).
    • Ellenőrizze, hogy legalább egy tananyagot kiválasztottak-e, és listázza ki azokat.
    • A csoport kiválasztását switch-el kezelje, és adjon visszajelzést az első vagy második csoport választása esetén.

Példa kimenet:

Amennyiben a felhasználó a „Hétfő” napot, „HTML” tananyagot és az első csoportot választja, a következő kimenetet várjuk:

Neved: Példa Név
A választott nap: Hétfő
Választott tananyagok: HTML
Az első csoportot választottad.

Ha valamilyen adat hiányzik, a megfelelő hibaüzenet jelenik meg.

Tesztelés:

  • Töltsd ki az űrlapot különböző kombinációkkal, és ellenőrizd a PHP kimenetét.
  • Próbáld ki, mi történik, ha nem adsz meg nevet vagy nem választasz csoportot.










2024. szeptember 20., péntek

Adatbázis kapcsolat PHP

// HTTP fejléc beállítása a megfelelő tartalomtípussal és karakterkódolással

header("Content-Type: text/html; charset=utf-8");

// Adatbázis kapcsolódáshoz szükséges adatok definíciója

/*A define() egy beépített PHP függvény, amelynek segítségével konstansokat definiálhatunk. Konstansok olyan változók, amelyek értéke egyszerre van meghatározva és nem változik futás közben. Általában nagybetűkkel szokták írni őket, és globálisan elérhetőek a kódban. */

define("DBHOST", "localhost"); // Adatbázis szerver elérési útja

define("DBUSER", "root"); // Adatbázis felhasználónév

define("DBPASS", ""); // Adatbázis jelszó

define("DBNAME", "database_name"); // Adatbázisod neve

másik lehetőség .env fájl használata

A .env fájl egy konfig fájl, környezeti változókat definiálhatunk benne. Ezeket az appunk futás közben olvassa be, és használja beállításokhoz, pl adatbázis kapcsolathoz, API kulcsokhoz, stb. A .env fájl azért hasznos, mert az érzékeny adatokat nem közvetlenül a forráskódban tároljuk, hanem külön fájlban, ami biztonságosabb. */

// .env fájl betöltése a Dotenv könyvtár segítségével

require 'vendor/autoload.php';

//telepíteni kell : composer require vlucas/phpdotenv

/* Létrehoz egy Dotenv objektumot, amely a megadott könyvtárban (általában a projekt gyökérkönyvtárában) keresi a .env fájlt.

Dotenv\Dotenv: Ez a Dotenv osztály teljes névtere és neve. A névtér (Dotenv) segít elkerülni az ütközéseket más osztályokkal.

::createImmutable(DIR): A :: operátor használatával hívjuk a createImmutable statikus metódust a Dotenv osztályban. Ez a metódus egy új Dotenv objektumot hoz létre, amely az aktuális könyvtárban (__DIR__) keresi a .env fájlt.

A :: operátor a PHP-ben az osztályok statikus tagjainak (metódusok, tulajdonságok, konstansok) elérésére szolgál. Ez lehetővé teszi a kód számára, hogy statikus kontextusban működjön, anélkül, hogy szükség lenne az osztály példányosítására.*/

$dotenv = Dotenv\Dotenv::createImmutable(__DIR__);

//betölti a .env fájl tartalmát és beállítja a környezeti változókat, így azok elérhetők lesznek az alkalmazásban.

$dotenv->load();

// Beállítjuk a tartalom típusát és karakterkódolását

header("Content-Type: text/html; charset=utf-8");

// Az adatbázis kapcsolati adatok meghatározása környezeti változók használatával.

define("DBHOST", $_ENV['DBHOST']);

define("DBUSER", $_ENV['DBUSER']);

define("DBPASS", $_ENV['DBPASS']);

define("DBNAME", $_ENV['DBNAME']);

// Létrehozza az adatbázis kapcsolatot a mysqli objektum segítségével.

$dbconn = new mysqli(DBHOST, DBUSER, DBPASS, DBNAME);

.env fájl tartalma

DBHOST=localhost

DBUSER=root

DBPASS=

DBNAME=database_name

2024. szeptember 18., szerda

PHP böngésző problémákra

?php
header('Access-Control-Allow-Origin: *');
header("Access-Control-Allow-Headers: Origin, X-Requested-With, Content-Type, Accept");
header('Access-Control-Allow-Methods: GET, POST, PUT, DELETE');

// Ne tárolja el a böngésző a választ 
header("Cache-Control: no-store, no-cache, must-revalidate, max-age=0"); 
header("Cache-Control: post-check=0, pre-check=0", false); 
header("Pragma: no-cache"); 
header("Expires: 0");

Ezek a fejlécbeállítások PHP-ban általában a Cross-Origin Resource Sharing (CORS) és a cache kezelésére szolgálnak.

Az első 3 lehetővé teszi a szerver számára, hogy különböző eredetű (domainek közötti) kéréseket fogadjon el, és különböző HTTP-módszereket (GET, POST, PUT, DELETE) kezeljen. A következő 4 a cache problémát oldja meg, amivel a fejlesztés során találkozunk.

  1. header('Access-Control-Allow-Origin: *');

    • Ez a fejléc beállítja, hogy a szerver minden domaintől elfogadjon kéréseket. A * azt jelenti, hogy bármilyen eredet (origin) engedélyezett.
  2. header("Access-Control-Allow-Headers: Origin, X-Requested-With, Content-Type, Accept");

    • Ez a fejléc határozza meg, hogy a kérésben milyen egyedi fejlécek használhatók. Itt például az Origin, X-Requested-With, Content-Type, és Accept fejléceket engedélyezi.
  3. header('Access-Control-Allow-Methods: GET, POST, PUT, DELETE');

    • Ez a fejléc szabályozza, hogy milyen HTTP-módszereket engedélyez a szerver. A GET, POST, PUT és DELETE módszerek itt kifejezetten engedélyezve vannak.
  4. Cache-Control: no-store, no-cache, must-revalidate, max-age=0

    • no-store: Ne tároljon semmilyen adatot.
    • no-cache: Minden egyes kérésnél ellenőrizze, hogy a válasz friss-e.
    • must-revalidate: Az elavult adatok nem használhatóak.
    • max-age=0: Az adatok azonnal lejárnak.
  5. Cache-Control: post-check=0, pre-check=0, false

    • post-check és pre-check: Ezek az opciók az Internet Explorer speciális beállításait érintik.
  6. Pragma: no-cache

    • Ez a fejléc a régebbi HTTP/1.0 rendszerek számára biztosítja, hogy ne cache-eljenek.
  7. Expires: 0

    • Ez a fejléc a válasz lejárati idejét állítja be, általában azonnali lejáratra.
  8. Ezek a beállítások segítenek abban, hogy a böngésző minden egyes kérésnél friss adatokat kérjen a szervertől, és ne tároljon el semmit a cache-be.

2024. szeptember 17., kedd

12 B Body-parser modul

 A body-parser egy Node.js middleware modul, amely megkönnyíti a bejövő HTTP-kérések body részének kezelését. Ez a modul különösen hasznos akkor, ha az űrlapadatokat vagy JSON-tartalmat szeretnél fogadni és feldolgozni egy POST vagy PUT kérés során az Express-ben.

Miért van szükség a body-parser-re?

Alapértelmezésben a Node.js és az Express nem képes a kérések törzsét automatikusan feldolgozni. Ezért van szükség a body-parser modulra, amely a kérések törzsét elérhetővé teszi a req.body objektumon keresztül.

Telepítése: npm install body-parser

Példa a használatára:

const express = require('express');

const bodyParser = require('body-parser');

const app = express();

// A body-parser használata JSON formátumú adatok feldolgozásához

/* app.use(bodyParser.json()): Ez a middleware lehetővé teszi, hogy JSON típusú kéréseket tudjunk feldolgozni, így például egy API-ban érkező JSON adatok a req.body-ban lesznek elérhetők. */

app.use(bodyParser.json());

// A body-parser használata URL-kódolt adatok feldolgozásához

/* app.use(bodyParser.urlencoded({ extended: true })): Ez az opció az űrlapokon keresztül küldött URL-kódolt adatokat dolgozza fel (mint a HTML form elemek application/x-www-form-urlencoded típusa). Az extended: true opció lehetővé teszi, hogy összetett objektumokat (pl. beágyazott objektumokat) is kezeljünk. */

app.use(bodyParser.urlencoded({ extended: true }));

// Példa POST kérésre

app.post('/submit', (req, res) => {

  const name = req.body.name;

  const email = req.body.email;

  res.send(`Név: ${name}, Email: ${email}`);

});

 

// A szerver figyel a 3000-es porton

app.listen(3000, () => {

  console.log('Szerver fut a http://localhost:3000 címen');

});

Működés:

Ha egy POST kérés érkezik a /submit útvonalra, például egy HTML űrlapból, a body-parser feldolgozza a kérést, és az adatokat a req.body objektumban tárolja. Ezután az adatok hozzáférhetők a további feldolgozáshoz vagy válaszként történő küldéshez.

Extended beállítás a urlencoded metódusnál

extended: true: Lehetővé teszi, hogy összetett adatstruktúrák, például beágyazott objektumok is kezelhetők legyenek (azaz nemcsak sima string értékeket tudsz fogadni).

extended: false: Csak egyszerű key-value párokat enged feldolgozni, például az alapvető URL-kódolt formákat.

Az express újabb verzióiban (pl. Express 4.x-től) a body-parser bizonyos funkciói beépítésre kerültek az Express alapvető részeként, így külön body-parser telepítése nem mindig szükséges, mivel használhatod az Express saját beépített módszereit is:

app.use(express.json());

app.use(express.urlencoded({ extended: true }));

vagyis nem kell külön telepíteni. Ezért nézzük meg a verzió számot.

12 B Express.js - Bevezetés: Express.js keretrendszer alapjai, routing és middleware

 Az Express.js a Node.js egyik legnépszerűbb és legszélesebb körben használt keretrendszere. Ez egy minimalista és rugalmas webes keretrendszer, amely egyszerűsíti a webalkalmazások és API-k fejlesztését. Az Express.js a Node.js-re épül, és lehetővé teszi, hogy gyorsan és hatékonyan fejlesszünk webes szervereket, mivel számos olyan alapvető funkciót biztosít, amelyekkel különben kézzel kellene bajlódnunk. Lényegében megkönnyíti a szerveroldali alkalmazások és API-k létrehozását. Az express sokkal könnyebbé teszi a HTTP-kérések kezelését, az útvonalak definiálását, és middleware-k hozzáadását a request/response ciklushoz.

3.1. Az Express.js Alapjai

Mi az az Express.js?

Az Express.js egy Node.js alapú, nyílt forráskódú webes alkalmazáskeretrendszer, amelyet főleg kiszolgálói alkalmazások készítésére használnak. Az Express segítségével gyorsan és könnyen létrehozhatunk weboldalakat és webes API-kat. Ez a keretrendszer azért vált népszerűvé, mert megkönnyíti a HTTP kérések és válaszok kezelését, a különböző útvonalak (routing) beállítását, valamint a middleware-ek alkalmazását, amelyek speciális funkciókat biztosítanak.

Az Express.js Telepítése

Mielőtt használni kezdhetjük az Express.js-t, telepítenünk kell. Ehhez először telepíteni kell a Node.js-t, majd a Node Package Manager (npm) segítségével az Express-t.

2.     Express.js telepítése:

    • Nyisd meg a terminált (vagy parancssort) és hozd létre az alkalmazásod mappáját:
mkdir my-express-app
cd my-express-app
    • Inicializáld az npm-et a mappában:
npm init -y
    • Telepítsd az Express.js-t:
npm install express --save
vagy ha már van saját mappád: npm install express

Egyszerű Express.js Alkalmazás Létrehozása

Az alábbi kód egy egyszerű Express.js alkalmazás, amely egy HTTP szervert hoz létre, és válaszol a bejövő kérésekre.

// Az express modul importálása
const express = require('express');
 
// Egy új express alkalmazás létrehozása
const app = express();
 
// Egy útvonal kezelése a gyökér URL-re ('/')
app.get('/', (req, res) => {
  res.send('Hello, Express.js!');
});
 
// A szerver elindítása és figyelés egy adott porton (3000)
app.listen(3000, () => {
  console.log('Szerver fut a http://localhost:3000 címen');
});

1.     const express = require('express');:

    • Az express modul importálása szükséges ahhoz, hogy használni tudjuk az Express.js keretrendszert. Ez a sor betölti az Express modulját, amit később az app nevű változóban fogunk használni.

2.     const app = express();:

    • Az express() meghívása létrehoz egy új Express alkalmazást, amely egy HTTP szerverként fog viselkedni. Az app nevű változóban tároljuk az alkalmazást, hogy később hozzáférjünk a különböző funkcióihoz.

3.     app.get('/', (req, res) => { ... });:

    • Itt definiálunk egy útvonalat a gyökér URL-re (azaz a / útvonalra). Ez azt jelenti, hogy ha valaki meglátogatja az alkalmazást a böngészőjében a gyökér URL-en, akkor a megadott callback függvény fut le.
    • A callback függvény két paramétert kap: req (request) és res (response). A req tartalmazza a kliens által küldött kérés részleteit, a res pedig azt az objektumot, amellyel válaszolhatunk a kliensnek.
    • A res.send('Hello, Express.js!'); sor elküldi a válaszként a "Hello, Express.js!" szöveget a kliensnek.

4.     app.listen(3000, () => { ... });:

    • Ezzel a sorral indítjuk el a szervert, és megadjuk, hogy melyik porton figyeljen (ebben az esetben a 3000-es porton). Amikor a szerver sikeresen elindul, a callback függvény fut le, és kiírja a konzolra, hogy a szerver fut.

3.2. Routing Express.js-ben

A routing az az eljárás, amellyel az alkalmazás meghatározza, hogyan válaszoljon a bejövő kérésekre egy adott URL-re. Az Express.js ezt rendkívül egyszerűvé teszi. Különböző HTTP módszereket (pl. GET, POST, PUT, DELETE) használhatunk, hogy különböző típusú kéréseket kezeljünk.

Erre példának, egy komplex feladatot fogunk megoldani közösen.

3.3. Middleware Az Express.js-ben

A middleware az Express.js egyik legfontosabb eleme. A middleware-ek olyan függvények, amelyek a bejövő kérések és a kiszolgált válaszok közötti folyamatokat kezelik. Ezek a függvények lehetővé teszik, hogy módosítsuk a kérés és válasz objektumokat, befejezzük a kérelem- és válaszfolyamatot, vagy továbblépjünk a következő middleware-re.

Példa Egy Egyszerű Middleware-re

const express = require('express');
const app = express();
 
// Egy egyszerű middleware, amely minden kérésnél lefut
app.use((req, res, next) => {
  console.log(`${req.method} kérés érkezett a(z) ${req.url} URL-re`);
  next(); // Tovább lép a következő middleware-re vagy útvonalra
});
 
// Kezelés a gyökér URL-re
app.get('/', (req, res) => {
  res.send('Kezdőlap');
});
 
// Kezelés az '/about' URL-re
app.get('/about', (req, res) => {
  res.send('About oldal');
});
 
app.listen(3000, () => {
  console.log('Szerver fut a http://localhost:3000 címen');
});

Middleware Kód Magyarázata

  1. app.use((req, res, next) => { ... });:
    • Az app.use metódussal definiálunk egy általános middleware-t, amely minden egyes bejövő kérésnél lefut.
    • A middleware függvény három paramétert kap: req (kérés), res (válasz) és next (egy függvény, amely a következő middleware-t vagy útvonalkezelőt hívja meg).
    • Ebben az esetben a middleware naplózza a konzolra a kérés típusát (pl. GET) és a kért URL-t. Ezután a next() meghívásával a folyamat továbbhalad a következő middleware-re vagy útvonalkezelőre.

Példák és Gyakorlati Feladatok

Példa 1: Alapvető Routing

Hozz létre egy Express.js alkalmazást, amely különböző útvonalakat kezel:

  • GET /: Válaszoljon "Főoldal".
  • GET /about: Válaszoljon "Rólunk".
  • GET /contact: Válaszoljon "Kapcsolat".
  • GET *: Válaszoljon "404 - Az oldal nem található", ha a felhasználó egy nem létező oldalra próbál navigálni.

2024. szeptember 16., hétfő

13 backend 9. - Adatbázis műveletek a PHP-ben összefoglaló

 -- Minden érték lekérése

SELECT * FROM tablanev;

 

-- Adott oszlopok lekérése

SELECT oszlop1, oszlop2, oszlop3 FROM tablanev;

 

-- Az oszlopok nevének körülírása backtick-kel

SELECT `oszlop1`, `oszlop2`, `oszlop3` FROM tablanev;

 

-- Feltétellel adatlekérés

SELECT * FROM tablanev WHERE feltetel;

 

-- Adott oszlopok lekérése feltétellel

SELECT oszlop1, oszlop2, oszlop3 FROM tablanev WHERE feltetel;

 

-- Keresés LIKE segítségével

SELECT oszlop1, oszlop2, oszlop3 FROM tablanev WHERE oszlop1 LIKE 'kifejezes%';  -- Kezdő kifejezés

SELECT oszlop1, oszlop2, oszlop3 FROM tablanev WHERE oszlop1 LIKE '%kifejezes%';  -- Bármely helyen

 

-- Rendezés ASC [A-Z-ig], DESC [Z-A-ig]

SELECT * FROM tablanev ORDER BY oszlop1 ASC;  -- Növekvő sorrend

SELECT * FROM tablanev ORDER BY oszlop1 DESC;  -- Csökkenő sorrend

SELECT * FROM tablanev WHERE feltetel ORDER BY oszlop1 DESC;  -- Feltétellel és csökkenő sorrend

SELECT * FROM tablanev WHERE feltetel ORDER BY oszlop1 DESC, oszlop2 ASC;  -- Több oszlop szerinti rendezés

 

-- Adott darabszám lekérése

SELECT * FROM tablanev LIMIT 10;  -- Az első 10 rekord

SELECT * FROM tablanev LIMIT 10, 10;  -- 10-től kezdődő következő 10 rekord

 

-- Rekord beszúrása

INSERT INTO tablanev (oszlop1, oszlop2, oszlop3) VALUES ('ertek1', ertek2, ertek3);

 

-- Rekordok törlése

DELETE FROM tablanev WHERE feltetel;

 

-- Rekordok módosítása

UPDATE tablanev SET oszlop1 = ertek1, oszlop2 = 'ertek2' WHERE feltetel;

 

-- Több tábla összekapcsolása JOIN használatával

-- Inner Join: Két tábla közös rekordjait adja vissza

SELECT t1.oszlop1, t2.oszlop2 FROM tabla1 t1

JOIN tabla2 t2 ON t1.kozos_oszlop = t2.kozos_oszlop;

 

-- Left Join: Az első táblából minden rekordot visszaad, és a második táblából csak a megfelelő rekordokat

SELECT t1.oszlop1, t2.oszlop2 FROM tabla1 t1

LEFT JOIN tabla2 t2 ON t1.kozos_oszlop = t2.kozos_oszlop;

 

-- Right Join: A második táblából minden rekordot visszaad, és az első táblából csak a megfelelő rekordokat

SELECT t1.oszlop1, t2.oszlop2 FROM tabla1 t1

RIGHT JOIN tabla2 t2 ON t1.kozos_oszlop = t2.kozos_oszlop;

 

-- Union: Két SELECT eredményének egyesítése

SELECT oszlop1 FROM tabla1

UNION

SELECT oszlop1 FROM tabla2;

2024. szeptember 15., vasárnap

2024.09.16-20

 


12 ikt - before express

 A feladat megoldásához az alábbi kódrészletet fogjuk használni: 

<!DOCTYPE html>
            <html lang="hu">
            <head>
                <meta charset="UTF-8">
                <meta name="viewport" content="width=device-width, initial-scale=1.0">
                <title>Rólunk</title>
                <style>
                    body { font-family: Arial, sans-serif; margin: 0; padding: 0; }
                    header { background: #007BFF; color: white; padding: 1rem; text-align: center; }
                    nav { background: #343A40; padding: 0.5rem; }
                    nav a { color: white; text-decoration: none; margin: 0 1rem; }
                    main { padding: 2rem; }
                    footer { background: #343A40; color: white; padding: 1rem; text-align: center; }
                </style>
            </head>
            <body>
                <header><h1>Rólunk</h1></header>
                <nav>
                    <a href="/">Főoldal</a>
                    <a href="/about">Rólunk</a>
                    <a href="/contact">Kapcsolat</a>
                </nav>
                <main>
                    <h2>Rólunk</h2>
                    <p>Ez az oldal a csapatunk történetéről és célkitűzéseiről szól.</p>
                </main>
                <footer><p>&copy; 2024 Weboldal. Minden jog fenntartva.</p></footer>
            </body>
            </html>

12 ikt - 3. Express.js Bevezetés: Express.js keretrendszer alapjai, routing és middleware

Az Express.js a Node.js egyik legnépszerűbb és legszélesebb körben használt keretrendszere. Ez egy minimalista és rugalmas webes keretrendszer, amely egyszerűsíti a webalkalmazások és API-k fejlesztését. Az Express.js a Node.js-re épül, és lehetővé teszi, hogy gyorsan és hatékonyan fejlesszünk webes szervereket, mivel számos olyan alapvető funkciót biztosít, amelyekkel különben kézzel kellene bajlódnunk.

Mi az az Express.js?

Az Express.js egy Node.js alapú, nyílt forráskódú webes alkalmazáskeretrendszer, amelyet főleg kiszolgálói alkalmazások készítésére használnak. Az Express segítségével gyorsan és könnyen létrehozhatunk weboldalakat és webes API-kat. Ez a keretrendszer azért vált népszerűvé, mert megkönnyíti a HTTP kérések és válaszok kezelését, a különböző útvonalak (routing) beállítását, valamint a middleware-ek alkalmazását, amelyek speciális funkciókat biztosítanak.

Az Express.js Telepítése

Mielőtt használni kezdhetjük az Express.js-t, telepítenünk kell. Ehhez először telepíteni kell a Node.js-t, majd a Node Package Manager (npm) segítségével az Express-t.

1.     Node.js telepítése:

    • Töltsd le és telepítsd a Node.js-t a hivatalos weboldalról.
    • A telepítés során az npm is telepítésre kerül.

2.     Express.js telepítése:

    • Nyisd meg a terminált (vagy parancssort) és hozd létre az alkalmazásod mappáját:
mkdir my-express-app
cd my-express-app
    • Inicializáld az npm-et a mappában:
npm init -y
    • Telepítsd az Express.js-t:
npm install express --save

Egyszerű Express.js Alkalmazás Létrehozása

Az alábbi kód egy egyszerű Express.js alkalmazás, amely egy HTTP szervert hoz létre, és válaszol a bejövő kérésekre.

// Az express modul importálása
const express = require('express');
 
// Egy új express alkalmazás létrehozása
const app = express();
 
// Egy útvonal kezelése a gyökér URL-re ('/')
app.get('/', (req, res) => {
  res.send('Hello, Express.js!');
});
 
// A szerver elindítása és figyelés egy adott porton (3000)
app.listen(3000, () => {
  console.log('Szerver fut a http://localhost:3000 címen');
});

1.     const express = require('express');:

    • Az express modul importálása szükséges ahhoz, hogy használni tudjuk az Express.js keretrendszert. Ez a sor betölti az Express modulját, amit később az app nevű változóban fogunk használni.

2.     const app = express();:

    • Az express() meghívása létrehoz egy új Express alkalmazást, amely egy HTTP szerverként fog viselkedni. Az app nevű változóban tároljuk az alkalmazást, hogy később hozzáférjünk a különböző funkcióihoz.

3.     app.get('/', (req, res) => { ... });:

    • Itt definiálunk egy útvonalat a gyökér URL-re (azaz a / útvonalra). Ez azt jelenti, hogy ha valaki meglátogatja az alkalmazást a böngészőjében a gyökér URL-en, akkor a megadott callback függvény fut le.
    • A callback függvény két paramétert kap: req (request) és res (response). A req tartalmazza a kliens által küldött kérés részleteit, a res pedig azt az objektumot, amellyel válaszolhatunk a kliensnek.
    • A res.send('Hello, Express.js!'); sor elküldi a válaszként a "Hello, Express.js!" szöveget a kliensnek.

4.     app.listen(3000, () => { ... });:

    • Ezzel a sorral indítjuk el a szervert, és megadjuk, hogy melyik porton figyeljen (ebben az esetben a 3000-es porton). Amikor a szerver sikeresen elindul, a callback függvény fut le, és kiírja a konzolra, hogy a szerver fut.

3.2. Routing Express.js-ben

A routing az az eljárás, amellyel az alkalmazás meghatározza, hogyan válaszoljon a bejövő kérésekre egy adott URL-re. Az Express.js ezt rendkívül egyszerűvé teszi. Különböző HTTP módszereket (pl. GET, POST, PUT, DELETE) használhatunk, hogy különböző típusú kéréseket kezeljünk.

Erre példának, egy komplex feladatot fogunk megoldani közösen.

3.3. Middleware Az Express.js-ben

A middleware az Express.js egyik legfontosabb eleme. A middleware-ek olyan függvények, amelyek a bejövő kérések és a kiszolgált válaszok közötti folyamatokat kezelik. Ezek a függvények lehetővé teszik, hogy módosítsuk a kérés és válasz objektumokat, befejezzük a kérelem- és válaszfolyamatot, vagy továbblépjünk a következő middleware-re.

Példa Egy Egyszerű Middleware-re

const express = require('express');
const app = express();
 
// Egy egyszerű middleware, amely minden kérésnél lefut
app.use((req, res, next) => {
  console.log(`${req.method} kérés érkezett a(z) ${req.url} URL-re`);
  next(); // Tovább lép a következő middleware-re vagy útvonalra
});
 
// Kezelés a gyökér URL-re
app.get('/', (req, res) => {
  res.send('Kezdőlap');
});
 
// Kezelés az '/about' URL-re
app.get('/about', (req, res) => {
  res.send('About oldal');
});
 
app.listen(3000, () => {
  console.log('Szerver fut a http://localhost:3000 címen');
});

Middleware Kód Magyarázata

  1. app.use((req, res, next) => { ... });:
    • Az app.use metódussal definiálunk egy általános middleware-t, amely minden egyes bejövő kérésnél lefut.
    • A middleware függvény három paramétert kap: req (kérés), res (válasz) és next (egy függvény, amely a következő middleware-t vagy útvonalkezelőt hívja meg).
    • Ebben az esetben a middleware naplózza a konzolra a kérés típusát (pl. GET) és a kért URL-t. Ezután a next() meghívásával a folyamat továbbhalad a következő middleware-re vagy útvonalkezelőre.

Példák és Gyakorlati Feladatok

Példa 1: Alapvető Routing

Hozz létre egy Express.js alkalmazást, amely különböző útvonalakat kezel:

  • GET /: Válaszoljon "Főoldal".
  • GET /about: Válaszoljon "Rólunk".
  • GET /contact: Válaszoljon "Kapcsolat".
  • GET *: Válaszoljon "404 - Az oldal nem található", ha a felhasználó egy nem létező oldalra próbál navigálni.

Megoldás:

const express = require('express');
const app = express();
 
app.get('/', (req, res) => {
  res.send('Főoldal');
});
 
app.get('/about', (req, res) => {
  res.send('Rólunk');
});
 
app.get('/contact', (req, res) => {
  res.send('Kapcsolat');
});
 
app.get('*', (req, res) => {
  res.status(404).send('404 - Az oldal nem található');
});
 
app.listen(3000, () => {
  console.log('Szerver fut a http://localhost:3000 címen');
});

Példa 2: Middleware Használata

Adj hozzá egy middleware-t, amely naplózza a bejövő kéréseket és a kért URL-eket, majd kezelje az alábbi útvonalakat:

  • GET /: Válaszoljon "Kezdőlap".
  • GET /about: Válaszoljon "About oldal".

Megoldás:

const express = require('express');
const app = express();
 
app.use((req, res, next) => {
  console.log(`${req.method} kérés érkezett a(z) ${req.url} URL-re`);
  next();
});
 
app.get('/', (req, res) => {
  res.send('Kezdőlap');
});
 
app.get('/about', (req, res) => {
  res.send('About oldal');
});
 
app.listen(3000, () => {
  console.log('Szerver fut a http://localhost:3000 címen');

Norvég feladat

A feladathoz szükséges képek, minta és adatbázis elérhetősége: https://github.com/latiza/norv-gfeladat/