Detecta idiomas (Advanced)

En este documento, se describe cómo usar Cloud Translation Advanced para detectar el idioma de una string.

Nota: Consulta Migra a Translation Advanced para obtener detalles sobre las diferencias entre el nivel básico y el avanzado.

Antes de comenzar

Antes de comenzar a usar la API de Cloud Translation, debes tener un proyecto que tenga habilitada esta API y una clave privada con las credenciales adecuadas. También puedes instalar bibliotecas cliente para los lenguajes de programación comunes que te ayudarán a realizar llamadas a la API. Para obtener más información, consulta la página Configuración.

Detecta el idioma de una string de texto

Para detectar el idioma de una string de texto, envía una solicitud HTTP con una URL del siguiente formato:

https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/global:detectLanguage

Nota: project-id también funciona, pero se recomienda usar project-number en el futuro.

Detecta el idioma de una sola string

LÍNEA DE REST Y CMD

Para detectar el idioma de un texto, realiza una solicitud POST y proporciona el cuerpo de la solicitud correspondiente. A continuación, se muestra un ejemplo de una solicitud POST mediante curl y PowerShell. En el ejemplo, se usa el token de acceso correspondiente a la configuración de una cuenta de servicio para el proyecto mediante el SDK de Cloud de Google Cloud. Si deseas obtener instrucciones para instalar el SDK de Cloud, configurar un proyecto con una cuenta de servicio y obtener un token de acceso, consulta la página Configuración.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

• PROJECT_NUMBER_OR_ID: el número o ID de tu proyecto de Google Cloud

Método HTTP y URL:

POST https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/global:detectLanguage

Cuerpo JSON de la solicitud:

{
   "content":"Доктор Ватсон, иди сюда!"
}

Para enviar tu solicitud, elige una de estas opciones:

curl

Nota: Asegúrate de haber configurado la variable de entorno GOOGLE_APPLICATION_CREDENTIALS a la ruta para el archivo de clave privada de tu cuenta de servicio.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
"https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/global:detectLanguage
"

PowerShell

Nota: Asegúrate de haber configurado la variable de entorno GOOGLE_APPLICATION_CREDENTIALS a la ruta para el archivo de clave privada de tu cuenta de servicio.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
  -Method POST `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -InFile request.json `
  -Uri "https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/global:detectLanguage
" | Select-Object -Expand Content

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "languages": [
    {
      "languageCode": "ru",
      "confidence": 1
    }
  ]
}

En la respuesta, languageCode proporciona el código del idioma detectado. confidence es un rango entre 0 y 1. 1 corresponde al 100% de seguridad.

Comienza a usarlo

Antes de probar este ejemplo, sigue las instrucciones de configuración de Go que encontrarás en la guía de inicio rápido sobre las bibliotecas cliente de Translation. Si deseas obtener más información, consulta la documentación de referencia de la API de Translation para Go.

Ver en GitHubComentarios

import (
	"context"
	"fmt"
	"io"

	translate "cloud.google.com/go/translate/apiv3"
	translatepb "google.golang.org/genproto/googleapis/cloud/translate/v3"
)

// detectLanguage detects the language of a text string.
func detectLanguage(w io.Writer, projectID string, text string) error {
	// projectID := "my-project-id"
	// text := "Hello, world!"

	ctx := context.Background()
	client, err := translate.NewTranslationClient(ctx)
	if err != nil {
		return fmt.Errorf("NewTranslationClient: %v", err)
	}
	defer client.Close()

	req := &translatepb.DetectLanguageRequest{
		Parent:   fmt.Sprintf("projects/%s/locations/global", projectID),
		MimeType: "text/plain", // Mime types: "text/plain", "text/html"
		Source: &translatepb.DetectLanguageRequest_Content{
			Content: text,
		},
	}

	resp, err := client.DetectLanguage(ctx, req)
	if err != nil {
		return fmt.Errorf("DetectLanguage: %v", err)
	}

	// Display list of detected languages sorted by detection confidence.
	// The most probable language is first.
	for _, language := range resp.GetLanguages() {
		// The language detected.
		fmt.Fprintf(w, "Language code: %v\n", language.GetLanguageCode())
		// Confidence of detection result for this language.
		fmt.Fprintf(w, "Confidence: %v\n", language.GetConfidence())
	}

	return nil
}

Java

