Seriya: Axios Dars 92

Upload Progress — onUploadProgress orqali upload progress kuzatish

Axios onUploadProgress xususiyati orqali fayl yuklanish jarayonini kuzatish: AxiosProgressEvent (loaded, total), foizni hisoblash, undefined total holatlari va UI throttling.

92-dars

Upload Progress — onUploadProgress orqali upload progress kuzatish

Foydalanuvchi serverga katta hajmli video, arxiv (ZIP) yoki yuqori sifatli rasm yuklayotganda sahifaning qotib qolgandek jim turishi yomon foydalanuvchi tajribasiga (bad UX) sabab bo'ladi. Foydalanuvchi so'rov ketayotganini yoki qotib qolganini tushunmay, sahifani yangilab yuborishi mumkin.

Axios brauzerning ichki XMLHttpRequest.upload.onprogress hodisasiga tayangan holda, faylning qancha qismi serverga yetib borganini millisekundlik aniqlikda kuzatib borish va uni real vaqtda Progress Bar orqali ko'rsatish uchun qulay interfeys taqdim etadi.


1. onUploadProgress qanday ishlaydi?

Axios konfiguratsiyasida onUploadProgress nomli maxsus parametr mavjud. Bu funksiya har safar tarmoq orqali serverga ma'lum bir qism (chunk) ma'lumot jo'natilganda avtomatik ravishda chaqiriladi va argument sifatida AxiosProgressEvent obyektini qabul qiladi.

sequenceDiagram
    autonumber
    actor User as Foydalanuvchi / UI
    participant Axios as Axios Client
    participant Server as Backend Server

    User->>Axios: Fayl yuklashni boshlash (POST /upload)
    loop Binar ma'lumotlar oqimi
        Axios->>Server: 1-qism uzatildi (2 MB)
        Axios-->>User: onUploadProgress(loaded: 2MB, total: 10MB) -> 20%
        Axios->>Server: 2-qism uzatildi (6 MB)
        Axios-->>User: onUploadProgress(loaded: 6MB, total: 10MB) -> 60%
        Axios->>Server: 3-qism uzatildi (10 MB)
        Axios-->>User: onUploadProgress(loaded: 10MB, total: 10MB) -> 100%
    end
    Server-->>Axios: 200 OK (Fayl saqlandi)
    Axios-->>User: Yuklash muvaffaqiyatli yakunlandi!

AxiosProgressEvent obyektining asosiy xossalari:

  1. loaded (number): Hozirgi lahzagacha serverga uzatilgan jami ma'lumot hajmi (baytlarda).
  2. total (number | undefined): Yuklanayotgan ma'lumotlarning umumiy hajmi (baytlarda).
  3. rate (number | undefined): Uzatish tezligi (bayt/soniya — zamonaviy Axios v1.x versiyalarida).
  4. estimated (number | undefined): Yuklash to'liq tugashigacha qolgan taxminiy vaqt (soniyalarda).

Foizni hisoblash formulasi:

Percent = Math.round((loaded * 100) / total)

2. Amaliyot: TypeScript yordamida Progress Servisi

Keling, yuklanish foizi bilan birga uzatilgan hajmni odam tushunadigan formatda (MB yoki KB) qaytaruvchi toza servis yozamiz:

// src/services/progressUploadService.ts
import { apiClient } from '../api/client';
import { AxiosProgressEvent } from 'axios';

export interface ProgressCallbackData {
  percentage: number;
  loaded: number;
  total: number;
  formattedLoaded: string;
  formattedTotal: string;
}

export interface ProgressOptions {
  onProgress: (data: ProgressCallbackData) => void;
  signal?: AbortSignal;
}

/**
 * Baytlarni inson tushunadigan formatga (KB, MB) o'tkazish
 */
export const formatBytes = (bytes: number, decimals: number = 2): string => {
  if (bytes === 0) return '0 Bytes';
  const k = 1024;
  const dm = decimals < 0 ? 0 : decimals;
  const sizes = ['Bytes', 'KB', 'MB', 'GB'];
  const i = Math.floor(Math.log(bytes) / Math.log(k));
  return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
};

export const ProgressUploadService = {
  uploadWithProgress: async (
    file: File,
    options: ProgressOptions
  ): Promise<string> => {
    const formData = new FormData();
    formData.append('file', file);

    const response = await apiClient.post<{ url: string }>(
      '/media/upload',
      formData,
      {
        signal: options.signal,

        // --- UPLOAD PROGRESS HOOK ---
        onUploadProgress: (progressEvent: AxiosProgressEvent) => {
          const loaded = progressEvent.loaded;
          const total = progressEvent.total;

          // Agar umumiy hajm (total) mavjud bo'lsa
          if (total) {
            const percentage = Math.round((loaded * 100) / total);

            options.onProgress({
              percentage,
              loaded,
              total,
              formattedLoaded: formatBytes(loaded),
              formattedTotal: formatBytes(total),
            });
          } else {
            // total noma'lum bo'lsa (Chunked Stream)
            console.log(`Yuklandi: ${formatBytes(loaded)} (umumiy hajm noma'lum)`);
          }
        },
      }
    );

    return response.data.url;
  },
};

