vizsga-segedlet

v1.0.10

Published

a month ago

Installs a template.md file to your project root on npm install

0High
0Medium
0Low

palixofficial

template markdown install

Globális vizsga segédlet

Ez a fájl nem egy konkrét feladathoz készült, hanem gyorsan másolható mintákat ad React Contexthez, Laravel API backendhez és alap Java megoldásokhoz.

Tartalomjegyzék

React Context

Context létrehozása

Példa fájl: src/contexts/UserContext.jsx

import { createContext, useContext, useState } from "react";

const UserContext = createContext(null);

export function useUserContext() {
  const context = useContext(UserContext);

  if (!context) {
    throw new Error("useUserContext csak UserProvideren belül használható!");
  }

  return context;
}

Provider implementálása teljes értékkel

A Providerben van két külön useState: firstName és lastName. Ezekből készül egy teljes értékű user objektum, amit a Context továbbad a komponenseknek.

Ugyanebben a fájlban:

export function UserProvider({ children }) {
  const [firstName, setFirstName] = useState("Teszt");
  const [lastName, setLastName] = useState("Elek");

  const user = {
    firstName,
    lastName,
    fullName: `${lastName} ${firstName}`,
  };

  function updateUser(newFirstName, newLastName) {
    setFirstName(newFirstName);
    setLastName(newLastName);
  }

  function resetUser() {
    setFirstName("");
    setLastName("");
  }

  const value = {
    firstName,
    setFirstName,
    lastName,
    setLastName,
    user,
    updateUser,
    resetUser,
  };

  return <UserContext.Provider value={value}>{children}</UserContext.Provider>;
}

Provider bekötése

Példa fájl: src/main.jsx

import { StrictMode } from "react";
import { createRoot } from "react-dom/client";
import App from "./App.jsx";
import { UserProvider } from "./contexts/UserContext.jsx";

createRoot(document.getElementById("root")).render(
  <StrictMode>
    <UserProvider>
      <App />
    </UserProvider>
  </StrictMode>
);

Context használata komponensben

import { useUserContext } from "../contexts/UserContext.jsx";

export default function Profile() {
  const {
    firstName,
    setFirstName,
    lastName,
    setLastName,
    user,
    updateUser,
    resetUser,
  } = useUserContext();

  return (
    <section>
      <h2>Profil</h2>

      <input
        type="text"
        value={lastName}
        onChange={(event) => setLastName(event.target.value)}
        placeholder="Vezetéknév"
      />

      <input
        type="text"
        value={firstName}
        onChange={(event) => setFirstName(event.target.value)}
        placeholder="Keresztnév"
      />

      <p>Teljes név: {user.fullName}</p>

      <button onClick={() => updateUser("Anna", "Kovács")}>
        Teszt felhasználó beállítása
      </button>

      <button onClick={resetUser}>Törlés</button>
    </section>
  );
}

Laravel backend

Az alábbi példa két táblával dolgozik:

categories: kategóriák
products: termékek, amelyek egy kategóriához tartoznak

A products.category_id külső kulcs a categories.id mezőre mutat.

Alap parancsok

# API route fájlok telepítése, ha még nincs api.php
php artisan install:api

# Model + migration + factory + seeder + API controller
php artisan make:model Category -mfs
php artisan make:model Product -mfs
php artisan make:controller Api/ProductController --api

# Migráció és seed futtatása
php artisan migrate:fresh --seed

# Fejlesztői szerver
php artisan serve

Modellek és migrationök

database/migrations/xxxx_xx_xx_create_categories_table.php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up(): void
    {
        Schema::create('categories', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->text('description')->nullable();
            $table->timestamps();
        });

        DB::table('categories')->insert([
            [
                'id' => 1,
                'name' => 'Elektronika',
                'description' => 'Elektronikai termékek',
                'created_at' => now(),
                'updated_at' => now(),
            ],
            [
                'id' => 2,
                'name' => 'Élelmiszer',
                'description' => 'Élelmiszerek és italok',
                'created_at' => now(),
                'updated_at' => now(),
            ],
        ]);
    }

    public function down(): void
    {
        Schema::dropIfExists('categories');
    }
};

database/migrations/xxxx_xx_xx_create_products_table.php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up(): void
    {
        Schema::create('products', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->integer('price');
            $table->foreignId('category_id')->constrained('categories')->cascadeOnDelete();
            $table->timestamps();
        });

        DB::table('products')->insert([
            [
                'name' => 'Laptop',
                'price' => 250000,
                'category_id' => 1,
                'created_at' => now(),
                'updated_at' => now(),
            ],
            [
                'name' => 'Egér',
                'price' => 6000,
                'category_id' => 1,
                'created_at' => now(),
                'updated_at' => now(),
            ],
        ]);
    }

    public function down(): void
    {
        Schema::dropIfExists('products');
    }
};

