2025 m. Turkijoje vis dar labiausiai pageidaujamas Python framework'as: Django 5

Savybės

• Django 5.1 + Python 3.12
• Vartotojų registracija/prisijungimas/slaptžodžio atstatymas (django-allauth)
• Profesionali Django Admin (Ne Filament, originalus admin!)
• Markdown redaktorius (EasyMDE)
• Tailwind CSS + DaisyUI
• PostgreSQL + Docker
• Nemokamas deploy į Railway.app
• SEO draugiški URL + sitemap + RSS

1. Projekto Nustatymas (2025 greičiausias metodas)

pip install django==5.1
django-admin startproject blogproject
cd blogproject
python manage.py startapp blog
Su Docker (rekomenduojama):

curl -SSL https://raw.githubusercontent.com/django/django/main/django/bin/dja # Arba tiesiogiai: django-admin startproject blogproject .


2. Būtini Paketai

pip install psycopg2-binary django-allauth django-tailwind django-crispy-form

3. settings.py – 2025 Geriausi Nustatymai (sutrumpinti)

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sites',
    'django.contrib.sites',
    'django.contrib.sites',
    'django.contrib.sites',
    'django.contrib.sites',
    'allauth',
    'allauth.account',
    'allauth.socialaccount',
    'tailwind',
    'theme',  # mūsų app
    'crispy_forms',
    'crispy_tailwind',
    'blog',
]

# Tailwind app
TAILWIND_APP_NAME = 'theme'

# Allauth
SITE_ID = 1
LOGIN_REDIRECT_URL = '/'
ACCOUNT_LOGOUT_REDIRECT_URL = '/'
ACCOUNT_AUTHENTICATION_METHOD = 'email'
ACCOUNT_EMAIL_REQUIRED = True
ACCOUNT_UNIQUE_EMAIL = True
ACCOUNT_USERNAME_REQUIRED = False

# Crispy
CRISPY_ALLOWED_TEMPLATE_PACKS = "tailwind"
CRISPY_TEMPLATE_PACK = "tailwind"

4. Blog Modelis (blog/models.py)

from django.db import models
from django.contrib.auth.models import User
from django.urls import reverse

class Post(models.Model):
    title = models.CharField(max_length=200)
    slug = models.SlugField(unique=True, max_length=200)
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    is_published = models.BooleanField(default=True)
    tags = models.CharField(max_length=200, blank=True)

    class Meta:
        ordering = ['-created_at']

    def __str__(self):
        return self.title

    def get_absolute_url(self):
        return reverse('post_detail', kwargs={'slug': self.slug})

5. Markdown Redaktorius (admin.py)

from django.contrib import admin
from django import forms
from easymde.fields import EasyMDEField
from .models import Post

class PostAdminForm(forms.ModelForm):
    content = EasyMDEField()

    class Meta:
        model = Post
        fields = '__all__'

@admin.register(Post)
class PostAdmin(admin.ModelAdmin):
    form = PostAdminForm
    prepopulated_fields = {"slug": ("title",)}
    list_display = ('title', 'author', 'created_at', 'is_published')
    search_fields = ('title', 'content')
    list_filter = ('is_published', 'created_at')

6. Pagrindinis Puslapis (blog/views.py)

from django.views.generic import ListView, DetailView
from .models import Post

class HomeView(ListView):
    model = Post
    template_name = 'blog/home.html'
    context_object_name = 'posts'
    paginate_by = 10

    def get_queryset(self):
        return Post.objects.filter(is_published=True)

7. Šablonas – home.html (Tailwind + DaisyUI)