Antes de probar este ejemplo, sigue las instrucciones de configuración para Java que encontrarás en la guía de inicio rápido sobre las bibliotecas cliente de Translation. Si deseas obtener más información, consulta la documentación de referencia de la API de Translation para Java.

Ver en GitHubComentarios

import com.google.cloud.translate.v3.DetectLanguageRequest;
import com.google.cloud.translate.v3.DetectLanguageResponse;
import com.google.cloud.translate.v3.DetectedLanguage;
import com.google.cloud.translate.v3.LocationName;
import com.google.cloud.translate.v3.TranslationServiceClient;
import java.io.IOException;

public class DetectLanguage {

  public static void detectLanguage() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR-PROJECT-ID";
    String text = "your-text";

    detectLanguage(projectId, text);
  }

  // Detecting the language of a text string
  public static void detectLanguage(String projectId, String text) throws IOException {

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (TranslationServiceClient client = TranslationServiceClient.create()) {
      // Supported Locations: `global`, [glossary location], or [model location]
      // Glossaries must be hosted in `us-central1`
      // Custom Models must use the same location as your model. (us-central1)
      LocationName parent = LocationName.of(projectId, "global");

      // Supported Mime Types: https://cloud.google.com/translate/docs/supported-formats
      DetectLanguageRequest request =
          DetectLanguageRequest.newBuilder()
              .setParent(parent.toString())
              .setMimeType("text/plain")
              .setContent(text)
              .build();

      DetectLanguageResponse response = client.detectLanguage(request);

      // Display list of detected languages sorted by detection confidence.
      // The most probable language is first.
      for (DetectedLanguage language : response.getLanguagesList()) {
        // The language detected
        System.out.printf("Language code: %s\n", language.getLanguageCode());
        // Confidence of detection result for this language
        System.out.printf("Confidence: %s\n", language.getConfidence());
      }
    }
  }
}

Node.js

Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js que encontrarás en la guía de inicio rápido sobre las bibliotecas cliente de Translation. Si deseas obtener más información, consulta la documentación de referencia de la API de Translation para Node.js.

Ver en GitHubComentarios

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'global';
// const text = 'text to translate';

// Imports the Google Cloud Translation library
const {TranslationServiceClient} = require('@google-cloud/translate');

// Instantiates a client
const translationClient = new TranslationServiceClient();

async function detectLanguage() {
  // Construct request
  const request = {
    parent: `projects/${projectId}/locations/${location}`,
    content: text,
  };

  // Run request
  const [response] = await translationClient.detectLanguage(request);

  console.log('Detected Languages:');
  for (const language of response.languages) {
    console.log(`Language Code: ${language.languageCode}`);
    console.log(`Confidence: ${language.confidence}`);
  }
}

detectLanguage();

Python

Antes de probar este ejemplo, sigue las instrucciones de configuración para Python que encontrarás en la guía de inicio rápido sobre las bibliotecas cliente de Translation. Si deseas obtener más información, consulta la documentación de referencia de la API de Translation para Python.

Ver en GitHubComentarios

from google.cloud import translate

def detect_language(project_id="YOUR_PROJECT_ID"):
    """Detecting the language of a text string."""

    client = translate.TranslationServiceClient()

    location = "global"

    parent = f"projects/{project_id}/locations/{location}"

    # Detail on supported types can be found here:
    # https://cloud.google.com/translate/docs/supported-formats
    response = client.detect_language(
        content="Hello, world!",
        parent=parent,
        mime_type="text/plain",  # mime types: text/plain, text/html
    )

    # Display list of detected languages sorted by detection confidence.
    # The most probable language is first.
    for language in response.languages:
        # The language detected
        print("Language code: {}".format(language.language_code))
        # Confidence of detection result for this language
        print("Confidence: {}".format(language.confidence))

Lenguajes adicionales

C#: Sigue las Instrucciones de configuración de C# en la página de bibliotecas cliente y, luego, visita la Documentación de referencia de Translation para .NET.

PHP: Sigue las Instrucciones de configuración de PHP en la página de bibliotecas cliente y, luego, visita la Documentación de referencia de Translation para PHP.

Ruby: Sigue las Instrucciones de configuración de Ruby en la página de bibliotecas cliente y, luego, visita la Documentación de referencia de Translation para Ruby.

Recursos adicionales

• Para obtener ayuda en la resolución de errores o problemas habituales, consulta la página Solución de problemas.