Detecta idiomas (Advanced)

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

Antes de comenzar

Antes de comenzar a usar la API de Cloud Translation, debes tener un proyecto que tenga habilitada la API de Cloud Translation y 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

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

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

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.

C#

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


using Google.Api.Gax.ResourceNames;
using Google.Cloud.Translate.V3;
using System;

namespace GoogleCloudSamples
{
    public static class DetectLanguage
    {
        /// <summary>
        /// Detects the language of a given text.
        /// </summary>
        /// <param name="text">The text string for performing language detection</param>
        /// <param name="projectId">Your Google Cloud Project ID.</param>
        public static void DetectLanguageSample(string text = "[TEXT_STRING_FOR_DETECTION]",
            string projectId = "[Google Cloud Project ID]")
        {
            TranslationServiceClient translationServiceClient = TranslationServiceClient.Create();
            DetectLanguageRequest request = new DetectLanguageRequest
            {
                ParentAsLocationName = new LocationName(projectId, "global"),
                Content = text,
                MimeType = "text/plain",
            };
            DetectLanguageResponse response = translationServiceClient.DetectLanguage(request);
            // Display list of detected languages sorted by detection confidence.
            // The most probable language is first.
            foreach (DetectedLanguage language in response.Languages)
            {
                // The language detected
                Console.WriteLine($"Language code: {language.LanguageCode}");
                // Confidence of detection result for this language
                Console.WriteLine($"Confidence: {language.Confidence}");
            }
        }
    }

Go

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

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 código de muestra, 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.

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 código de muestra, 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 quieres obtener más información, consulta la documentación de referencia de la API de Translation para Node.js.

/**
 * 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,
  };

  try {
    // 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}`);
    }
  } catch (error) {
    console.error(error.details);
  }
}

detectLanguage();

PHP

Antes de probar este código de muestra, sigue las instrucciones de configuración para PHP 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 PHP.

use Google\Cloud\Translate\V3\TranslationServiceClient;

$translationServiceClient = new TranslationServiceClient();

/** Uncomment and populate these variables in your code */
// $text = 'Hello, world!';
// $projectId = '[Google Cloud Project ID]';
$formattedParent = $translationServiceClient->locationName($projectId, 'global');

// Optional. Can be "text/plain" or "text/html".
$mimeType = 'text/plain';

try {
    $response = $translationServiceClient->detectLanguage(
        $formattedParent,
        [
            'content' => $text,
            'mimeType' => $mimeType
        ]
    );
    // Display list of detected languages sorted by detection confidence.
    // The most probable language is first.
    foreach ($response->getLanguages() as $language) {
        // The language detected
        printf('Language code: %s' . PHP_EOL, $language->getLanguageCode());
        // Confidence of detection result for this language
        printf('Confidence: %s' . PHP_EOL, $language->getConfidence());
    }
} finally {
    $translationServiceClient->close();
}

Python

Antes de probar este código de muestra, 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.

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))

Ruby

Antes de probar este código de muestra, sigue las instrucciones de configuración para Ruby 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 Ruby.

require "google/cloud/translate"

# project_id = "[Google Cloud Project ID]"
# location_id = "[LOCATION ID]"

client = Google::Cloud::Translate.translation_service

# The text string for performing language detection
content = "Hello, world!"
# Optional. Can be "text/plain" or "text/html".
mime_type = "text/plain"

parent = client.location_path project: project_id, location: location_id

response = client.detect_language parent:    parent,
                                  content:   content,
                                  mime_type: mime_type

# Display list of detected languages sorted by detection confidence.
# The most probable language is first.
response.languages.each do |language|
  # The language detected
  puts "Language Code: #{language.language_code}"
  # Confidence of detection result for this language
  puts "Confidence: #{language.confidence}"
end