फ़ाइल डेटा अपलोड करें

Google Drive API की मदद से, File बनाते या अपडेट करते समय, फ़ाइल का डेटा अपलोड किया जा सकता है. सिर्फ़ मेटाडेटा वाली फ़ाइल बनाने के तरीके के बारे में जानने के लिए, सिर्फ़ मेटाडेटा वाली फ़ाइलें बनाना लेख पढ़ें. जैसे, फ़ोल्डर.

तीन तरह की फ़ाइलें अपलोड की जा सकती हैं:

  • सामान्य अपलोड (uploadType=media): इस तरह के अपलोड का इस्तेमाल, मेटाडेटा दिए बिना छोटी मीडिया फ़ाइल (पांच एमबी या इससे कम) ट्रांसफ़र करने के लिए किया जाता है. आसान तरीके से अपलोड करने के लिए, आसान तरीके से अपलोड करना लेख पढ़ें.

  • एक साथ कई फ़ाइलें अपलोड करना (uploadType=multipart): "इस तरह की अपलोड सुविधा का इस्तेमाल करके, एक ही अनुरोध में 5 एमबी या इससे कम साइज़ की फ़ाइल के साथ-साथ, फ़ाइल के बारे में बताने वाला मेटाडेटा ट्रांसफ़र करें. कई हिस्सों में अपलोड करने की प्रोसेस पूरी करने के लिए, कई हिस्सों में अपलोड करने की प्रोसेस पूरी करना लेख पढ़ें.

  • फिर से शुरू किया जा सकने वाला अपलोड (uploadType=resumable): इस तरह के अपलोड का इस्तेमाल तब करें, जब फ़ाइलें बड़ी हों (पांच एमबी से ज़्यादा) और नेटवर्क में रुकावट आने की संभावना ज़्यादा हो. जैसे, मोबाइल ऐप्लिकेशन से फ़ाइल बनाते समय. फिर से शुरू किए जा सकने वाले अपलोड, ज़्यादातर ऐप्लिकेशन के लिए भी एक अच्छा विकल्प है. ऐसा इसलिए, क्योंकि ये छोटे फ़ाइलों के लिए भी काम करते हैं. इसके लिए, हर अपलोड पर एक अतिरिक्त एचटीटीपी अनुरोध करना पड़ता है. फिर से अपलोड करने की सुविधा का इस्तेमाल करने के लिए, फिर से अपलोड करने की सुविधा का इस्तेमाल करना लेख पढ़ें.

Google API की क्लाइंट लाइब्रेरी, इनमें से कम से कम एक तरह के अपलोड को लागू करती हैं. हर टाइप का इस्तेमाल करने के बारे में ज़्यादा जानकारी के लिए, क्लाइंट लाइब्रेरी के दस्तावेज़ देखें.

PUT की तुलना में PATCH का इस्तेमाल करना

आपको बता दें कि एचटीटीपी वर्ब PATCH, फ़ाइल के संसाधन को आंशिक तौर पर अपडेट करने की सुविधा देता है. वहीं, एचटीटीपी वर्ब PUT, संसाधन को पूरी तरह से बदलने की सुविधा देता है. ध्यान दें कि मौजूदा संसाधन में नया फ़ील्ड जोड़ने पर, PUT में बड़े बदलाव हो सकते हैं.

फ़ाइल रिसॉर्स अपलोड करते समय, इन दिशा-निर्देशों का पालन करें:

  • फिर से शुरू किए जा सकने वाले अपलोड के शुरुआती अनुरोध के लिए या सामान्य या कई हिस्सों वाले अपलोड के सिर्फ़ एक अनुरोध के लिए, एपीआई रेफ़रंस में दिए गए एचटीटीपी वर्ब का इस्तेमाल करें.
  • अनुरोध शुरू होने के बाद, फिर से शुरू किए जा सकने वाले अपलोड के लिए किए जाने वाले सभी अनुरोधों के लिए, PUT का इस्तेमाल करें. ये अनुरोध, कॉन्टेंट अपलोड कर रहे हैं. भले ही, कोई भी तरीका इस्तेमाल किया जा रहा हो.

आसानी से अपलोड करना

आसानी से अपलोड करने के लिए, files संसाधन पर uploadType=media के साथ create तरीके का इस्तेमाल करें.

यहां सामान्य अपलोड करने का तरीका बताया गया है:

HTTP

  1. uploadType=media क्वेरी पैरामीटर के साथ, /upload यूआरआई के लिए POST अनुरोध बनाएं:

    POST https://www.googleapis.com/upload/drive/v3/files?uploadType=media

  2. फ़ाइल का डेटा, अनुरोध के मुख्य हिस्से में जोड़ें.

  3. ये एचटीटीपी हेडर जोड़ें:

    • Content-Type. इसे अपलोड किए जा रहे ऑब्जेक्ट के MIME मीडिया टाइप पर सेट करें.
    • Content-Length. इसे अपलोड किए गए बाइट की संख्या पर सेट करें. अगर आपने chunked transfer encoding का इस्तेमाल किया है, तो इस हेडर की ज़रूरत नहीं है.

  4. अनुरोध भेजें. अगर अनुरोध पूरा हो जाता है, तो सर्वर, फ़ाइल के मेटाडेटा के साथ HTTP 200 OK स्टेटस कोड दिखाता है. {HTTP}

JavaScript

/**
 * Uploads a file without metadata.
 *
 * @param {Blob|File} file The file to upload.
 * @param {string} accessToken A valid OAuth 2.0 access token.
 * @return {Promise<Object>} The uploaded file metadata.
 */