Hardcodeolt adatok migrationben

Ha vizsgán gyorsan kell fix adat, lehet DB::table()->insert()-et használni migrationben. Fontos: előbb a szülő tábla adata legyen beszúrva, utána a külső kulcsot használó tábla.

categories migration Schema::create() után:

DB::table('categories')->insert([
    [
        'id' => 1,
        'name' => 'Elektronika',
        'description' => 'Elektronikai termékek',
        'created_at' => now(),
        'updated_at' => now(),
    ],
    [
        'id' => 2,
        'name' => 'Élelmiszer',
        'description' => 'Élelmiszerek és italok',
        'created_at' => now(),
        'updated_at' => now(),
    ],
]);

Seeder

database/seeders/CategorySeeder.php

namespace Database\Seeders;

use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\DB;

class CategorySeeder extends Seeder
{
    public function run(): void
    {
        DB::table('categories')->insert([
            [
                'name' => 'Elektronika',
                'description' => 'Elektronikai termékek',
                'created_at' => now(),
                'updated_at' => now(),
            ],
            [
                'name' => 'Élelmiszer',
                'description' => 'Élelmiszerek és italok',
                'created_at' => now(),
                'updated_at' => now(),
            ],
        ]);
    }
}

database/seeders/ProductSeeder.php

namespace Database\Seeders;

use App\Models\Product;
use Illuminate\Database\Seeder;

class ProductSeeder extends Seeder
{
    public function run(): void
    {
        Product::factory()->count(10)->create();
    }
}

database/seeders/DatabaseSeeder.php

namespace Database\Seeders;

use Illuminate\Database\Seeder;

class DatabaseSeeder extends Seeder
{
    public function run(): void
    {
        $this->call([
            CategorySeeder::class,
            ProductSeeder::class,
        ]);
    }
}

Factory

database/factories/CategoryFactory.php

namespace Database\Factories;

use Illuminate\Database\Eloquent\Factories\Factory;

class CategoryFactory extends Factory
{
    public function definition(): array
    {
        return [
            'name' => fake()->word(),
            'description' => fake()->sentence(),
        ];
    }
}

database/factories/ProductFactory.php

namespace Database\Factories;

use App\Models\Category;
use Illuminate\Database\Eloquent\Factories\Factory;

class ProductFactory extends Factory
{
    public function definition(): array
    {
        return [
            'name' => fake()->word(),
            'price' => fake()->numberBetween(1000, 500000),
            'category_id' => Category::query()->inRandomOrder()->value('id') ?? Category::factory(),
        ];
    }
}

Model kapcsolatok

app/Models/Category.php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasMany;

class Category extends Model
{
    use HasFactory;

    protected $fillable = [
        'name',
        'description',
    ];

    public function products(): HasMany
    {
        return $this->hasMany(Product::class);
    }
}

app/Models/Product.php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;

class Product extends Model
{
    use HasFactory;

    protected $fillable = [
        'name',
        'price',
        'category_id',
    ];

    public function category(): BelongsTo
    {
        return $this->belongsTo(Category::class);
    }
}

API controller

app/Http/Controllers/Api/ProductController.php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Models\Product;
use Illuminate\Http\Request;

class ProductController extends Controller
{
    public function index()
    {
        return Product::with('category')->get();
    }

    public function show(Product $product)
    {
        return $product->load('category');
    }

    public function store(Request $request)
    {
        $validated = $request->validate([
            'name' => ['required', 'string', 'max:255'],
            'price' => ['required', 'integer', 'min:0'],
            'category_id' => ['required', 'exists:categories,id'],
        ]);

        return Product::create($validated)->load('category');
    }

    public function update(Request $request, Product $product)
    {
        $validated = $request->validate([
            'name' => ['sometimes', 'required', 'string', 'max:255'],
            'price' => ['sometimes', 'required', 'integer', 'min:0'],
            'category_id' => ['sometimes', 'required', 'exists:categories,id'],
        ]);

        $product->update($validated);

        return $product->load('category');
    }

    public function destroy(Product $product)
    {
        $product->delete();

        return response()->json([
            'message' => 'Sikeres törlés',
        ]);
    }
}

API route

routes/api.php

use App\Http\Controllers\Api\ProductController;
use Illuminate\Support\Facades\Route;

Route::apiResource('products', ProductController::class);

Teszt URL-ek:

GET    /api/products
GET    /api/products/1
POST   /api/products
PUT    /api/products/1
DELETE /api/products/1

A GET /api/products válaszban a category kapcsolat is benne lesz:

[
  {
    "id": 1,
    "name": "Laptop",
    "price": 250000,
    "category_id": 1,
    "category": {
      "id": 1,
      "name": "Elektronika"
    }
  }
]

Java alapminták

Alap adattípusok és kiírás

Egysoros leírás: alap változók létrehozása és konzolra írás.

public class Main {
    public static void main(String[] args) {
        int eletkor = 20;
        double atlag = 4.5;
        boolean aktiv = true;
        String nev = "Minta József";

        System.out.println(nev);
        System.out.println("Életkor: " + eletkor);
        System.out.println("Átlag: " + atlag);
        System.out.println("Aktív: " + aktiv);
    }
}

Feltételek és ciklusok

Egysoros leírás: az if eldönti, melyik ág fusson le, a ciklus pedig ismétlést végez.

public class Main {
    public static void main(String[] args) {
        int pont = 75;

        if (pont >= 50) {
            System.out.println("Sikeres");
        } else {
            System.out.println("Sikertelen");
        }

        for (int i = 1; i <= 5; i++) {
            System.out.println(i);
        }

        int szam = 1;

        while (szam <= 3) {
            System.out.println("While: " + szam);
            szam++;
        }
    }
}

ArrayList

Egysoros leírás: dinamikus lista, amelybe több azonos típusú elemet lehet felvenni és bejárni.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> nevek = new ArrayList<>();

        nevek.add("Anna");
        nevek.add("Béla");
        nevek.add("Cecil");

        System.out.println(nevek.get(0)); // Anna
        System.out.println(nevek.size()); // 3

        for (String nev : nevek) {
            System.out.println(nev);
        }

        nevek.remove("Béla");
    }
}

Gyakori metódusok:

lista.add(elem);      // hozzáadás
lista.get(index);     // elem lekérése index alapján
lista.set(index, uj); // elem módosítása
lista.remove(elem);   // elem törlése
lista.size();         // lista mérete
lista.clear();        // összes elem törlése

Rendezés ABC szerint és visszafelé:

import java.util.ArrayList;
import java.util.Collections;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> nevek = new ArrayList<>();

        nevek.add("Cecil");
        nevek.add("Anna");
        nevek.add("Béla");

        Collections.sort(nevek); // ABC szerint: Anna, Béla, Cecil
        System.out.println(nevek);

        Collections.sort(nevek, Collections.reverseOrder()); // visszafelé: Cecil, Béla, Anna
        System.out.println(nevek);
    }
}

Map

Egysoros leírás: kulcs-érték párokat tárol, például névhez pontszámot vagy azonosítóhoz objektumot.

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> pontok = new HashMap<>();

        pontok.put("Anna", 90);
        pontok.put("Béla", 75);
        pontok.put("Cecil", 82);

        System.out.println(pontok.get("Anna")); // 90
        System.out.println(pontok.containsKey("Béla")); // true

        for (String nev : pontok.keySet()) {
            System.out.println(nev + ": " + pontok.get(nev));
        }

        pontok.remove("Béla");
    }
}

Gyakori metódusok:

map.put(kulcs, ertek);      // hozzáadás vagy módosítás
map.get(kulcs);             // érték lekérése kulcs alapján
map.remove(kulcs);          // elem törlése
map.containsKey(kulcs);     // van-e ilyen kulcs
map.keySet();               // kulcsok bejárása
map.values();               // értékek bejárása
map.size();                 // elemek száma

Rendezés kulcs alapján ABC szerint és visszafelé:

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> pontok = new HashMap<>();

        pontok.put("Cecil", 82);
        pontok.put("Anna", 90);
        pontok.put("Béla", 75);

        Map<String, Integer> abcSzerint = new TreeMap<>(pontok);
        System.out.println(abcSzerint); // Anna, Béla, Cecil

        Map<String, Integer> visszafele = new TreeMap<>(Collections.reverseOrder());
        visszafele.putAll(pontok);
        System.out.println(visszafele); // Cecil, Béla, Anna
    }
}

Set

Egysoros leírás: olyan gyűjtemény, amelyben egy elem csak egyszer szerepelhet.

import java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<String> egyediNevek = new HashSet<>();

        egyediNevek.add("Anna");
        egyediNevek.add("Béla");
        egyediNevek.add("Anna");

        System.out.println(egyediNevek.size()); // 2
        System.out.println(egyediNevek.contains("Anna")); // true

        for (String nev : egyediNevek) {
            System.out.println(nev);
        }

        egyediNevek.remove("Béla");
    }
}

Gyakori metódusok:

set.add(elem);        // hozzáadás, ha még nincs benne
set.remove(elem);     // törlés
set.contains(elem);   // benne van-e
set.size();           // elemszám
set.clear();          // összes elem törlése

