Cómo buscar archivos y carpetas

La API de Google Drive admite varias formas de buscar archivos y carpetas.

Puedes usar el método files.list para mostrar todos o algunos de los archivos y carpetas de un usuario de Drive. El files.list también se puede usar para recuperar el fileId requerido para algún recurso métodos (como files.get y files.update).

Buscar todos los archivos y carpetas en la sección Mi unidad del usuario actual

Usa el método files.list sin ningún parámetro para mostrar todos los archivos y individuales.

GET https://www.googleapis.com/drive/v3/files

Buscar archivos o carpetas específicos en la sección Mi unidad del usuario actual

Para buscar un conjunto específico de archivos o carpetas, usa el campo de cadena de consulta q con el método files.list para filtrar las para mostrar resultados combinando uno o más términos de búsqueda.

Una cadena de consulta contiene las siguientes tres partes:

query_term operator values

Aquí:

  • query_term es el término o campo de búsqueda que se va a buscar.

  • operator especifica la condición para el término de la búsqueda.

  • values son los valores específicos que deseas usar para filtrar tu búsqueda. resultados.

Para ver los términos y operadores de búsqueda que puedes usar para filtrar archivos y carpetas, consulta Términos y operadores de búsqueda.

Por ejemplo, la siguiente cadena de consulta filtra la búsqueda para que solo muestre carpetas estableciendo el tipo de MIME:

q: mimeType = 'application/vnd.google-apps.folder'

Para obtener más información sobre los tipos de MIME, consulta Google Workspace y Google Drive los tipos de MIME admitidos.

Ejemplos de cadenas de consulta

En la siguiente tabla, se muestran ejemplos de algunas cadenas de consulta básicas. El código real difiere según la biblioteca cliente que uses para la búsqueda.

También debes escapar los caracteres especiales en los nombres de tus archivos para asegurarte de que el la consulta funciona correctamente. Por ejemplo, si el nombre de un archivo contiene un apóstrofo (') y un carácter de barra inversa ("\"), usa una barra inversa para escapar de ellos: name contains 'quinn\'s paper\\essay'.

Qué quieres consultar Ejemplo
Archivos con el nombre "hello" name = 'hello'
Archivos con un nombre que contenga las palabras "hello" y "adiós" name contains 'hello' and name contains 'goodbye'
Archivos con un nombre que no contiene la palabra "hello" not name contains 'hello'
Archivos que contienen el texto "importante" y en la papelera fullText contains 'important' and trashed = true
Archivos que contienen la palabra "hello" fullText contains 'hello'
Archivos que no contienen la palabra "hello" not fullText contains 'hello'
Archivos que contienen la frase exacta "hello world" fullText contains '"hello world"'
Archivos con una consulta que contiene el "\" carácter (por ejemplo, "\authors") fullText contains '\\authors'
Archivos que son carpetas mimeType = 'application/vnd.google-apps.folder'
Archivos que no son carpetas mimeType != 'application/vnd.google-apps.folder'
Archivos modificados después de una fecha determinada (la zona horaria predeterminada es UTC). modifiedTime > '2012-06-04T12:00:00'
Archivos de imagen o video modificados después de una fecha específica modifiedTime > '2012-06-04T12:00:00' and (mimeType contains 'image/' or mimeType contains 'video/')
Archivos destacados starred = true
Archivos dentro de una colección (por ejemplo, el ID de la carpeta en la colección parents) '1234567' in parents
Archivos en una carpeta de datos de aplicación en una colección 'appDataFolder' in parents
Archivos para los que el usuario "test@example.org" es el propietario 'test@example.org' in owners
Archivos para los que el usuario "test@example.org" tiene permiso de escritura 'test@example.org' in writers
Archivos para los miembros del grupo "group@example.org" tener permiso de escritura 'group@example.org' in writers
Archivos compartidos con el usuario autorizado con el mensaje "hello" en el nombre sharedWithMe and name contains 'hello'
Archivos con una propiedad de archivo personalizada visibles para todas las apps properties has { key='mass' and value='1.3kg' }
Archivos con una propiedad de archivo personalizada y privada para la app solicitante appProperties has { key='additionalID' and value='8e8aceg2af2ge72e78' }
Archivos que no se compartieron con nadie ni con dominios (solo privados o que no se hayan compartido con usuarios o grupos específicos). visibility = 'limited'

Filtra los resultados de la búsqueda con una biblioteca cliente

En la siguiente muestra de código, se indica cómo usar una biblioteca cliente para filtrar la búsqueda resultados a los nombres de archivo e ID de los archivos JPEG. En esta muestra, se usa mimeType. término de búsqueda para limitar los resultados a archivos de tipo image/jpeg. También establece spaces a drive para limitar aún más la búsqueda a Drive espacio. Cuando nextPageToken muestra null, no hay más resultados.

Java

drive/snippets/drive_v3/src/main/java/SearchFile.java
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.api.services.drive.model.FileList;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/* Class to demonstrate use-case of search files. */
public class SearchFile {

  /**
   * Search for specific set of files.
   *
   * @return search result list.
   * @throws IOException if service account credentials file not found.
   */
  public static List<File> searchFile() 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();

    List<File> files = new ArrayList<File>();

    String pageToken = null;
    do {
      FileList result = service.files().list()
          .setQ("mimeType='image/jpeg'")
          .setSpaces("drive")
          .setFields("nextPageToken, items(id, title)")
          .setPageToken(pageToken)
          .execute();
      for (File file : result.getFiles()) {
        System.out.printf("Found file: %s (%s)\n",
            file.getName(), file.getId());
      }

      files.addAll(result.getFiles());

      pageToken = result.getNextPageToken();
    } while (pageToken != null);

    return files;
  }
}