async function uploadFileSimple(file, accessToken) {
  const response = await fetch(
    'https://www.googleapis.com/upload/drive/v3/files?uploadType=media',
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${accessToken}`,
        'Content-Type': file.type,
      },
      body: file,
    }
  );
  if (!response.ok) {
    throw new Error(`Upload failed: ${response.statusText}`);
  }
  return response.json();
}

सामान्य तरीके से अपलोड करने पर, बुनियादी मेटाडेटा बनाया जाता है. साथ ही, फ़ाइल से कुछ एट्रिब्यूट का अनुमान लगाया जाता है. जैसे, एमआईएमई टाइप या modifiedTime. अगर आपके पास छोटी फ़ाइलें हैं और फ़ाइल का मेटाडेटा ज़रूरी नहीं है, तो सामान्य अपलोड का इस्तेमाल किया जा सकता है.

मल्टीपार्ट अपलोड करना

मल्टीपार्ट अपलोड अनुरोध की मदद से, एक ही अनुरोध में मेटाडेटा और डेटा अपलोड किया जा सकता है. अगर कनेक्शन फ़ेल होने पर, भेजे गए डेटा को फिर से अपलोड किया जा सकता है, तो इस विकल्प का इस्तेमाल करें.

मल्टीपार्ट अपलोड करने के लिए, files संसाधन पर uploadType=multipart के साथ create तरीके का इस्तेमाल करें.

यहां कई हिस्सों में अपलोड करने का तरीका बताया गया है:

Java

drive/snippets/drive_v3/src/main/java/UploadBasic.java
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
import com.google.api.client.http.FileContent;
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.drive.Drive;
import com.google.api.services.drive.DriveScopes;
import com.google.api.services.drive.model.File;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.Arrays;

/* Class to demonstrate use of Drive insert file API */
public class UploadBasic {

  /**
   * Upload new file.
   *
   * @return Inserted file metadata if successful, {@code null} otherwise.
   * @throws IOException if service account credentials file not found.
   */
  public static String uploadBasic() throws IOException {
    // Load pre-authorized user credentials from the environment.
    // TODO(developer) - See https://developers.google.com/identity for
    // guides on implementing OAuth2 for your application.
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault()
        .createScoped(Arrays.asList(DriveScopes.DRIVE_FILE));
    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(
        credentials);

    // Build a new authorized API client service.
    Drive service = new Drive.Builder(new NetHttpTransport(),
        GsonFactory.getDefaultInstance(),
        requestInitializer)
        .setApplicationName("Drive samples")
        .build();
    // Upload file photo.jpg on drive.
    File fileMetadata = new File();
    fileMetadata.setName("photo.jpg");
    // File's content.
    java.io.File filePath = new java.io.File("files/photo.jpg");
    // Specify media type and file-path for file.
    FileContent mediaContent = new FileContent("image/jpeg", filePath);
    try {
      File file = service.files().create(fileMetadata, mediaContent)
          .setFields("id")
          .execute();
      System.out.println("File ID: " + file.getId());
      return file.getId();
    } catch (GoogleJsonResponseException e) {
      // TODO(developer) - handle error appropriately
      System.err.println("Unable to upload file: " + e.getDetails());
      throw e;
    }
  }
}

Python

drive/snippets/drive-v3/file_snippet/upload_basic.py
import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError
from googleapiclient.http import MediaFileUpload


def upload_basic():
  """Insert new file.
  Returns : Id's of the file uploaded

  Load pre-authorized user credentials from the environment.
  TODO(developer) - See https://developers.google.com/identity
  for guides on implementing OAuth2 for the application.
  """
  creds, _ = google.auth.default()

  try:
    # create drive api client
    service = build("drive", "v3", credentials=creds)

    file_metadata = {"name": "download.jpeg"}
    media = MediaFileUpload("download.jpeg", mimetype="image/jpeg")
    # pylint: disable=maybe-no-member
    file = (
        service.files()
        .create(body=file_metadata, media_body=media, fields="id")
        .execute()
    )
    print(f'File ID: {file.get("id")}')

  except HttpError as error:
    print(f"An error occurred: {error}")
    file = None

  return file.get("id")


if __name__ == "__main__":
  upload_basic()

Node.js

drive/snippets/drive_v3/file_snippets/upload_basic.js
import fs from 'node:fs';
import {GoogleAuth} from 'google-auth-library';
import {google} from 'googleapis';

/**
 * Uploads a file to Google Drive.
 * @return {Promise<string|null|undefined>} The ID of the uploaded file.
 */
async function uploadBasic() {
  // Authenticate with Google and get an authorized client.
  // TODO (developer): Use an appropriate auth mechanism for your app.
  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/drive',
  });

  // Create a new Drive API client (v3).
  const service = google.drive({version: 'v3', auth});

  // The request body for the file to be uploaded.
  const requestBody = {
    name: 'photo.jpg',
    fields: 'id',
  };

  // The media content to be uploaded.
  const media = {
    mimeType: 'image/jpeg',
    body: fs.createReadStream('files/photo.jpg'),
  };

  // Upload the file.
  const file = await service.files.create({
    requestBody,
    media,
  });

  // Print the ID of the uploaded file.
  console.log('File Id:', file.data.id);
  return file.data.id;
}

JavaScript

/**
 * Uploads a file along with its metadata.
 *
 * @param {Blob|File} file The file to upload.
 * @param {string} accessToken A valid OAuth 2.0 access token.
 * @return {Promise<Object>} The uploaded file metadata.
 */
async function uploadFileMultipart(file, accessToken) {
  const metadata = {
    name: file.name,
  };

  const boundary = 'foo_bar_baz';
  const delimiter = `\r\n--${boundary}\r\n`;
  const closeDelimiter = `\r\n--${boundary}--`;

  const requestBody = new Blob([
    `--${boundary}\r\n`,
    'Content-Type: application/json; charset=UTF-8\r\n\r\n',
    JSON.stringify(metadata),
    delimiter,
    `Content-Type: ${file.type}\r\n\r\n`,
    file,
    closeDelimiter,
  ]);

  const response = await fetch(
    'https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart',
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${accessToken}`,
        'Content-Type': `multipart/related; boundary=${boundary}`,
      },
      body: requestBody,
    }
  );
  if (!response.ok) {
    throw new Error(`Upload failed: ${response.statusText}`);
  }
  return response.json();
}

PHP

drive/snippets/drive_v3/src/DriveUploadBasic.php
<?php
use Google\Client;
use Google\Service\Drive;
# TODO - PHP client currently chokes on fetching start page token
function uploadBasic()
{
    try {
        $client = new Client();
        $client->useApplicationDefaultCredentials();
        $client->addScope(Drive::DRIVE);
        $driveService = new Drive($client);
        $fileMetadata = new Drive\DriveFile(array(
        'name' => 'photo.jpg'));
        $content = file_get_contents('../files/photo.jpg');
        $file = $driveService->files->create($fileMetadata, array(
            'data' => $content,
            'mimeType' => 'image/jpeg',
            'uploadType' => 'multipart',
            'fields' => 'id'));
        printf("File ID: %s\n", $file->id);
        return $file->id;
    } catch(Exception $e) {
        echo "Error Message: ".$e;
    } 

}