{% extends "base.html" %}
{% load static %}
{% block content %}
<div class="max-w-4xl mx-auto px-6 py-12">
    <h1 class="text-5xl font-bold text-center mb-12 text-primary">2025 Django Bootcamp</h1>
    <div class="grid gap-8">
        {% for post in posts %}
        <article class="card bg-base-100 shadow-xl hover:shadow-2xl transition">
            <div class="card-body">
                <h2 class="card-title text-2xl">
                    <a href="{{ post.get_absolute_url }}" class="hover:text-primary">
                        {{ post.title }}
                    </a>
                </h2>
                <div class="flex gap-4 text-sm text-gray-500 mb-4">
                    <span>{{ post.author }}</span>
                    <span>{{ post.created_at|date:"d F Y" }}</span>
                </div>
                <p class="text-gray-700">
                    {{ post.content|truncatewords_html:50|safe }}
                </p>
                <div class="card-actions justify-end mt-6">
                    <a href="{{ post.get_absolute_url }}" class="btn btn-primary">Tęsti</a>
                </div>
            </div>
        </article>
        {% empty %}
        <p class="text-center text-xl">Dar nėra įrašų.</p>
        {% endfor %}
    </div>
    <!-- Puslapiavimas -->
    {% if is_paginated %}
    <div class="flex justify-center mt-12">
        <div class="join">
            {% if page_obj.has_previous %}
            <a href="?page={{ page_obj.previous_page_number }}" class="join-item btn">Ankstesnis</a>
            {% endif %}
            <span class="join-item btn btn-ghost">Puslapis {{ page_obj.number }} / {{ page_obj.paginator.num_pages }}</span>
            {% if page_obj.has_next %}
            <a href="?page={{ page_obj.next_page_number }}" class="join-item btn">Kitas</a>
            {% endif %}
        </div>
    </div>
    {% endif %}
</div>
{% endblock %}

8. Dockerfile

FROM python:3.12-slim
ENV PYTHONDONTWRITEBYTECODE=1
ENV PYTHONUNBUFFERED=1
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY .
CMD ["gunicorn", "blogproject.wsgi:application", "--bind", "0.0.0.0:8000"]

9. Nemokamas Deploy į Railway.app

• Sukurti GitHub repozitoriją
• railway.app → New Project → Prijungti GitHub repo
• Kintamieji → DATABASE_URL (Railway automatiškai suteikia PostgreSQL)
• Deploy → https://django-blog-2025.up.railway.app

Rezultatas – 2025 Turkijos Django Standartas
Šis projektas:

• Admin panelėje pridėti įrašą per 1 minutę
• Registracija/prisijungimas/slaptžodžio atstatymas paruošta
• Mobilusis suderinamumas + modernus dizainas
• SEO draugiškas (sitemap + meta tag)
• Nemokamas hostingas (Railway)

Pilnas šaltinio kodas (veikiantis):
https://github.com/kullanicin/django-blog-2025

Gyvas demo:
https://django-blog-2025.up.railway.app

Python programavimo kalboje while ciklas yra viena iš pagrindinių valdymo struktūrų, leidžiančių kartoti kodą tol, kol tenkinama tam tikra sąlyga. Šiame straipsnyje aptarsime while ciklo veikimo principus, pateiksime praktinius kodų pavyzdžius ir atsakysime į dažniausiai užduodamus klausimus (FAQs). Mūsų tikslas – padėti pradedantiesiems ir patyrusiems kūrėjams geriau suprasti šią struktūrą.

---

1. Kas yra While Ciklas?
While ciklas vykdo kodo bloką tol, kol nurodyta sąlyga yra teisinga (True). Kai sąlyga tampa neteisinga (False), ciklas sustoja, ir programa tęsiasi su kitu kodu.

Sintaksė:
while sąlyga:
    # Kodas, kuris bus vykdomas

• Sąlyga: Loginė išraiška, tikrinama prieš kiekvieną ciklo iteraciją.
• Kodo blokas: Instrukcijos, kurios kartojamos, kol sąlyga teisinga.

---

2. Pagrindiniai While Ciklo Pavyzdžiai
2.1. Skaičių Spausdinimas nuo 1 iki 5
Šis pavyzdys rodo, kaip while ciklas gali būti naudojamas spausdinti skaičius tam tikrame intervale.
skaičius = 1
while skaičius <= 5:
    print(skaičius)
    skaičius += 1
Išvestis:
1
2
3
4
5
Paaiškinimas:

• skaičius pradeda nuo 1.
• Kol skaičius <= 5 yra True, ciklas spausdina skaičius ir padidina jį vienetu.
• Kai skaičius tampa 6, sąlyga tampa False, ir ciklas sustoja.

---

2.2. Vartotojo Įvesties Tikrinimas
While ciklas puikiai tinka situacijoms, kai reikia kartoti veiksmą, kol vartotojas pateiks tinkamą įvestį.
slaptažodis = ""
while slaptažodis != "saugus123":
    slaptažodis = input("Įveskite slaptažodį: ")
    if slaptažodis != "saugus123":
        print("Neteisingas slaptažodis, bandykite dar kartą!")