3. React Komponentida Ishlatish va UI Throttling

Yuqori tezlikdagi internet yoki lokal tarmoqda onUploadProgress sekundiga 50–100 marta chaqirilishi mumkin. Agar siz React holatini (useState) har bir millisekundda yangilayversangiz, interfeys keraksiz qayta chizilishlardan (re-renders) qotib qolishi mumkin.

Buning oldini olish uchun oddiy vaqt cheklovi (Throttling) qo'shish tavsiya etiladi:

// src/components/VideoUpload.tsx
import React, { useState, useRef } from 'react';
import { ProgressUploadService, ProgressCallbackData } from '../services/progressUploadService';

export const VideoUpload: React.FC = () => {
  const [progressInfo, setProgressInfo] = useState<ProgressCallbackData | null>(null);
  const [uploading, setUploading] = useState<boolean>(false);
  const lastUpdateRef = useRef<number>(0);

  const handleFileChange = async (e: React.ChangeEvent<HTMLInputElement>) => {
    const file = e.target.files?.[0];
    if (!file) return;

    setUploading(true);
    setProgressInfo(null);

    try {
      const url = await ProgressUploadService.uploadWithProgress(file, {
        onProgress: (data) => {
          const now = Date.now();
          // Har 100ms da bir marta yoki 100% bo'lganda UI ni yangilaymiz (Throttling)
          if (now - lastUpdateRef.current > 100 || data.percentage === 100) {
            lastUpdateRef.current = now;
            setProgressInfo(data);
          }
        },
      });

      alert('Video yuklandi: ' + url);
    } catch (error) {
      console.error('Yuklashda xato:', error);
    } finally {
      setUploading(false);
    }
  };

  return (
    <div style={{ padding: '20px', maxWidth: '400px' }}>
      <h4>Video yuklash</h4>
      <input type="file" onChange={handleFileChange} disabled={uploading} />

      {uploading && progressInfo && (
        <div style={{ marginTop: '16px' }}>
          <p>
            Yuklanmoqda: <strong>{progressInfo.percentage}%</strong> ({progressInfo.formattedLoaded} / {progressInfo.formattedTotal})
          </p>
          <div style={{ width: '100%', backgroundColor: '#e9ecef', borderRadius: '4px', overflow: 'hidden' }}>
            <div
              style={{
                width: `${progressInfo.percentage}%`,
                height: '12px',
                backgroundColor: '#28a745',
                transition: 'width 0.15s ease-in-out',
              }}
            />
          </div>
        </div>
      )}
    </div>
  );
};

4. Edge Caselar va Nozik Jihatlar ⚠️

A. total ning undefined bo'lib qolishi

Ba'zi holatlarda server yoki oraliq proksi (masalan, Nginx yoki Cloudflare) oqimli uzatishda (Chunked Transfer Encoding) Content-Length sarlavhasini qaytarmaydi. Natijada progressEvent.total bo'sh (undefined) bo'ladi.

[!WARNING] Har doim if (progressEvent.total) shartini tekshirib, keyin foizni hisoblang, aks holda NaN% xatosi chiqishi mumkin.

B. Juda kichik fayllar (Instant Upload)

Agar fayl hajmi juda kichik bo'lsa (masalan, 100KB), zamonaviy tarmoqda u 50 millisekundda yuklanib tugaydi. Foydalanuvchi progress barni ko'rishga ham ulgurmaydi. Shu sababli progress ko'rsatkichini faqat 1-2 megabaytdan katta fayllar uchun chiqarish mantiqan to'g'ri bo'ladi.

C. onUploadProgress vs onDownloadProgress

  • onUploadProgress: Mijozdan serverga yuborilayotgan ma'lumotlar oqimini kuzatadi (Fayl yuklashda).
  • onDownloadProgress: Serverdan mijozga kelayotgan javob oqimini kuzatadi (Fayl yuklab olishda / download).

Xulosa

Axios'ning onUploadProgress imkoniyati og'ir fayllarni yuklash jarayonini foydalanuvchi uchun shaffof, tushunarli va qulay qiladi. loaded va total parametrlarini to'g'ri hisoblash hamda interfeys yangilanishlarini throttling orqali nazorat qilish har qanday frontend ilovada sifatli foydalanuvchi tajribasini (UX) ta'minlaydi.