Python

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


def search_file():
  """Search file in drive location

  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)
    files = []
    page_token = None
    while True:
      # pylint: disable=maybe-no-member
      response = (
          service.files()
          .list(
              q="mimeType='image/jpeg'",
              spaces="drive",
              fields="nextPageToken, files(id, name)",
              pageToken=page_token,
          )
          .execute()
      )
      for file in response.get("files", []):
        # Process change
        print(f'Found file: {file.get("name")}, {file.get("id")}')
      files.extend(response.get("files", []))
      page_token = response.get("nextPageToken", None)
      if page_token is None:
        break

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

  return files


if __name__ == "__main__":
  search_file()

Node.js

drive/snippets/drive_v3/file_snippets/search_file.js
/**
 * Search file in drive location
 * @return{obj} data file
 * */
async function searchFile() {
  const {GoogleAuth} = require('google-auth-library');
  const {google} = require('googleapis');

  // Get credentials and build service
  // TODO (developer) - Use appropriate auth mechanism for your app
  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/drive',
  });
  const service = google.drive({version: 'v3', auth});
  const files = [];
  try {
    const res = await service.files.list({
      q: 'mimeType=\'image/jpeg\'',
      fields: 'nextPageToken, files(id, name)',
      spaces: 'drive',
    });
    Array.prototype.push.apply(files, res.files);
    res.data.files.forEach(function(file) {
      console.log('Found file:', file.name, file.id);
    });
    return res.data.files;
  } catch (err) {
    // TODO(developer) - Handle error
    throw err;
  }
}

PHP

drive/snippets/drive_v3/src/DriveSearchFiles.php
use Google\Client;
use Google\Service\Drive;
function searchFiles()
{
    try {
        $client = new Client();
        $client->useApplicationDefaultCredentials();
        $client->addScope(Drive::DRIVE);
        $driveService = new Drive($client);
        $files = array();
        $pageToken = null;
        do {
            $response = $driveService->files->listFiles(array(
                'q' => "mimeType='image/jpeg'",
                'spaces' => 'drive',
                'pageToken' => $pageToken,
                'fields' => 'nextPageToken, files(id, name)',
            ));
            foreach ($response->files as $file) {
                printf("Found file: %s (%s)\n", $file->name, $file->id);
            }
            array_push($files, $response->files);

            $pageToken = $response->pageToken;
        } while ($pageToken != null);
        return $files;
    } catch(Exception $e) {
       echo "Error Message: ".$e;
    }
}

Busca archivos con una propiedad de archivo personalizada

Para buscar archivos con una propiedad de archivo personalizada, usa properties o el término de búsqueda de appProperties con una clave y un valor. Por ejemplo, para Busca una propiedad de archivo personalizado que sea privada para la app solicitante llamada additionalID con un valor de 8e8aceg2af2ge72e78:

appProperties has { key='additionalID' and value='8e8aceg2af2ge72e78' }

Para obtener más información, consulta Cómo agregar un archivo personalizado. propiedades.

Busca archivos con un valor de campo o etiqueta específico

Para buscar archivos con etiquetas específicas, usa el término de búsqueda labels con un ID de etiqueta específico. Por ejemplo: 'labels/LABEL_ID' in labels. Si el proceso es satisfactorio, el cuerpo de la respuesta contendrá todas las instancias de archivo a las que etiqueta.

Para buscar archivos sin un ID de etiqueta específico: Not 'labels/LABEL_ID' in labels.

También puedes buscar archivos según valores de campo específicos. Por ejemplo, para Buscar archivos con un valor de texto: labels/LABEL_ID.text_field_id ='TEXT'

Para obtener más información, consulta Cómo buscar archivos con una etiqueta o un campo específicos. predeterminado.

Buscar en el corpus

Las búsquedas que llaman a files.list usan el elemento corpora de user de forma predeterminada. Cómo realizar búsquedas otro corpus, como los archivos compartidos con un domain, establece el corpora parámetro.

Se pueden buscar múltiples corpus en una sola consulta, aunque los resultados están incompletos. puede mostrarse si el corpus combinado es demasiado grande. Si incompleteSearch es true en el cuerpo de la respuesta, no se mostraron todos los documentos. Si esta debes acotar tu consulta eligiendo un corpus diferente, como user o drive.