print("Prisijungta sėkmingai!")
Išvestis (pvz.):
Įveskite slaptažodį: testas
Neteisingas slaptažodis, bandykite dar kartą!
Įveskite slaptažodį: saugus123
Prisijungta sėkmingai!
Paaiškinimas:

• Ciklas tęsiasi, kol vartotojas neįveda teisingo slaptažodžio.
• Kai įvestas slaptažodis sutampa su ,,saugus123", ciklas baigiasi.

---

2.3. Begalinis Ciklas su Break
Kartais reikia sukurti ciklą, kuris veikia tol, kol įvykdoma tam tikra sąlyga, naudojant break.
while True:
    atsakymas = input("Ar norite tęsti? (taip/ne): ")
    if atsakymas.lower() == "ne":
        print("Programa baigta.")
        break
    print("Tęsiame...")
Išvestis (pvz.):
Ar norite tęsti? (taip/ne): taip
Tęsiame...
Ar norite tęsti? (taip/ne): ne
Programa baigta.
Paaiškinimas:

• while True sukuria begalinį ciklą.
• break nutraukia ciklą, kai vartotojas įveda ,,ne".

---

3. Papildomos While Ciklo Funkcijos
3.1. Continue Naudojimas
continue leidžia praleisti likusią ciklo iteraciją ir pereiti prie kitos.
skaičius = 0
while skaičius < 10:
    skaičius += 1
    if skaičius % 2 == 0:  # Praleidžiame lyginius skaičius
        continue
    print(f"Nelyginis skaičius: {skaičius}")
Išvestis:
Nelyginis skaičius: 1
Nelyginis skaičius: 3
Nelyginis skaičius: 5
Nelyginis skaičius: 7
Nelyginis skaičius: 9
Paaiškinimas:

• Jei skaičius yra lyginis, continue praleidžia print ir grįžta prie kitos iteracijos.

---

3.2. Else su While
else blokas vykdomas, kai ciklas baigiasi natūraliai (ne dėl break).
skaičius = 1
while skaičius <= 3:
    print(f"Skaičius: {skaičius}")
    skaičius += 1
else:
    print("Ciklas baigtas!")
Išvestis:
Skaičius: 1
Skaičius: 2
Skaičius: 3
Ciklas baigtas!
Paaiškinimas:

• else blokas įvykdomas, kai sąlyga skaičius <= 3 tampa False.

---

4. Dažniausios Klaidų Priežastys

• Begalinis ciklas: Jei sąlyga niekada netampa False, ciklas veiks amžinai. Visada įsitikinkite, kad yra būdas išeiti iš ciklo.
• Netinkamas kintamųjų keitimas: Neužmirškite atnaujinti kintamųjų, kurie kontroliuoja ciklo sąlygą.
• Per sudėtingos sąlygos: Stenkitės, kad sąlygos būtų aiškios ir lengvai suprantamos.

---

5. Kodų Pavyzdys: Skaičių Suma
Šis pavyzdys apskaičiuoja vartotojo įvestų skaičių sumą, kol įvedamas 0.
suma = 0
while True:
    įvestis = input("Įveskite skaičių (0 baigia): ")
    try:
        skaičius = int(įvestis)
        if skaičius == 0:
            break
        suma += skaičius
    except ValueError:
        print("Prašome įvesti skaičių!")
print(f"Bendra suma: {suma}")
Išvestis (pvz.):
Įveskite skaičių (0 baigia): 5
Įveskite skaičių (0 baigia): 10
Įveskite skaičių (0 baigia): abc
Prašome įvesti skaičių!
Įveskite skaičių (0 baigia): 0
Bendra suma: 15
Paaiškinimas:

• Ciklas prašo įvesti skaičius, kol įvedamas 0.
• try-except apsaugo nuo neteisingos įvesties (pvz., raidžių).

---

Dažniausiai Užduodami Klausimai (FAQs)
K: Kuo while skiriasi nuo for ciklo?
A: While ciklas tinka, kai nežinote iteracijų skaičiaus ir remiatės sąlyga. For ciklas dažniausiai naudojamas, kai iteruojate per žinomą seką (pvz., sąrašą ar intervalą).