Rendezés ABC szerint és visszafelé:

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<String> nevekSet = new HashSet<>();

        nevekSet.add("Cecil");
        nevekSet.add("Anna");
        nevekSet.add("Béla");

        ArrayList<String> nevekLista = new ArrayList<>(nevekSet);

        Collections.sort(nevekLista); // ABC szerint: Anna, Béla, Cecil
        System.out.println(nevekLista);

        Collections.sort(nevekLista, Collections.reverseOrder()); // visszafelé: Cecil, Béla, Anna
        System.out.println(nevekLista);
    }
}

Interface

public interface Titkosithato {
    String titkosit(String szoveg, int eltolas);
    String visszafejt(String szoveg, int eltolas);
}

Implementáció:

public class CaesarTitkosito implements Titkosithato {
    @Override
    public String titkosit(String szoveg, int eltolas) {
        return asciiEltolas(szoveg, eltolas);
    }

    @Override
    public String visszafejt(String szoveg, int eltolas) {
        return asciiEltolas(szoveg, -eltolas);
    }

    private String asciiEltolas(String szoveg, int eltolas) {
        StringBuilder eredmeny = new StringBuilder();

        for (int i = 0; i < szoveg.length(); i++) {
            char karakter = szoveg.charAt(i);
            char eltoltKarakter = (char) (karakter + eltolas);
            eredmeny.append(eltoltKarakter);
        }

        return eredmeny.toString();
    }
}

ASCII karaktereltolás

Egyszerű függvény:

public static String asciiEltolas(String szoveg, int eltolas) {
    StringBuilder eredmeny = new StringBuilder();

    for (int i = 0; i < szoveg.length(); i++) {
        char karakter = szoveg.charAt(i);
        eredmeny.append((char) (karakter + eltolas));
    }

    return eredmeny.toString();
}

Használat:

public class Main {
    public static void main(String[] args) {
        String eredeti = "ABC";
        String titkositott = asciiEltolas(eredeti, 2);
        String visszafejtett = asciiEltolas(titkositott, -2);

        System.out.println(eredeti);       // ABC
        System.out.println(titkositott);   // CDE
        System.out.println(visszafejtett); // ABC
    }

    public static String asciiEltolas(String szoveg, int eltolas) {
        StringBuilder eredmeny = new StringBuilder();

        for (int i = 0; i < szoveg.length(); i++) {
            char karakter = szoveg.charAt(i);
            eredmeny.append((char) (karakter + eltolas));
        }

        return eredmeny.toString();
    }
}

Fájlbeolvasás BufferedReaderrel

FileReader + BufferedReader:

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class FajlBeolvasas {
    public static void main(String[] args) {
        String fajlNev = "adatok.txt";

        try (BufferedReader br = new BufferedReader(new FileReader(fajlNev))) {
            String sor;

            while ((sor = br.readLine()) != null) {
                System.out.println(sor);
            }
        } catch (IOException e) {
            System.out.println("Hiba történt a fájl beolvasása közben: " + e.getMessage());
        }
    }
}

Ha objektumlistába kell feldolgozni, például pontosvesszővel tagolt sorból:

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

public class TermekBeolvasas {
    public static void main(String[] args) {
        ArrayList<Termek> termekek = new ArrayList<>();

        try (BufferedReader br = new BufferedReader(new FileReader("termekek.txt"))) {
            String sor;

            while ((sor = br.readLine()) != null) {
                String[] adatok = sor.split(";");

                String nev = adatok[0];
                int ar = Integer.parseInt(adatok[1]);

                termekek.add(new Termek(nev, ar));
            }
        } catch (IOException e) {
            System.out.println("Fájl hiba: " + e.getMessage());
        }

        for (Termek termek : termekek) {
            System.out.println(termek);
        }
    }
}

class Termek {
    private String nev;
    private int ar;

    public Termek(String nev, int ar) {
        this.nev = nev;
        this.ar = ar;
    }

    @Override
    public String toString() {
        return nev + " - " + ar + " Ft";
    }
}

Published

Vulnerabilities

Links

Maintainers

Keywords

Readme

Globális vizsga segédlet

Tartalomjegyzék

React Context

Context létrehozása

Provider implementálása teljes értékkel

Provider bekötése

Context használata komponensben

Laravel backend

Alap parancsok

Modellek és migrationök

Hardcodeolt adatok migrationben

Seeder

Factory

Model kapcsolatok

API controller

API route

Java alapminták

Alap adattípusok és kiírás

Feltételek és ciklusok

ArrayList

Map

Set

Interface

ASCII karaktereltolás

Fájlbeolvasás BufferedReaderrel