.NET

drive/snippets/drive_v3/DriveV3Snippets/UploadBasic.cs
using Google.Apis.Auth.OAuth2;
using Google.Apis.Drive.v3;
using Google.Apis.Services;

namespace DriveV3Snippets
{
    // Class to demonstrate use of Drive insert file API
    public class UploadBasic
    {
        /// <summary>
        /// Upload new file.
        /// </summary>
        /// <param name="filePath">Image path to upload.</param>
        /// <returns>Inserted file metadata if successful, null otherwise.</returns>
        public static string DriveUploadBasic(string filePath)
        {
            try
            {
                /* Load pre-authorized user credentials from the environment.
                 TODO(developer) - See https://developers.google.com/identity for
                 guides on implementing OAuth2 for your application. */
                GoogleCredential credential = GoogleCredential.GetApplicationDefault()
                    .CreateScoped(DriveService.Scope.Drive);

                // Create Drive API service.
                var service = new DriveService(new BaseClientService.Initializer
                {
                    HttpClientInitializer = credential,
                    ApplicationName = "Drive API Snippets"
                });

                // Upload file photo.jpg on drive.
                var fileMetadata = new Google.Apis.Drive.v3.Data.File()
                {
                    Name = "photo.jpg"
                };
                FilesResource.CreateMediaUpload request;
                // Create a new file on drive.
                using (var stream = new FileStream(filePath,
                           FileMode.Open))
                {
                    // Create a new file, with metadata and stream.
                    request = service.Files.Create(
                        fileMetadata, stream, "image/jpeg");
                    request.Fields = "id";
                    request.Upload();
                }

                var file = request.ResponseBody;
                // Prints the uploaded file id.
                Console.WriteLine("File ID: " + file.Id);
                return file.Id;
            }
            catch (Exception e)
            {
                // TODO(developer) - handle error appropriately
                if (e is AggregateException)
                {
                    Console.WriteLine("Credential Not found");
                }
                else if (e is FileNotFoundException)
                {
                    Console.WriteLine("File not found");
                }
                else
                {
                    throw;
                }
            }
            return null;
        }
    }
}

HTTP

  1. uploadType=multipart क्वेरी पैरामीटर के साथ, /upload यूआरआई के लिए POST अनुरोध बनाएं:

    POST https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart

  1. अनुरोध का मुख्य हिस्सा बनाएं. मुख्य हिस्से को RFC 2387 में दिए गए MIME multipart/related कॉन्टेंट टाइप के हिसाब से फ़ॉर्मैट करें. इसमें दो हिस्से होते हैं:

    • मेटाडेटा. मेटाडेटा सबसे पहले होना चाहिए. साथ ही, इसमें Content-Type हेडर application/json; charset=UTF-8 पर सेट होना चाहिए. फ़ाइल का मेटाडेटा JSON फ़ॉर्मैट में जोड़ें.
    • मीडिया. मीडिया दूसरे नंबर पर होना चाहिए और इसमें किसी भी एमआईएमई टाइप का Content-Type हेडर होना चाहिए. फ़ाइल के डेटा को मीडिया वाले हिस्से में जोड़ें. हर हिस्से की पहचान करने के लिए, बाउंड्री स्ट्रिंग का इस्तेमाल करें. इससे पहले दो हाइफ़न लगाएं. इसके अलावा, आखिरी बाउंड्री स्ट्रिंग के बाद दो हाइफ़न जोड़ें.

    1. ये टॉप-लेवल एचटीटीपी हेडर जोड़ें:

      • Content-Type. इसे multipart/related पर सेट करें. साथ ही, वह बाउंड्री स्ट्रिंग शामिल करें जिसका इस्तेमाल अनुरोध के अलग-अलग हिस्सों की पहचान करने के लिए किया जा रहा है. उदाहरण के लिए: Content-Type: multipart/related; boundary=foo_bar_baz
      • Content-Length. इसे अनुरोध के मुख्य हिस्से में मौजूद बाइट की कुल संख्या पर सेट करें.

    2. अनुरोध भेजें.

    सिर्फ़ मेटाडेटा वाला हिस्सा बनाने या अपडेट करने के लिए, उससे जुड़ा डेटा शामिल किए बिना, स्टैंडर्ड रिसॉर्स एंडपॉइंट पर POST या PATCH अनुरोध भेजें: https://www.googleapis.com/drive/v3/files अगर अनुरोध पूरा हो जाता है, तो सर्वर, फ़ाइल के मेटाडेटा के साथ HTTP 200 OK स्टेटस कोड दिखाता है.

फ़ाइलें बनाते समय, उन्हें फ़ाइल के name फ़ील्ड में फ़ाइल एक्सटेंशन की जानकारी देनी चाहिए. उदाहरण के लिए, फ़ोटो की JPEG फ़ाइल बनाते समय, मेटाडेटा में "name": "photo.jpg" जैसी जानकारी दी जा सकती है. get तरीके को बाद में किए गए कॉल, रीड-ओनली fileExtension प्रॉपर्टी दिखाते हैं. इसमें name फ़ील्ड में मूल रूप से बताया गया एक्सटेंशन होता है.

फिर से अपलोड किया जा सकता है

फिर से शुरू किए जा सकने वाले अपलोड की मदद से, डेटा फ़्लो में रुकावट आने पर अपलोड की प्रोसेस को फिर से शुरू किया जा सकता है. बड़ी फ़ाइलों को शुरू से अपलोड करने की ज़रूरत नहीं होती. इसलिए, नेटवर्क में गड़बड़ी होने पर, फिर से शुरू होने वाले अपलोड से बैंडविथ का इस्तेमाल भी कम किया जा सकता है.