K: Kaip išvengti begalinio ciklo?
A: Įsitikinkite, kad ciklo sąlyga kada nors taps False, ir reguliariai atnaujinkite susijusius kintamuosius. Taip pat galite naudoti break avarinėms situacijoms.

K: Ar else blokas su while yra būtinas?
A: Ne, jis nėra būtinas. Jis naudojamas tik tada, kai norite atlikti veiksmą, kai ciklas baigiasi natūraliai.

K: Kada naudoti continue?
A: Naudokite continue, kai norite praleisti tam tikrą iteraciją, bet tęsti ciklą (pvz., praleisti netinkamus duomenis).

K: Ar while True yra bloga praktika?
A: Ne, jei turite aiškų būdą nutraukti ciklą (pvz., su break). Tačiau būkite atsargūs, kad išvengtumėte netyčinio begalinio ciklo.

---

Išvada
Python while ciklas yra galinga ir lanksti priemonė, tinkanti įvairioms užduotims – nuo paprastų skaičiavimų iki vartotojo įvesties valdymo. Svarbu suprasti, kaip tinkamai struktūrizuoti ciklą, naudoti break, continue ir else, taip pat vengti dažnų klaidų, tokių kaip begaliniai ciklai. Praktikuodami šiuos pavyzdžius, galėsite efektyviai naudoti while ciklą savo projektuose.

PHP yra viena populiariausių interneto svetainių kūrimo kalbų, tačiau netinkamas jos naudojimas gali sukelti rimtų saugumo problemų. Šiame straipsnyje aptarsime pagrindines PHP saugumo priemones, pateiksime praktinius kodų pavyzdžius ir atsakysime į dažniausiai užduodamus klausimus (FAQs). Mūsų tikslas – padėti kūrėjams kurti saugesnes programas.

---

1. Įvesties Duomenų Validacija ir Filtravimas
Vartotojų pateikiami duomenys (pvz., formų laukeliai, URL parametrai) yra dažna saugumo spragų priežastis. Norint apsisaugoti, būtina validuoti ir filtruoti visus įvesties duomenis.

Pagrindiniai Principai:

• Validacija: Patikrinkite, ar duomenys atitinka numatytą formatą (pvz., el. pašto adresas, skaičius).
• Filtravimas: Pašalinkite arba neutralizuokite pavojingus simbolius.

Kodų Pavyzdys:
<?php
// Vartotojo vardo validacija
$username = $_POST['username'] ?? '';

if (!preg_match('/^[a-zA-Z0-9]{3,20}$/', $username)) {
   die('Netinkamas vartotojo vardas! Naudokite tik raides ir skaičius, 3-20 simbolių.');
}

// El. pašto filtravimas
$email = filter_var($_POST['email'] ?? '', FILTER_SANITIZE_EMAIL);
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
   die('Netinkamas el. pašto formatas!');
}

echo "Duomenys sėkmingai apdoroti: $username, $email";
?>
Patarimai:

• Naudokite filter_var() ir reguliariąsias išraiškas (preg_match).
• Venkite tiesioginio $_GET ar $_POST naudojimo be patikrinimo.

---

2. Apsauga nuo SQL Injekcijų
SQL injekcijos įvyksta, kai užpuolikas per formą įterpia kenksmingą SQL kodą. Tai gali leisti pavogti, pakeisti ar ištrinti duomenis iš duomenų bazės.

Sprendimas: Paruošti Užklausos (Prepared Statements)
Paruoštos užklausos (angl. prepared statements) atskiria SQL kodą nuo vartotojo duomenų, todėl injekcijos tampa neįmanomos.

Kodų Pavyzdys:
<?php
try {
   $pdo = new PDO("mysql:host=localhost;dbname=test", "root", "");
   $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

   // Paruošta užklausa
   $stmt = $pdo->prepare("SELECT * FROM users WHERE username = :username AND email = :email");
   $stmt->execute([
       'username' => $_POST['username'] ?? '',
       'email' => $_POST['email'] ?? ''
   ]);

   $user = $stmt->fetch(PDO::FETCH_ASSOC);
   if ($user) {
       echo "Vartotojas rastas!";
   } else {
       echo "Vartotojas nerastas.";
   }
} catch (PDOException $e) {
   die("Klaida: " . $e->getMessage());
}
?>
Patarimai:

• Visada naudokite PDO arba MySQLi su paruoštomis užklausomis.
• Venkite seno mysql_* funkcijų rinkinio – jis pasenęs ir nesaugus.

---

3. Apsauga nuo XSS (Cross-Site Scripting)
XSS leidžia užpuolikui įterpti kenksmingą JavaScript kodą į svetainę, kuris gali būti vykdomas kitų vartotojų naršyklėse.

Sprendimas: Duomenų Kodavimas ir Escaping
Visada koduokite (angl. escape) išvesties duomenis, kad jie būtų rodomi kaip tekstas, o ne vykdomas kodas.

Kodų Pavyzdys:
<?php
$comment = $_POST['comment'] ?? '';

// Komentaro kodavimas prieš rodant
$safeComment = htmlspecialchars($comment, ENT_QUOTES, 'UTF-8');

echo "<div>Komentaras: $safeComment</div>";
?>
Patarimai:

• Naudokite htmlspecialchars() visada, kai rodote vartotojo įvestus duomenis.
• Jei leidžiate HTML turinį, naudokite bibliotekas, pvz., HTMLPurifier, kad pašalintumėte kenksmingą kodą.

---

4. CSRF (Cross-Site Request Forgery) Apsauga
CSRF ataka verčia vartotoją atlikti nepageidaujamus veiksmus (pvz., pakeisti slaptažodį), jei jis jau yra prisijungęs.

Sprendimas: CSRF Žetonai
Kiekvienai formai pridėkite unikalų žetoną, kuris patikrina, ar užklausa yra teisėta.

Kodų Pavyzdys:
<?php
session_start();

// Sukuriame CSRF žetoną
if (empty($_SESSION['csrf_token'])) {
   $_SESSION['csrf_token'] = bin2hex(random_bytes(32));
}
?>

<form method="POST" action="process.php">
    <input type="hidden" name="csrf_token" value="<?php echo $_SESSION['csrf_token']; ?>">
    <input type="text" name="username" placeholder="Vartotojo vardas">
    <button type="submit">Siųsti</button>
</form>

<?php
// process.php
session_start();

if ($_POST['csrf_token'] !== $_SESSION['csrf_token']) {
   die('Netinkamas CSRF žetonas!');
}

// Toliau apdorojame formą...
?>
Patarimai:

• Naudokite random_bytes() žetonų generavimui.
• Atnaujinkite žetoną po kiekvienos sėkmingos užklausos.

---

5. Saugus Failų Įkėlimas
Failų įkėlimas gali būti pavojingas, jei užpuolikas įkelia kenksmingą kodą (pvz., PHP skriptą).

Pagrindiniai Principai:

• Tikrinkite failų tipą ir dydį.
• Perkelkite failus į saugią direktoriją už viešosios prieigos ribų.
• Pakeiskite failų pavadinimus.

Kodų Pavyzdys:
<?php
$uploadDir = 'uploads/';
$allowedTypes = ['image/jpeg', 'image/png'];

if ($_FILES['userfile']['error'] === UPLOAD_ERR_OK) {
   $fileType = mime_content_type($_FILES['userfile']['tmp_name']);
   if (!in_array($fileType, $allowedTypes)) {
       die('Netinkamas failo formatas! Leidžiami tik JPG ir PNG.');
   }

   // Generuojame unikalų failo pavadinimą
   $newFileName = uniqid() . '.png';
   $destination = $uploadDir . $newFileName;

   if (move_uploaded_file($_FILES['userfile']['tmp_name'], $destination)) {
       echo "Failas sėkmingai įkeltas!";
   } else {
       echo "Klaida įkeliant failą.";
   }
} else {
   echo "Failo įkėlimo klaida.";
}
?>
Patarimai:

• Naudokite mime_content_type() failo tipo patikrinimui.
• Apribokite failų dydį per php.ini (upload_max_filesize).

---

6. Slaptažodžių Saugojimas
Niekada nesaugokite slaptažodžių grynu tekstu. Naudokite stiprius maišos algoritmus.

Kodų Pavyzdys:
<?php
$password = $_POST['password'] ?? '';

// Slaptažodžio maiša
$hashedPassword = password_hash($password, PASSWORD_BCRYPT);

// Patikrinimas
if (password_verify($password, $hashedPassword)) {
   echo "Slaptažodis teisingas!";
} else {
   echo "Slaptažodis neteisingas.";
}
?>
Patarimai:

• Naudokite password_hash() ir password_verify().
• BCRYPT yra numatytasis algoritmas, kuris reguliariai atnaujinamas.

---

Dažniausiai Užduodami Klausimai (FAQs)
K: Kodėl svarbu validuoti įvesties duomenis?
A: Nevaliduoti duomenys gali leisti užpuolikui įterpti kenksmingą kodą, pvz., SQL injekcijas ar XSS atakas.

K: Ar PDO visiškai apsaugo nuo SQL injekcijų?
A: Taip, jei naudojate paruoštas užklausas teisingai. Tačiau visada tikrinkite kitus įvesties šaltinius.

K: Kaip dažnai turėčiau atnaujinti CSRF žetoną?
A: Geriausia atnaujinti po kiekvienos sėkmingos formos pateikimo, kad sumažintumėte pakartotinio naudojimo riziką.

K: Ar htmlspecialchars() pakanka XSS apsaugai?
A: Paprastais atvejais taip, bet jei leidžiate HTML turinį, naudokite papildomas bibliotekas, pvz., HTMLPurifier.

K: Kaip apsaugoti PHP sesijas?
A: Naudokite session_regenerate_id() po prisijungimo, įjunkite session.use_strict_mode ir nustatykite saugius slapukus (HttpOnly, Secure).

---

Išvada
PHP saugumo užtikrinimas reikalauja nuolatinio dėmesio ir gerų praktikų taikymo. Validuokite ir filtruokite įvesties duomenis, naudokite paruoštas užklausas, koduokite išvestį, apsaugokite formas ir failų įkėlimą, taip pat saugiai laikykite slaptažodžius. Laikydamiesi šių principų, galite žymiai sumažinti savo programos pažeidžiamumą.

Flutter yra populiarus Google sukurtas įrankis, skirtas kurti gražias ir funkcionalias mobiliąsias programas. Vienas iš pagrindinių Flutter privalumų – lengvas darbas su JSON duomenimis ir API integracija. Šiame straipsnyje aptarsime, kas yra JSON ir API, kaip juos naudoti Flutter projektuose, ir pateiksime praktinius pavyzdžius. Turinys pritaikytas SEO reikalavimams ir orientuotas į raktinius žodžius, tokius kaip ,,Flutter JSON", ,,Flutter API integracija" ir ,,Flutter kodų pavyzdžiai".

---

Kas yra JSON ir API?

• JSON (JavaScript Object Notation): Lengvas duomenų formatas, naudojamas struktūrizuotai informacijai perduoti tarp serverio ir kliento. JSON yra lengvai skaitomas ir dažnai naudojamas API atsakymams.
• API (Application Programming Interface): Sąsaja, leidžianti programoms bendrauti tarpusavyje. Flutter programoje API dažniausiai naudojamas duomenims iš serverio gauti ar siųsti.

---

Flutter ir JSON: Kaip Tai Veikia?
Flutter programoje JSON duomenys dažniausiai gaunami iš API ir paverčiami Dart objektais. Tam naudojama dart:convert biblioteka ir http paketas API užklausoms.

1 žingsnis: Priklausomybės pridėjimas
Failo pubspec.yaml pridėkite šią eilutę:

dependencies:
  http: ^1.1.0
2 žingsnis: Paprastas JSON Apdorojimas
Tarkime, turime JSON struktūrą:

{
  "id": 1,
  "vardas": "Jonas",
  "amžius": 30
}
Pavyzdys, kaip ją apdoroti Flutter programoje:

import 'dart:convert';
import 'package:http/http.dart' as http;

void main() async {
  final url = Uri.parse('https://api.example.com/vartotojas');
  final atsakymas = await http.get(url);
 
  if (atsakymas.statusCode == 200) {
    final jsonDuomenys = jsonDecode(atsakymas.body);
    print('Vardas: ${jsonDuomenys['vardas']}'); // Rezultatas: Vardas: Jonas
    print('Amžius: ${jsonDuomenys['amžius']}'); // Rezultatas: Amžius: 30
  } else {
    print('Klaida: ${atsakymas.statusCode}');
  }
}
Šiame pavyzdyje jsonDecode paverčia JSON eilutę į Dart Map objektą.