फिर से शुरू किए जा सकने वाले अपलोड तब काम आते हैं, जब आपकी फ़ाइलों के साइज़ में काफ़ी अंतर हो या जब अनुरोधों के लिए समयसीमा तय हो. जैसे, मोबाइल ओएस के बैकग्राउंड टास्क और App Engine के कुछ अनुरोध. अपलोड की प्रोग्रेस बार दिखाने के लिए भी, फिर से शुरू किए जा सकने वाले अपलोड का इस्तेमाल किया जा सकता है.

फिर से शुरू किए जा सकने वाले अपलोड में, ये मुख्य चरण शामिल होते हैं:

  1. शुरुआती अनुरोध भेजें और फिर से शुरू किए जा सकने वाले सेशन का यूआरआई पाएं.
  2. डेटा अपलोड करें और अपलोड की स्थिति पर नज़र रखें.
  3. (ज़रूरी नहीं) अगर अपलोड में कोई समस्या आती है, तो अपलोड फिर से शुरू करें.

शुरुआती अनुरोध भेजना

फिर से शुरू किए जा सकने वाले अपलोड की प्रोसेस शुरू करने के लिए, uploadType=resumable के साथ files रिसॉर्स पर create तरीके का इस्तेमाल करें.

HTTP

  1. uploadType=resumable क्वेरी पैरामीटर के साथ, /upload यूआरआई के लिए POST अनुरोध बनाएं:

    POST https://www.googleapis.com/upload/drive/v3/files?uploadType=resumable

    अगर सेशन शुरू करने का अनुरोध पूरा हो जाता है, तो जवाब में 200 OK एचटीटीपी स्टेटस कोड शामिल होता है. इसके अलावा, इसमें Location हेडर भी शामिल होता है, जो फिर से शुरू किए जा सकने वाले सेशन का यूआरआई बताता है:

    HTTP/1.1 200 OK
Location: https://www.googleapis.com/upload/drive/v3/files?uploadType=resumable&upload_id=xa298sd_sdlkj2
Content-Length: 0

    फिर से शुरू किए जा सकने वाले सेशन का यूआरआई सेव करें, ताकि फ़ाइल का डेटा अपलोड किया जा सके और अपलोड की स्थिति के बारे में क्वेरी की जा सके. फिर से शुरू किए जा सकने वाले सेशन का यूआरआई, एक हफ़्ते बाद खत्म हो जाता है.

    किसी मौजूदा फ़ाइल को अपडेट करने के लिए, PATCH का इस्तेमाल करें.

  2. अगर आपके पास फ़ाइल का मेटाडेटा है, तो उसे JSON फ़ॉर्मैट में अनुरोध के मुख्य हिस्से में जोड़ें. अगर ऐसा नहीं है, तो अनुरोध के मुख्य हिस्से को खाली छोड़ दें.

  3. ये एचटीटीपी हेडर जोड़ें:

    • X-Upload-Content-Type. ज़रूरी नहीं है. इसे फ़ाइल के एमआईएमई टाइप पर सेट किया जाता है. यह डेटा, बाद के अनुरोधों में ट्रांसफ़र किया जाता है. अगर मेटाडेटा या इस हेडर में डेटा का एमआईएमई टाइप नहीं बताया गया है, तो ऑब्जेक्ट को application/octet-stream. के तौर पर दिखाया जाता है
    • X-Upload-Content-Length. ज़रूरी नहीं है. इसे फ़ाइल के डेटा के बाइट की संख्या पर सेट किया जाता है. यह डेटा, बाद के अनुरोधों में ट्रांसफ़र किया जाता है.
    • Content-Type. अगर आपके पास फ़ाइल का मेटाडेटा है, तो यह ज़रूरी है. application/json; charset=UTF-8 पर सेट करें.
    • Content-Length. अगर आपने चंक किए गए ट्रांसफ़र एन्कोडिंग का इस्तेमाल नहीं किया है, तो यह ज़रूरी है. इसकी वैल्यू, शुरुआती अनुरोध के मुख्य हिस्से में मौजूद बाइट की संख्या पर सेट होती है.

  4. अनुरोध भेजें. अगर सेशन शुरू करने का अनुरोध पूरा हो जाता है, तो जवाब में 200 OK HTTP स्टेटस कोड शामिल होता है. हालांकि, इसमें कोई डेटा नहीं होता. इसके अलावा, जवाब में Location हेडर भी शामिल होता है, जो फिर से शुरू किए जा सकने वाले सेशन का यूआरआई बताता है. फ़ाइल का डेटा अपलोड करने और अपलोड की स्थिति के बारे में क्वेरी करने के लिए, फिर से शुरू किए जा सकने वाले सेशन यूआरआई का इस्तेमाल करें. फिर से शुरू किए जा सकने वाले सेशन का यूआरआई, एक हफ़्ते बाद खत्म हो जाता है.

  5. फिर से शुरू किए जा सकने वाले सेशन का यूआरएल कॉपी करें और सेव करें.

  6. कॉन्टेंट अपलोड करने की प्रोसेस जारी रखें.

JavaScript

/**
 * Initiates a resumable upload session and returns the session URI.
 *
 * @param {Blob|File} file The file to upload.
 * @param {string} accessToken A valid OAuth 2.0 access token.
 * @return {Promise<string>} The resumable session URI.
 */