---

API Integracija Flutter Programoje
Norint dirbti su API, reikia atlikti šiuos veiksmus:

• Sukurti modelį duomenims struktūrizuoti.
• Gauti duomenis iš API.
• Atvaizduoti juos vartotojo sąsajoje.

Pavyzdys: API Duomenų Gavimas ir Atvaizdavimas
Tarkime, API grąžina vartotojų sąrašą:

[
  {"id": 1, "vardas": "Jonas", "amžius": 30},
  {"id": 2, "vardas": "Rasa", "amžius": 25}
]
1. Modelio Klasė

class Vartotojas {
  final int id;
  final String vardas;
  final int amzius;

  Vartotojas({required this.id, required this.vardas, required this.amzius});

  factory Vartotojas.isJson(Map<String, dynamic> json) {
    return Vartotojas(
      id: json['id'],
      vardas: json['vardas'],
      amzius: json['amžius'],
    );
  }
}
2. API Užklausa

import 'dart:convert';
import 'package:http/http.dart' as http;

Future<List<Vartotojas>> gautiVartotojus() async {
  final url = Uri.parse('https://api.example.com/vartotojai');
  final atsakymas = await http.get(url);

  if (atsakymas.statusCode == 200) {
    List jsonDuomenys = jsonDecode(atsakymas.body);
    return jsonDuomenys.map((json) => Vartotojas.isJson(json)).toList();
  } else {
    throw Exception('Nepavyko gauti duomenų');
  }
}
3. Duomenų Atvaizdavimas

import 'package:flutter/material.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: VartotojuSarasas(),
    );
  }
}

class VartotojuSarasas extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('Vartotojų Sąrašas')),
      body: FutureBuilder<List<Vartotojas>>(
        future: gautiVartotojus(),
        builder: (context, snapshot) {
          if (snapshot.hasData) {
            return ListView.builder(
              itemCount: snapshot.data!.length,
              itemBuilder: (context, index) {
                final vartotojas = snapshot.data![index];
                return ListTile(
                  title: Text(vartotojas.vardas),
                  subtitle: Text('Amžius: ${vartotojas.amzius}'),
                );
              },
            );
          } else if (snapshot.hasError) {
            return Text('Klaida: ${snapshot.error}');
          }
          return CircularProgressIndicator();
        },
      ),
    );
  }
}
Šiame pavyzdyje FutureBuilder naudojamas duomenų gavimui ir atvaizdavimui realiuoju laiku.

---

Kodėl JSON ir API Svarbūs Flutter?

• Dinamiškumas: API leidžia gauti naujausius duomenis iš serverio.
• Struktūra: JSON palengvina sudėtingų duomenų apdorojimą.
• Universalumas: Šie įrankiai veikia su dauguma šiuolaikinių technologijų.

---

Išvada
Flutter darbas su JSON ir API yra esminė įgūdis kuriant funkcionalias programas. Naudodami pateiktus pavyzdžius, galite lengvai integruoti išorinius duomenis į savo Flutter projektus. Jei norite daugiau informacijos ar sudėtingesnių pavyzdžių, klauskite!

Golang (arba Go) yra moderni programavimo kalba, kuri išsiskiria savo paprastumu ir galingu konkurencingumo (angl. concurrency) mechanizmu. Šiame straipsnyje aptarsime Golang konkurencingumo logiką, kaip ji veikia, ir pateiksime praktinius pavyzdžius. Turinys yra pritaikytas SEO reikalavimams ir orientuotas į tokius raktinius žodžius kaip ,,Golang concurrency", ,,Go goroutines" ar ,,Golang kanalai".

---

Kas yra Concurrency Golang Kalboje?
Konkurencingumas Golang kalboje leidžia vykdyti kelias užduotis vienu metu, efektyviai išnaudojant procesoriaus resursus. Skirtingai nei tradicinis daugiagijis programavimas (angl. multithreading), Golang naudoja goroutines ir kanalus (angl. channels), kad supaprastintų lygiagrečių procesų valdymą.

• Goroutines: Lengvos gijos, kurios veikia nepriklausomai.
• Kanalai: Mechanizmas, skirtas duomenų mainams tarp goroutines.

---

Goroutines: Kaip Jie Veikia?
Goroutine yra funkcija, kuri vykdoma lygiagrečiai su kitomis programos dalimis. Jos kuriamos naudojant raktinį žodį go.

Pavyzdys 1: Paprasta Goroutine

package main

import "fmt"

func spausdintiTeksta(tekstas string) {
    for i := 0; i < 3; i++ {
        fmt.Println(tekstas)
    }
}

func main() {
    go spausdintiTeksta("Goroutine veikia!") // Paleidžiama kaip goroutine
    spausdintiTeksta("Pagrindinė funkcija")   // Vykdoma pagrindinėje gijoje
}
Šiame pavyzdyje go spausdintiTeksta paleidžia funkciją kaip goroutine, o pagrindinė programa tęsiasi. Pastaba: rezultatai gali būti nenuspėjami, nes goroutine vykdymo tvarka nėra garantuota.

---

Kanalai: Duomenų Sinchronizacija
Kanalai (angl. channels) leidžia goroutines keistis duomenimis ir sinchronizuoti jų veikimą. Jie kuriami su make(chan tipas).

Pavyzdys 2: Kanalo Naudojimas

package main

import "fmt"

func siustiDuomenis(kanalas chan int) {
    kanalas <- 42 // Siunčiamas skaičius į kanalą
}

func main() {
    kanalas := make(chan int) // Sukuriamas kanalas
    go siustiDuomenis(kanalas)
    skaicius := <-kanalas // Gaunami duomenys iš kanalo
    fmt.Println("Gautas skaičius:", skaicius) // Rezultatas: Gautas skaičius: 42
}
Čia <- operatorius naudojamas duomenų siuntimui ir gavimui. Kanalai užtikrina, kad viena goroutine lauktų, kol kita perduos duomenis.

---

WaitGroup: Goroutines Sinchronizacija
Norint palaukti, kol visos goroutines baigs darbą, naudojamas sync.WaitGroup.

Pavyzdys 3: WaitGroup Naudojimas

package main

import (
    "fmt"
    "sync"
)

func vykdytiUžduotį(id int, wg *sync.WaitGroup) {
    defer wg.Done() // Signalizuoja, kad goroutine baigė darbą
    fmt.Printf("Užduotis %d atlikta\n", id)
}

func main() {
    var wg sync.WaitGroup
    for i := 1; i <= 3; i++ {
        wg.Add(1) // Pridedama užduotis
        go vykdytiUžduotį(i, &wg)
    }
    wg.Wait() // Laukiama, kol visos užduotys baigsis
    fmt.Println("Visos užduotys atliktos!")
}
Rezultatas gali būti:

Užduotis 2 atlikta
Užduotis 1 atlikta
Užduotis 3 atlikta
Visos užduotys atliktos!

---

Kodėl Golang Concurrency Yra Efektyvus?

• Lengvos Goroutines: Jos naudoja mažiau atminties nei tradicinės gijos.
• Paprastas Sinchronizavimas: Kanalai pašalina sudėtingus užraktus (angl. locks).
• Galingumas: Go runtime efektyviai paskirsto užduotis tarp procesoriaus branduolių.

---

Praktinis Pavyzdys: Lygiagretus Skaičiavimas
Tarkime, norime apskaičiuoti kelių skaičių kvadratus lygiagrečiai:

package main

import "fmt"

func kvadratas(skaicius int, kanalas chan int) {
    rezultatas := skaicius * skaicius
    kanalas <- rezultatas
}

func main() {
    skaiciai := []int{2, 4, 6, 8}
    kanalas := make(chan int)

    for _, sk := range skaiciai {
        go kvadratas(sk, kanalas)
    }

    for i := 0; i < len(skaiciai); i++ {
        fmt.Println("Kvadratas:", <-kanalas)
    }
}
Rezultatas gali būti:

Kvadratas: 4
Kvadratas: 16
Kvadratas: 36
Kvadratas: 64

---

Išvada
Golang konkurencingumo logika, paremta goroutines ir kanalais, yra paprasta, bet itin galinga. Šie mechanizmai leidžia lengvai kurti efektyvias ir lygiagrečias programas. Naudodami pateiktus pavyzdžius, galite pradėti eksperimentuoti su Golang concurrency savo projektuose. Jei turite klausimų ar reikia daugiau pavyzdžių, klauskite!