async function initiateResumableUpload(file, accessToken) {
  const metadata = {
    name: file.name,
    mimeType: file.type,
  };

  const response = await fetch(
    'https://www.googleapis.com/upload/drive/v3/files?uploadType=resumable',
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${accessToken}`,
        'Content-Type': 'application/json; charset=UTF-8',
        'X-Upload-Content-Type': file.type,
        'X-Upload-Content-Length': file.size,
      },
      body: JSON.stringify(metadata),
    }
  );
  if (!response.ok) {
    throw new Error(`Failed to initiate upload: ${response.statusText}`);
  }
  return response.headers.get('Location');
}

कॉन्टेंट अपलोड करना

फिर से शुरू किए जा सकने वाले सेशन के साथ फ़ाइल अपलोड करने के दो तरीके हैं:

  • एक ही अनुरोध में कॉन्टेंट अपलोड करना: इस तरीके का इस्तेमाल तब करें, जब फ़ाइल को एक ही अनुरोध में अपलोड किया जा सकता हो. ऐसा तब भी किया जा सकता है, जब किसी एक अनुरोध के लिए कोई तय समयसीमा न हो या आपको अपलोड करने की प्रोसेस दिखाने वाले इंडिकेटर को दिखाने की ज़रूरत न हो. यह तरीका सबसे अच्छा है, क्योंकि इसमें कम अनुरोधों की ज़रूरत होती है और इससे बेहतर परफ़ॉर्मेंस मिलती है.

  • कॉन्टेंट को कई हिस्सों में अपलोड करें: अगर आपको किसी एक अनुरोध में ट्रांसफ़र किए जाने वाले डेटा की मात्रा कम करनी है, तो इस तरीके का इस्तेमाल करें. ऐसा हो सकता है कि आपको डेटा ट्रांसफ़र करने की प्रोसेस को छोटा करना पड़े. ऐसा तब होता है, जब हर अनुरोध के लिए समयसीमा तय होती है. ऐसा App Engine के कुछ अनुरोधों के लिए हो सकता है. अगर आपको अपलोड की प्रोग्रेस दिखाने के लिए, पसंद के मुताबिक बनाया गया इंडिकेटर देना है, तो यह तरीका भी काम का है.

एचटीटीपी - एक अनुरोध

  1. फिर से शुरू किए जा सकने वाले सेशन के यूआरआई के लिए, PUT अनुरोध बनाएं.
  2. फ़ाइल का डेटा, अनुरोध के मुख्य हिस्से में जोड़ें.
  3. Content-Length एचटीटीपी हेडर जोड़ें और उसे फ़ाइल में मौजूद बाइट की संख्या पर सेट करें.
  4. अनुरोध भेजें. अगर अपलोड करने के अनुरोध में रुकावट आती है या आपको 5xx जवाब मिलता है, तो अपलोड करने की प्रोसेस फिर से शुरू करना में दी गई प्रक्रिया का पालन करें.

JavaScript - सिंगल अनुरोध

/**
 * Uploads the entire file in a single request using the session URI.
 *
 * @param {string} sessionUrl The resumable session URI.
 * @param {Blob|File} file The file to upload.
 * @return {Promise<Object>} The uploaded file metadata.
 */
async function uploadFileSingleRequest(sessionUrl, file) {
  const response = await fetch(sessionUrl, {
    method: 'PUT',
    headers: {
      'Content-Length': file.size,
    },
    body: file,
  });
  if (!response.ok) {
    throw new Error(`Upload failed: ${response.status} ${response.statusText}`);
  }
  return response.json();
}

एचटीटीपी - कई अनुरोध

  1. फिर से शुरू किए जा सकने वाले सेशन के यूआरआई के लिए, PUT अनुरोध बनाएं.

  2. अनुरोध के मुख्य हिस्से में, चंक का डेटा जोड़ें. अपलोड पूरा करने वाले आखिरी हिस्से को छोड़कर, बाकी सभी हिस्सों का साइज़ 256 केबी (256 x 1024 बाइट) के मल्टीपल में बनाएं. चंक का साइज़ जितना हो सके उतना बड़ा रखें, ताकि अपलोड करने की प्रोसेस तेज़ी से हो.

  3. ये एचटीटीपी हेडर जोड़ें:

    • Content-Length. इसे मौजूदा चंक में मौजूद बाइट की संख्या पर सेट करें.
    • Content-Range. इसे सेट करके यह दिखाया जाता है कि अपलोड की गई फ़ाइल में कौनसी बाइट हैं. उदाहरण के लिए, Content-Range: bytes 0-524287/2000000 से पता चलता है कि आपने 2,000,000 बाइट की फ़ाइल में, पहले 524,288 बाइट (256 x 1024 x 2) अपलोड किए हैं.

  4. अनुरोध भेजें और जवाब को प्रोसेस करें. अगर अपलोड करने के अनुरोध में रुकावट आती है या आपको 5xx जवाब मिलता है, तो अधूरे अपलोड को फिर से शुरू करना में दी गई प्रक्रिया का पालन करें.

  5. फ़ाइल में मौजूद हर बचे हुए हिस्से के लिए, पहले से चौथे चरण तक की प्रोसेस दोहराएं. रिस्पॉन्स में मौजूद Range हेडर का इस्तेमाल करके, यह तय करें कि अगला हिस्सा कहां से शुरू करना है. यह न मान लें कि सर्वर को पिछले अनुरोध में भेजे गए सभी बाइट मिल गए हैं.

फ़ाइल पूरी तरह से अपलोड हो जाने पर, आपको 200 OK या 201 Created जवाब मिलता है. साथ ही, संसाधन से जुड़ा कोई भी मेटाडेटा मिलता है.

JavaScript - कई अनुरोध

/**
 * Uploads a file in chunks of a specified size.
 *
 * @param {string} sessionUrl The resumable session URI.
 * @param {Blob|File} file The file to upload.
 * @param {number} chunkSize Chunk size in bytes (must be a multiple of 256 KB).
 * @return {Promise<Object>} The uploaded file metadata.
 */
async function uploadFileChunked(sessionUrl, file, chunkSize = 1024 * 1024) {
  let start = 0;
  while (start < file.size) {
    const end = Math.min(start + chunkSize, file.size);
    const chunk = file.slice(start, end);
    const chunkLength = end - start;

    const response = await fetch(sessionUrl, {
      method: 'PUT',
      headers: {
        'Content-Length': chunkLength,
        'Content-Range': `bytes ${start}-${end - 1}/${file.size}`,
      },
      body: chunk,
    });

    if (response.status === 308) {
      // 308 Resume Incomplete indicates chunk was received successfully.
      start = end;
    } else if (response.ok) {
      // 200 OK or 201 Created indicates the upload is fully complete.
      return response.json();
    } else {
      throw new Error(`Upload failed: ${response.status} ${response.statusText}`);
    }
  }
}

अपलोड होने की प्रोसेस बीच में रुक जाने पर उसे फिर से शुरू करना

अगर अपलोड करने का अनुरोध, जवाब मिलने से पहले ही बंद हो जाता है या आपको 503 Service Unavailable जवाब मिलता है, तो आपको अपलोड करने की प्रोसेस फिर से शुरू करनी होगी.

HTTP

  1. अपलोड का स्टेटस जानने के लिए, फिर से शुरू किए जा सकने वाले सेशन के यूआरआई पर एक खाली PUT अनुरोध भेजें.

  2. फ़ाइल में मौजूद मौजूदा जगह की जानकारी नहीं है, यह बताने के लिए Content-Range हेडर जोड़ें. उदाहरण के लिए, अगर आपकी फ़ाइल का कुल साइज़ 20,00,000 बाइट है, तो Content-Range को */2000000 पर सेट करें. अगर आपको फ़ाइल के पूरे साइज़ के बारे में नहीं पता है, तो Content-Range को */* पर सेट करें.

  3. अनुरोध भेजें.

  4. जवाब को प्रोसेस करें:

    • 200 OK या 201 Created रिस्पॉन्स से पता चलता है कि अपलोड पूरा हो गया है. अब आपको कुछ और करने की ज़रूरत नहीं है.
    • 308 Resume Incomplete रिस्पॉन्स से पता चलता है कि आपको फ़ाइल अपलोड करनी होगी.
    • 404 Not Found रिस्पॉन्स से पता चलता है कि अपलोड सेशन की समयसीमा खत्म हो गई है. इसलिए, अपलोड को शुरू से फिर से शुरू करना होगा.

  5. अगर आपको 308 Resume Incomplete रिस्पॉन्स मिला है, तो रिस्पॉन्स के Range हेडर को प्रोसेस करें. इससे यह पता चलेगा कि सर्वर को कौनसी बाइट मिली हैं. अगर रिस्पॉन्स में Range हेडर नहीं है, तो इसका मतलब है कि कोई बाइट नहीं मिली है. उदाहरण के लिए, bytes=0-42 के Range हेडर से पता चलता है कि फ़ाइल के पहले 43 बाइट मिल गए हैं और अपलोड करने के लिए अगला हिस्सा 44वें बाइट से शुरू होगा.

  6. अब आपको पता चल गया है कि अपलोड करने की प्रोसेस कहां से फिर से शुरू करनी है. इसलिए, फ़ाइल को अगले बाइट से अपलोड करना जारी रखें. Content-Range हेडर शामिल करके बताएं कि फ़ाइल का कौनसा हिस्सा भेजा गया है. उदाहरण के लिए, Content-Range: bytes 43-1999999 से पता चलता है कि आपको 44 से 20,00,000 बाइट भेजने हैं.

JavaScript

/**
 * Resumes an interrupted upload by querying the status and uploading remaining bytes.
 *
 * @param {string} sessionUrl The resumable session URI.
 * @param {Blob|File} file The file being uploaded.
 * @return {Promise<Object>} The uploaded file metadata.
 */
async function resumeUpload(sessionUrl, file) {
  // 1. Query the upload status by sending an empty PUT request
  const statusResponse = await fetch(sessionUrl, {
    method: 'PUT',
    headers: {
      'Content-Range': `bytes */${file.size}`,
    },
  });

  if (statusResponse.ok) {
    // Already completed
    return statusResponse.json();
  }

  if (statusResponse.status !== 308) {
    throw new Error(`Failed to query upload status: ${statusResponse.statusText}`);
  }

  // 2. Parse the Range header to determine received bytes
  const rangeHeader = statusResponse.headers.get('Range');
  let startOffset = 0;
  if (rangeHeader) {
    const parts = rangeHeader.split('-');
    startOffset = parseInt(parts[1], 10) + 1;
  }

  // 3. Upload the remaining content of the file
  const remainingChunk = file.slice(startOffset);
  const response = await fetch(sessionUrl, {
    method: 'PUT',
    headers: {
      'Content-Length': remainingChunk.size,
      'Content-Range': `bytes ${startOffset}-${file.size - 1}/${file.size}`,
    },
    body: remainingChunk,
  });

  if (!response.ok) {
    throw new Error(`Resume upload failed: ${response.statusText}`);
  }
  return response.json();
}

मीडिया अपलोड करने से जुड़ी गड़बड़ियां ठीक करना

मीडिया अपलोड करते समय, गड़बड़ियों को ठीक करने के लिए इन सबसे सही तरीकों का इस्तेमाल करें:

  • 5xx गड़बड़ियों के लिए, कनेक्शन में रुकावट आने की वजह से अपलोड नहीं हो पाने वाली फ़ाइलों को फिर से अपलोड करें या अपलोड करने की प्रोसेस जारी रखें. 5xx गड़बड़ियों को ठीक करने के बारे में ज़्यादा जानने के लिए, 500, 502, 503, 504 गड़बड़ियां लेख पढ़ें.
  • 403 rate limit गड़बड़ियों के लिए, अपलोड करने की कोशिश फिर से करें. 403 rate limit गड़बड़ियों को ठीक करने के बारे में ज़्यादा जानकारी के लिए, 403 गड़बड़ी: rateLimitExceeded लेख पढ़ें.
  • फिर से अपलोड किए जा सकने वाले किसी भी अपलोड के दौरान, 4xx (इसमें 403 भी शामिल है) से जुड़ी गड़बड़ियों के लिए, अपलोड फिर से शुरू करें. इन गड़बड़ियों से पता चलता है कि अपलोड सेशन खत्म हो गया है. इसलिए, नया सेशन यूआरआई का अनुरोध करके इसे फिर से शुरू करना होगा. अगर एक हफ़्ते तक कोई गतिविधि नहीं की जाती है, तो अपलोड सेशन भी खत्म हो जाते हैं.

Google Docs में इंपोर्ट करने के तरीके

Drive में कोई फ़ाइल बनाते समय, आपको फ़ाइल को Google Workspace के फ़ाइल टाइप में बदलना पड़ सकता है. जैसे, Google Docs या Sheets. उदाहरण के लिए, हो सकता है कि आपको अपने पसंदीदा वर्ड प्रोसेसर में मौजूद किसी दस्तावेज़ को Docs में बदलना हो, ताकि आप इसकी सुविधाओं का फ़ायदा ले सकें.

किसी फ़ाइल को Google Workspace के किसी खास फ़ाइल टाइप में बदलने के लिए, फ़ाइल बनाते समय Google Workspace mimeType तय करें.

यहां CSV फ़ाइल को Google Workspace शीट में बदलने का तरीका बताया गया है:

Java

drive/snippets/drive_v3/src/main/java/UploadWithConversion.java
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
import com.google.api.client.http.FileContent;
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.drive.Drive;
import com.google.api.services.drive.DriveScopes;
import com.google.api.services.drive.model.File;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.Arrays;

/* Class to demonstrate Drive's upload with conversion use-case. */
public class UploadWithConversion {

  /**
   * Upload file with conversion.
   *
   * @return Inserted file id if successful, {@code null} otherwise.
   * @throws IOException if service account credentials file not found.
   */
  public static String uploadWithConversion() throws IOException {
    // Load pre-authorized user credentials from the environment.
    // TODO(developer) - See https://developers.google.com/identity for
    // guides on implementing OAuth2 for your application.
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault()
        .createScoped(Arrays.asList(DriveScopes.DRIVE_FILE));
    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(
        credentials);

    // Build a new authorized API client service.
    Drive service = new Drive.Builder(new NetHttpTransport(),
        GsonFactory.getDefaultInstance(),
        requestInitializer)
        .setApplicationName("Drive samples")
        .build();

    // File's metadata.
    File fileMetadata = new File();
    fileMetadata.setName("My Report");
    fileMetadata.setMimeType("application/vnd.google-apps.spreadsheet");

    java.io.File filePath = new java.io.File("files/report.csv");
    FileContent mediaContent = new FileContent("text/csv", filePath);
    try {
      File file = service.files().create(fileMetadata, mediaContent)
          .setFields("id")
          .execute();
      System.out.println("File ID: " + file.getId());
      return file.getId();
    } catch (GoogleJsonResponseException e) {
      // TODO(developer) - handle error appropriately
      System.err.println("Unable to move file: " + e.getDetails());
      throw e;
    }
  }
}

Python

drive/snippets/drive-v3/file_snippet/upload_with_conversion.py
import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError
from googleapiclient.http import MediaFileUpload


def upload_with_conversion():
  """Upload file with conversion
  Returns: ID of the file uploaded

  Load pre-authorized user credentials from the environment.
  TODO(developer) - See https://developers.google.com/identity
  for guides on implementing OAuth2 for the application.
  """
  creds, _ = google.auth.default()

  try:
    # create drive api client
    service = build("drive", "v3", credentials=creds)

    file_metadata = {
        "name": "My Report",
        "mimeType": "application/vnd.google-apps.spreadsheet",
    }
    media = MediaFileUpload("report.csv", mimetype="text/csv", resumable=True)
    # pylint: disable=maybe-no-member
    file = (
        service.files()
        .create(body=file_metadata, media_body=media, fields="id")
        .execute()
    )
    print(f'File with ID: "{file.get("id")}" has been uploaded.')

  except HttpError as error:
    print(f"An error occurred: {error}")
    file = None

  return file.get("id")


if __name__ == "__main__":
  upload_with_conversion()

Node.js

drive/snippets/drive_v3/file_snippets/upload_with_conversion.js
import fs from 'node:fs';
import {GoogleAuth} from 'google-auth-library';
import {google} from 'googleapis';

/**
 * Uploads a file to Google Drive and converts it to a Google Sheet.
 * @return {Promise<string|null|undefined>} The ID of the uploaded file.
 */
async function uploadWithConversion() {
  // Authenticate with Google and get an authorized client.
  // TODO (developer): Use an appropriate auth mechanism for your app.
  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/drive',
  });

  // Create a new Drive API client (v3).
  const service = google.drive({version: 'v3', auth});

  // The metadata for the file to be uploaded and converted.
  const fileMetadata = {
    name: 'My Report',
    // The MIME type to convert the file to.
    mimeType: 'application/vnd.google-apps.spreadsheet',
  };

  // The media content to be uploaded.
  const media = {
    mimeType: 'text/csv',
    body: fs.createReadStream('files/report.csv'),
  };

  // Upload the file with conversion.
  const file = await service.files.create({
    requestBody: fileMetadata,
    media,
    fields: 'id',
  });

  // Print the ID of the uploaded file.
  console.log('File Id:', file.data.id);
  return file.data.id;
}

PHP

drive/snippets/drive_v3/src/DriveUploadWithConversion.php
<?php
use Google\Client;
use Google\Service\Drive;
function uploadWithConversion()
{
    try {
        $client = new Client();
        $client->useApplicationDefaultCredentials();
        $client->addScope(Drive::DRIVE);
        $driveService = new Drive($client);
        $fileMetadata = new Drive\DriveFile(array(
            'name' => 'My Report',
            'mimeType' => 'application/vnd.google-apps.spreadsheet'));
        $content = file_get_contents('../files/report.csv');
        $file = $driveService->files->create($fileMetadata, array(
            'data' => $content,
            'mimeType' => 'text/csv',
            'uploadType' => 'multipart',
            'fields' => 'id'));
        printf("File ID: %s\n", $file->id);
        return $file->id;
    } catch(Exception $e) {
        echo "Error Message: ".$e;
    }

}

.NET

drive/snippets/drive_v3/DriveV3Snippets/UploadWithConversion.cs
using Google.Apis.Auth.OAuth2;
using Google.Apis.Drive.v3;
using Google.Apis.Services;

namespace DriveV3Snippets
{
    // Class to demonstrate Drive's upload with conversion use-case.
    public class UploadWithConversion
    {
        /// <summary>
        /// Upload file with conversion.
        /// </summary>
        /// <param name="filePath">Id of the spreadsheet file.</param>
        /// <returns>Inserted file id if successful, null otherwise.</returns>
        public static string DriveUploadWithConversion(string filePath)
        {
            try
            {
                /* Load pre-authorized user credentials from the environment.
                 TODO(developer) - See https://developers.google.com/identity for
                 guides on implementing OAuth2 for your application. */
                GoogleCredential credential = GoogleCredential.GetApplicationDefault()
                    .CreateScoped(DriveService.Scope.Drive);

                // Create Drive API service.
                var service = new DriveService(new BaseClientService.Initializer
                {
                    HttpClientInitializer = credential,
                    ApplicationName = "Drive API Snippets"
                });

                // Upload file My Report on drive.
                var fileMetadata = new Google.Apis.Drive.v3.Data.File()
                {
                    Name = "My Report",
                    MimeType = "application/vnd.google-apps.spreadsheet"
                };
                FilesResource.CreateMediaUpload request;
                // Create a new drive.
                using (var stream = new FileStream(filePath,
                           FileMode.Open))
                {
                    // Create a new file, with metadata and stream.
                    request = service.Files.Create(
                        fileMetadata, stream, "text/csv");
                    request.Fields = "id";
                    request.Upload();
                }

                var file = request.ResponseBody;
                // Prints the uploaded file id.
                Console.WriteLine("File ID: " + file.Id);
                return file.Id;
            }
            catch (Exception e)
            {
                // TODO(developer) - handle error appropriately
                if (e is AggregateException)
                {
                    Console.WriteLine("Credential Not found");
                }
                else if (e is FileNotFoundException)
                {
                    Console.WriteLine("File not found");
                }
                else
                {
                    throw;
                }
            }
            return null;
        }
    }
}

फ़ाइल बनाने से पहले, about संसाधन के importFormats फ़ील्ड में जाकर देखें कि कन्वर्ज़न उपलब्ध है या नहीं. इस कलेक्शन में, कन्वर्ज़न की सुविधा डाइनैमिक तरीके से उपलब्ध होती है. इंपोर्ट करने के कुछ सामान्य फ़ॉर्मैट ये हैं:

इन्होंने भेजाTo
Microsoft Word, OpenDocument Text, एचटीएमएल, RTF, सादा टेक्स्ट, मार्कडाउनGoogle Docs
Microsoft Excel, OpenDocument Spreadsheet, CSV, TSV, सादा टेक्स्टGoogle Sheets
Microsoft PowerPoint, OpenDocument PresentationGoogle Slides
JPEG, PNG, GIF, BMP, PDFGoogle Docs (दस्तावेज़ में इमेज एम्बेड करता है)
सादा टेक्स्ट (खास एमआईएमई टाइप), JSONGoogle Apps Script

Docs, Sheets या Slides की फ़ाइल में update अनुरोध के दौरान मीडिया अपलोड और बदलने पर, दस्तावेज़ का पूरा कॉन्टेंट बदल जाता है.

किसी इमेज को Docs फ़ाइल में बदलने पर, Drive ऑप्टिकल कैरेक्टर रिकग्निशन (ओसीआर) का इस्तेमाल करके इमेज को टेक्स्ट में बदलता है. ocrLanguage पैरामीटर में, लागू होने वाला BCP 47 भाषा कोड सेट करके, ओसीआर एल्गोरिदम की क्वालिटी को बेहतर बनाया जा सकता है. एक्सट्रैक्ट किया गया टेक्स्ट, दस्तावेज़ में एम्बेड की गई इमेज के साथ दिखता है.

फ़ाइलें अपलोड करने के लिए, पहले से जनरेट किए गए आईडी का इस्तेमाल करना

Drive API की मदद से, पहले से जनरेट किए गए फ़ाइल आईडी की सूची को वापस पाया जा सकता है. इन आईडी का इस्तेमाल, संसाधन बनाने, कॉपी करने, और अपलोड करने के लिए किया जा सकता है. ज़्यादा जानकारी के लिए, अपनी फ़ाइलों के साथ इस्तेमाल करने के लिए आईडी जनरेट करना लेख पढ़ें.

अगर सर्वर से जुड़ी कोई गड़बड़ी होती है या टाइम आउट हो जाता है, तो पहले से जनरेट किए गए आईडी का इस्तेमाल करके, अपलोड करने की प्रोसेस को फिर से शुरू किया जा सकता है. अगर फ़ाइल से जुड़ी कार्रवाई पूरी हो जाती है, तो बाद में किए गए फिर से कोशिश करने के अनुरोधों के जवाब में, 409 Conflict एचटीटीपी स्टेटस कोड मिलता है. साथ ही, डुप्लीकेट फ़ाइलें नहीं बनती हैं.

ध्यान दें कि पहले से जनरेट किए गए आईडी, Google Workspace फ़ाइलें बनाने के लिए इस्तेमाल नहीं किए जा सकते. हालांकि, application/vnd.google-apps.drive-sdk और application/vnd.google-apps.folder MIME टाइप के लिए इनका इस्तेमाल किया जा सकता है. इसी तरह, Google Workspace फ़ाइल फ़ॉर्मैट में बदलने के लिए किए गए अपलोड भी काम नहीं करते.

ऐसे फ़ाइल टाइप के लिए इंडेक्स किए जा सकने वाले टेक्स्ट को तय करना जिनके बारे में जानकारी नहीं है

उपयोगकर्ता, दस्तावेज़ के कॉन्टेंट को ढूंढने के लिए Drive के यूज़र इंटरफ़ेस (यूआई) का इस्तेमाल कर सकते हैं. अपने ऐप्लिकेशन का कॉन्टेंट खोजने के लिए, files संसाधन पर list तरीके का इस्तेमाल किया जा सकता है. इसके अलावा, fullText फ़ील्ड का इस्तेमाल भी किया जा सकता है. ज़्यादा जानकारी के लिए, फ़ाइलें और फ़ोल्डर खोजना लेख पढ़ें.

Drive, फ़ाइल टाइप की पहचान होने पर, खोज के लिए दस्तावेज़ों को अपने-आप इंडेक्स कर देता है. इनमें टेक्स्ट दस्तावेज़, PDF, टेक्स्ट वाली इमेज, और अन्य सामान्य टाइप शामिल हैं. अगर आपका ऐप्लिकेशन अन्य तरह की फ़ाइलें सेव करता है (जैसे कि ड्रॉइंग, वीडियो, और शॉर्टकट), तो उन्हें खोजने में आसानी हो सकती है. इसके लिए, फ़ाइल के contentHints.indexableText फ़ील्ड में इंडेक्स किया जा सकने वाला टेक्स्ट डालें.

इंडेक्स किए जा सकने वाले टेक्स्ट के बारे में ज़्यादा जानने के लिए, फ़ाइल का मेटाडेटा मैनेज करना लेख पढ़ें.