Zu Translation Advanced migrieren

Auf dieser Seite werden die wichtigsten Unterschiede zwischen Cloud Translation Basic und Cloud Translation Advanced beschrieben. Sie enthält auch einige Codebeispiele zur Migration Ihrer Anwendung. Wenn Sie nur die Features in Cloud Translation Advanced (z. B. Glossare) aufrufen möchten, lesen Sie den Artikel Einführung in Cloud Translation Advanced.

Cloud Translation Advanced unterstützt alle in Basic verfügbaren Features und Modelle. Die Clientbibliotheken unterstützen jedoch nicht die Abwärtskompatibilität der Clientintegration. Wenn Sie von den Features von Cloud Translation Advanced profitieren möchten, müssen Sie die Migration Ihrer Anwendungen entsprechend planen.

Bei einem neuen Projekt empfehlen wir, Ihre Anwendung bereits mit Cloud Translation Advanced zu erstellen. Damit steht Ihnen eine Reihe neuer Features und verbesserter Dienste zur Verfügung. Cloud Translation Basic ist weiterhin verfügbar, unterstützt allerdings keine neuen Features wie Glossare, Batchübersetzung oder Modellauswahl.

Wichtige Unterschiede zwischen Basic und Advanced

Zwischen Cloud Translation Advanced und der Basic-Version gibt es mehrere Unterschiede.

Dienstkonten

Mit Cloud Translation Basic können Sie API-Schlüssel verwenden, um sich bei Translation zu authentifizieren.

Cloud Translation Advanced enthält Features, für die vom Kunden verwaltete Ressourcen benötigt werden. Für diese Ressourcen ist die Verwaltung von IAM-Rollen und Berechtigungen erforderlich. Sie können sich deshalb nicht mit API-Schlüsseln beim Dienst authentifizieren. Stattdessen müssen Sie Dienstkonten für die Authentifizierung bei Translation verwenden.

IAM-Rollen

Bisher waren für Dienstkonten keine speziellen IAM-Rollen zur Authentifizierung bei Translation erforderlich.

Cloud Translation Advanced bietet verschiedene IAM-Rollen, die Sie Ihrem Dienstkonto für den Zugriff auf bestimmte Ressourcen im Projekt zuweisen können. Wenn Sie beispielsweise Ihr Dienstkonto zum Übersetzen von Text verwenden möchten, weisen Sie ihm die Rolle roles/cloudtranslate.user zu. Weitere Informationen zu den verfügbaren IAM-Rollen finden Sie unter Einführung in Cloud Translation Advanced.

Ressourcen, Projekte und Standorte

Wenn Sie Anfragen an Cloud Translation Advanced stellen, müssen Sie den Namen der Ressourcen angeben, die Sie verwenden möchten. Eine Ressource ist in der Regel ein qualifizierter Name, der den Namen des Projekts und seinen Standort enthält. Ein Ressourcenname wird benötigt, wenn Sie ein Übersetzungsmodell angeben, ein AutoML-Modell verwenden oder eine REST-Methode aufrufen.

Wenn Ihr Google Cloud-Projekt beispielsweise den Namen my-project hat und der Standort für die Ressource us-central1 lautet, könnte der vollständige Name Ihrer Ressourcen so aussehen:

projects/my-project/locations/us-central1/...

Der Standortname wird auch in der URL verwendet, der Sie REST-Anfragen senden. Mit dem Standort wird festgelegt, wo die Anfrage ausgeführt wird. Beispielsweise lautet die URL, an die Sie eine getSupportedLanguages-Anfrage senden, in etwa so:

https://translation.googleapis.com/v3/projects/my-project/locations/us-central1/supportedLanguages

Übersetzungsmodelle

Wenn Sie eine Anfrage für eine Übersetzung an Cloud Translation Advanced stellen, müssen Sie angeben, welches Übersetzungsmodell verwendet werden soll. Sie können ein benutzerdefiniertes AutoML Translation-Modell, ein allgemeines NMÜ-Modell (neuronale maschinelle Übersetzung) oder ein allgemeines PBMT-Modell (Phrase-Based Machine Translation) nutzen. Weitere Informationen finden Sie unter Text übersetzen.

Für die Einbindung in AutoML-Modelle ist es erforderlich, dass die für Übersetzungsanfragen verwendeten Dienstkonten die geeigneten IAM-Berechtigungen haben, um auf AutoML und allgemeine Modelle zuzugreifen. Das gilt unabhängig davon, ob die Berechtigungen in Ihrem oder einem anderen Projekt definiert sind.

Weitere Informationen zum Auswählen eines Übersetzungsmodells finden Sie unter Übersetzung von Text mit Cloud Translation Advanced.

Mit den folgenden Schritten können Sie ein Update Ihrer Anwendung von Cloud Translation Basic auf Cloud Translation Advanced ausführen.

  1. Stellen Sie Ihre Google Cloud-Projekte, -Anwendungen und -Nutzer fest, die auf die Basic API zugreifen.
  2. Richten Sie Dienstkonten und die Authentifizierung für Ihre Anwendung ein. Überprüfen Sie die IAM-Rollen und berücksichtigen Sie dabei insbesondere die Rollen für AutoML, Cloud Storage und Cloud Translation.
  3. Aktivieren Sie Cloud Translation Advanced für Ihr Projekt. Wenn Sie AutoML-Modelle mit Cloud Translation Advanced verwenden, müssen Sie auch AutoML aktivieren.
  4. Vergleichen Sie die Unterschiede zwischen Cloud Translation Basic und Cloud Translation Advanced.
  5. Aktualisieren Sie Ihren Anwendungs- oder Übersetzungs-Workflow, um die neuen Features zu nutzen. Zur Einbindung Ihrer Anwendung in AutoML und Cloud Storage müssen Sie die geeigneten IAM-Rollen und -Berechtigungen für Ihre Dienstkonten festlegen, damit diese auf Ihre Ressourcen zugreifen können.
  6. Planen Sie das Monitoring Ihres Kontingents für Übersetzungsanfragen. Für beide Versionen der API gelten die gleichen Tages- und Monatskontingente.
  7. Prüfen Sie die Abrechnung auf mögliche Änderungen.

Unterschiede bei APIs und Clientbibliotheken

In den folgenden Abschnitten werden bestimmte Unterschiede zwischen Cloud Translation Basic und Cloud Translation API Advanced erläutert.

Cloud Translation Advanced-Clientbibliotheken importieren

Verwenden Sie den folgenden Code, um die Cloud Translation Advanced-Clientbibliotheken zu importieren.

C#

nuget install Google.Cloud.Translate.V3 -Pre

Go

go get -u cloud.google.com/go/translate/apiv3

Java

Bei Verwendung von <a href="https://maven.apache.org/" class="external" track-type="buildTools" track-name="externalLink" target="_blank">Maven</a> fügen Sie Ihrer Datei <code>pom.xml</code> Folgendes hinzu:<div class="github-docwidget-gitinclude-code"> <pre suppresswarning="suppresswarning" translate="no" style="margin: 10px 0;" class="prettyprint" track-metadata-position="googleapis/java-translate/README.md/master/```xml[^`]*```" data-code-snippet="true" data-github-path="googleapis/java-translate/README.md" data-git-revision="master" data-regexp="```xml[^`]*```"><code>&lt;dependencyManagement&gt; &lt;dependencies&gt; &lt;dependency&gt; &lt;groupId&gt;com.google.cloud&lt;/groupId&gt; &lt;artifactId&gt;libraries-bom&lt;/artifactId&gt; &lt;version&gt;2.8.0&lt;/version&gt; &lt;type&gt;pom&lt;/type&gt; &lt;scope&gt;import&lt;/scope&gt; &lt;/dependency&gt; &lt;/dependencies&gt; &lt;/dependencyManagement&gt; &lt;dependency&gt; &lt;groupId&gt;com.google.cloud&lt;/groupId&gt; &lt;artifactId&gt;google-cloud-translate&lt;/artifactId&gt; &lt;/dependency&gt;</code></pre> </div>Bei Verwendung von <a href="https://gradle.org/" class="external" track-type="buildTools" track-name="externalLink" target="_blank">Gradle</a> fügen Sie den Abhängigkeiten Folgendes hinzu:<div class="github-docwidget-gitinclude-code"> <pre suppresswarning="suppresswarning" translate="no" style="margin: 10px 0;" class="prettyprint" track-metadata-position="googleapis/java-translate/README.md/master/```Groovy[^`]*```" data-code-snippet="true" data-github-path="googleapis/java-translate/README.md" data-git-revision="master" data-regexp="```Groovy[^`]*```"><code>compile &#39;com.google.cloud:google-cloud-translate:1.94.0&#39;</code></pre> </div>Bei Verwendung von <a href="https://www.scala-sbt.org/" class="external" track-type="buildTools" track-name="externalLink" target="_blank">SBT</a> fügen Sie den Abhängigkeiten Folgendes hinzu:<div class="github-docwidget-gitinclude-code"> <pre suppresswarning="suppresswarning" translate="no" style="margin: 10px 0;" class="prettyprint" track-metadata-position="googleapis/java-translate/README.md/master/```Scala[^`]*```" data-code-snippet="true" data-github-path="googleapis/java-translate/README.md" data-git-revision="master" data-regexp="```Scala[^`]*```"><code>libraryDependencies += &quot;com.google.cloud&quot; % &quot;google-cloud-translate&quot; % &quot;1.94.0&quot;</code></pre> </div> <p>Bei Verwendung von IntelliJ oder Eclipse können Sie Ihrem Projekt mithilfe der folgenden IDE-Plug-ins Clientbibliotheken hinzufügen:</p><ul><li><a href="/tools/intellij/docs/client-libraries" target="_blank">Cloud Code for IntelliJ</a></li> <li><a href="/eclipse/docs/libraries" target="_blank">Cloudtools for Eclipse</a></li></ul><p>Diese Plug-ins bieten zusätzliche Funktionen wie z. B. die Schlüsselverwaltung für Dienstkonten. Ausführliche Informationen finden Sie in der Dokumentation der einzelnen Plug-ins.</p> <aside class="note"><strong>Hinweis</strong>: Cloud-Java-Clientbibliotheken unterstützen derzeit Android nicht.</aside>

Node.js

Weitere Informationen zur Einrichtung der Node.js-Entwicklungsumgebung finden Sie im Einrichtungsleitfaden für die Node.js-Entwicklungsumgebung.

npm install --save @google-cloud/translate

PHP

composer install google/cloud-translate

Python

Weitere Informationen zur Einrichtung der Python-Entwicklungsumgebung finden Sie im Einrichtungsleitfaden für die Python-Entwicklungsumgebung.

pip install --upgrade google-cloud-translate

Ruby

Weitere Informationen zur Einrichtung der Ruby-Entwicklungsumgebung finden Sie im Einrichtungsleitfaden für die Ruby-Entwicklungsumgebung.

gem install google-cloud-translate

Text übersetzen

Mit Cloud Translation Basic können Sie den folgenden Code verwenden, um eine Übersetzungsanfrage an die API zu senden:

REST UND BEFEHLSZEILE

HTTP-Methode und URL:

POST https://translation.googleapis.com/language/translate/v2

JSON-Text der Anfrage:

{
  "q": ["Hello world", "My name is Jeff"],
  "target": "de"
}

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

curl

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus:

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/language/translate/v2

PowerShell

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus:

$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/language/translate/v2 " | Select-Object -Expand Content

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

{
  "data": {
    "translations": [
      {
        "translatedText": "Hallo Welt",
        "detectedSourceLanguage": "en"
      },
      {
        "translatedText": "Mein Name ist Jeff",
        "detectedSourceLanguage": "en"
      }
    ]
  }
}

C#

Folgen Sie der Einrichtungsanleitung für C# unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für C#.


using Google.Cloud.Translation.V2;
using System;

public partial class TranslateSample
{
    public string TranslateText()
    {
        TranslationClient client = TranslationClient.Create();
        var response = client.TranslateText(
            text: "Hello World.",
            targetLanguage: "ru",  // Russian
            sourceLanguage: "en");  // English
        Console.WriteLine(response.TranslatedText);
        return response.TranslatedText;
    }
}

Go

Folgen Sie der Einrichtungsanleitung für Go unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für Go.

import (
	"context"
	"fmt"

	"cloud.google.com/go/translate"
	"golang.org/x/text/language"
)

func translateText(targetLanguage, text string) (string, error) {
	// text := "The Go Gopher is cute"
	ctx := context.Background()

	lang, err := language.Parse(targetLanguage)
	if err != nil {
		return "", fmt.Errorf("language.Parse: %v", err)
	}

	client, err := translate.NewClient(ctx)
	if err != nil {
		return "", err
	}
	defer client.Close()

	resp, err := client.Translate(ctx, []string{text}, lang, nil)
	if err != nil {
		return "", fmt.Errorf("Translate: %v", err)
	}
	if len(resp) == 0 {
		return "", fmt.Errorf("Translate returned empty response to text: %s", text)
	}
	return resp[0].Text, nil
}

Java

Folgen Sie der Einrichtungsanleitung für Java unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für Java.

// TODO(developer): Uncomment these lines.
// import com.google.cloud.translate.*;
// Translate translate = TranslateOptions.getDefaultInstance().getService();

Translation translation = translate.translate("¡Hola Mundo!");
System.out.printf("Translated Text:\n\t%s\n", translation.getTranslatedText());

Node.js

Folgen Sie der Einrichtungsanleitung für Node.js unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für Node.js.

// Imports the Google Cloud client library
const {Translate} = require('@google-cloud/translate').v2;

// Creates a client
const translate = new Translate();

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const text = 'The text to translate, e.g. Hello, world!';
// const target = 'The target language, e.g. ru';

async function translateText() {
  // Translates the text into the target language. "text" can be a string for
  // translating a single piece of text, or an array of strings for translating
  // multiple texts.
  let [translations] = await translate.translate(text, target);
  translations = Array.isArray(translations) ? translations : [translations];
  console.log('Translations:');
  translations.forEach((translation, i) => {
    console.log(`${text[i]} => (${target}) ${translation}`);
  });
}

translateText();

PHP

Folgen Sie der Einrichtungsanleitung für PHP unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für PHP.

use Google\Cloud\Translate\TranslateClient;

/** Uncomment and populate these variables in your code */
// $text = 'The text to translate."
// $targetLanguage = 'ja';  // Language to translate to

$translate = new TranslateClient();
$result = $translate->translate($text, [
    'target' => $targetLanguage,
]);
print("Source language: $result[source]\n");
print("Translation: $result[text]\n");

Python

Folgen Sie der Einrichtungsanleitung für Python unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für Python.

"""Translates text into the target language.

Target must be an ISO 639-1 language code.
See https://g.co/cloud/translate/v2/translate-reference#supported_languages
"""
from google.cloud import translate_v2 as translate
translate_client = translate.Client()

if isinstance(text, six.binary_type):
    text = text.decode('utf-8')

# Text can also be a sequence of strings, in which case this method
# will return a sequence of results for each text.
result = translate_client.translate(
    text, target_language=target)

print(u'Text: {}'.format(result['input']))
print(u'Translation: {}'.format(result['translatedText']))
print(u'Detected source language: {}'.format(
    result['detectedSourceLanguage']))

Ruby

Folgen Sie der Einrichtungsanleitung für Ruby unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für Ruby.

# project_id    = "Your Google Cloud project ID"
# text          = "The text you would like to translate"
# language_code = "The ISO 639-1 code of language to translate to, eg. 'en'"

require "google/cloud/translate"

translate   = Google::Cloud::Translate.new version: :v2, project_id: project_id
translation = translate.translate text, to: language_code

puts "Translated '#{text}' to '#{translation.text.inspect}'"
puts "Original language: #{translation.from} translated to: #{translation.to}"

Bei Cloud Translation Advanced müssen Sie die Projektnummer oder Projekt-ID und den Projektstandort angeben, wenn Sie eine translateText-Anfrage erstellen – in der Regel global oder us-central1.

Sie können auch explizit ein Übersetzungsmodell oder ein Glossar angeben, das beim Übersetzen des Textes verwendet werden soll. Außerdem haben Sie die Möglichkeit, für die Ausgabe der Übersetzung zwischen text/plain und text/html auszuwählen. Der Standardwert ist text/html.

REST UND BEFEHLSZEILE

Bevor Sie die unten aufgeführten Anfragedaten verwenden, ersetzen Sie den folgenden Wert:

  • project-number-or-id: Projektnummer oder ID Ihres GCP-Projekts

HTTP-Methode und URL:

POST https://translation.googleapis.com/v3/projects/project-number-or-id:translateText

JSON-Text der Anfrage:

{
  "sourceLanguageCode": "en",
  "targetLanguageCode": "ru",
  "contents": ["Dr. Watson, come here!", "Bring me some coffee!"]
}

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

curl

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus:

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:translateText

PowerShell

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus:

$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:translateText " | Select-Object -Expand Content

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

{
  "translations": [
    {
      "translatedText": "Доктор Ватсон, иди сюда!",
    },
    {
      "translatedText": "Принеси мне кофе!",
    }
  ]
}

C#

Folgen Sie der Einrichtungsanleitung für C# unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für C#.


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

namespace GoogleCloudSamples
{
    public static class TranslateText
    {
        /// <summary>
        /// Translates a given text to a target language.
        /// </summary>
        /// <param name="text">The content to translate.</param>
        /// <param name="targetLanguage">Required. Target language code.</param>
        /// <param name="projectId">Your Google Cloud Project ID.</param>
        public static void TranslateTextSample(string text = "[TEXT_TO_TRANSLATE]",
            string targetLanguage = "ja",
            string projectId = "[Google Cloud Project ID]")
        {
            TranslationServiceClient translationServiceClient = TranslationServiceClient.Create();
            TranslateTextRequest request = new TranslateTextRequest
            {
                Contents =
                {
                    // The content to translate.
                    text,
                },
                TargetLanguageCode = targetLanguage,
                ParentAsLocationName = new LocationName(projectId, "global"),
            };
            TranslateTextResponse response = translationServiceClient.TranslateText(request);
            // Display the translation for each input text provided
            foreach (Translation translation in response.Translations)
            {
                Console.WriteLine($"Translated text: {translation.TranslatedText}");
            }
        }
    }

Go

Folgen Sie der Einrichtungsanleitung für Go unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für Go.

import (
	"context"
	"fmt"
	"io"

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

// translateText translates input text and returns translated text.
func translateText(w io.Writer, projectID string, sourceLang string, targetLang string, text string) error {
	// projectID := "my-project-id"
	// sourceLang := "en-US"
	// targetLang := "fr"
	// text := "Text you wish to translate"

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

	req := &translatepb.TranslateTextRequest{
		Parent:             fmt.Sprintf("projects/%s/locations/global", projectID),
		SourceLanguageCode: sourceLang,
		TargetLanguageCode: targetLang,
		MimeType:           "text/plain", // Mime types: "text/plain", "text/html"
		Contents:           []string{text},
	}

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

	// Display the translation for each input text provided
	for _, translation := range resp.GetTranslations() {
		fmt.Fprintf(w, "Translated text: %v\n", translation.GetTranslatedText())
	}

	return nil
}

Java

Folgen Sie der Einrichtungsanleitung für Java unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für Java.

import com.google.cloud.translate.v3.LocationName;
import com.google.cloud.translate.v3.TranslateTextRequest;
import com.google.cloud.translate.v3.TranslateTextResponse;
import com.google.cloud.translate.v3.Translation;
import com.google.cloud.translate.v3.TranslationServiceClient;

import java.io.IOException;

public class TranslateText {

  public static void translateText() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR-PROJECT-ID";
    // Supported Languages: https://cloud.google.com/translate/docs/languages
    String targetLanguage = "your-target-language";
    String text = "your-text";
    translateText(projectId, targetLanguage, text);
  }

  // Translating Text
  public static void translateText(String projectId, String targetLanguage, 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
      TranslateTextRequest request =
          TranslateTextRequest.newBuilder()
              .setParent(parent.toString())
              .setMimeType("text/plain")
              .setTargetLanguageCode(targetLanguage)
              .addContents(text)
              .build();

      TranslateTextResponse response = client.translateText(request);

      // Display the translation for each input text provided
      for (Translation translation : response.getTranslationsList()) {
        System.out.printf("Translated text: %s\n", translation.getTranslatedText());
      }
    }
  }
}

Node.js

Folgen Sie der Einrichtungsanleitung für Node.js unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für 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 translateText() {
  // Construct request
  const request = {
    parent: `projects/${projectId}/locations/${location}`,
    contents: [text],
    mimeType: 'text/plain', // mime types: text/plain, text/html
    sourceLanguageCode: 'en',
    targetLanguageCode: 'sr-Latn',
  };

  try {
    // Run request
    const [response] = await translationClient.translateText(request);

    for (const translation of response.translations) {
      console.log(`Translation: ${translation.translatedText}`);
    }
  } catch (error) {
    console.error(error.details);
  }
}

translateText();

Python

Folgen Sie der Einrichtungsanleitung für Python unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für Python.

from google.cloud import translate

def sample_translate_text(text, target_language, project_id):
    """
    Translating Text

    Args:
      text The content to translate in string format
      target_language Required. The BCP-47 language code to use for translation.
    """

    client = translate.TranslationServiceClient()

    # TODO(developer): Uncomment and set the following variables
    # text = 'Text you wish to translate'
    # target_language = 'fr'
    # project_id = '[Google Cloud Project ID]'
    contents = [text]
    parent = client.location_path(project_id, "global")

    response = client.translate_text(
        parent=parent,
        contents=contents,
        mime_type='text/plain',  # mime types: text/plain, text/html
        source_language_code='en-US',
        target_language_code=target_language)
    # Display the translation for each input text provided
    for translation in response.translations:
        print(u"Translated text: {}".format(translation.translated_text))

Ruby

Folgen Sie der Einrichtungsanleitung für Ruby unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für Ruby.

require "google/cloud/translate"

client = Google::Cloud::Translate.new

project = "[Google Cloud Project ID]"

# The content to translate in string format
contents = ["Hello, world!"]
# Required. The BCP-47 language code to use for translation.
target_language = "fr"
parent = client.class.location_path project, "global"

response = client.translate_text contents, target_language, parent

# Display the translation for each input text provided
response.translations.each do |translation|
  puts "Translated text: #{translation.translated_text}"
end

Unterstützte Sprachen ermitteln

Mit Cloud Translation Basic können Sie den folgenden Code verwenden, um eine Übersetzungsanfrage an die API zu senden:

REST UND BEFEHLSZEILE

Bevor Sie die unten aufgeführten Anfragedaten verwenden, ersetzen Sie den folgenden Wert:

  • project-number-or-id: Projektnummer oder ID Ihres GCP-Projekts

HTTP-Methode und URL:

GET https://translation.googleapis.com/v3/projects/project-number-or-id/locations/global/supportedLanguages

Senden Sie die Anfrage mithilfe einer der folgenden Optionen:

curl

Führen Sie folgenden Befehl aus:

curl -X GET \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
https://translation.googleapis.com/v3/projects/project-number-or-id/locations/global/supportedLanguages

PowerShell

Führen Sie folgenden Befehl aus:

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

Invoke-WebRequest `
-Method GET `
-Headers $headers `
-Uri "https://translation.googleapis.com/v3/projects/project-number-or-id/locations/global/supportedLanguages " | Select-Object -Expand Content

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

{
  "languages": [
     "languageCode": "af",
      "supportSource": true,
      "supportTarget": true
    },
    {
      "languageCode": "am",
      "supportSource": true,
      "supportTarget": true
    },
    {
      "languageCode": "ar",
      "supportSource": true,
      "supportTarget": true
    },
    ....
    {
      "languageCode": "zu",
      "supportSource": true,
      "supportTarget": true
    }
   ]
}

Die Liste ist alphabetisch nach Sprachcode sortiert. Diese Abfrage gibt die Sprachcodes für unterstützte Sprachen nach ISO-639-1 zurück. Einige enthalten auch einen Ländercode wie zh-CN oder zh-TW. Beispiel:

   {
      "languageCode": "zh-TW",
      "supportSource": true,
      "supportTarget": true
    },

Java

// TODO(developer): Uncomment these lines.
// import com.google.cloud.translate.*;
// Translate translate = TranslateOptions.getDefaultInstance().getService();

List<Language> languages = translate.listSupportedLanguages();

for (Language language : languages) {
  System.out.printf("Name: %s, Code: %s\n", language.getName(), language.getCode());
}

Node.js

// Imports the Google Cloud client library
const {Translate} = require('@google-cloud/translate').v2;

// Creates a client
const translate = new Translate();

async function listLanguages() {
  // Lists available translation language with their names in English (the default).
  const [languages] = await translate.getLanguages();

  console.log('Languages:');
  languages.forEach(language => console.log(language));
}

listLanguages();

Python

"""Lists all available languages."""
from google.cloud import translate_v2 as translate
translate_client = translate.Client()

results = translate_client.get_languages()

for language in results:
    print(u'{name} ({language})'.format(**language))

Bei Cloud Translation Advanced müssen Sie beim Senden einer getSupportedLanguages-Anfrage die Projektnummer oder Projekt-ID und den Projektstandort angeben – in der Regel global oder us-central1.

REST UND BEFEHLSZEILE

Bevor Sie die unten aufgeführten Anfragedaten verwenden, ersetzen Sie den folgenden Wert:

  • project-number-or-id: Projektnummer oder ID Ihres GCP-Projekts

HTTP-Methode und URL:

GET https://translation.googleapis.com/v3/projects/project-number-or-id/locations/global/supportedLanguages

Senden Sie die Anfrage mithilfe einer der folgenden Optionen:

curl

Führen Sie folgenden Befehl aus:

curl -X GET \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
https://translation.googleapis.com/v3/projects/project-number-or-id/locations/global/supportedLanguages

PowerShell

Führen Sie folgenden Befehl aus:

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

Invoke-WebRequest `
-Method GET `
-Headers $headers `
-Uri "https://translation.googleapis.com/v3/projects/project-number-or-id/locations/global/supportedLanguages " | Select-Object -Expand Content

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

{
  "languages": [
     "languageCode": "af",
      "supportSource": true,
      "supportTarget": true
    },
    {
      "languageCode": "am",
      "supportSource": true,
      "supportTarget": true
    },
    {
      "languageCode": "ar",
      "supportSource": true,
      "supportTarget": true
    },
    ....
    {
      "languageCode": "zu",
      "supportSource": true,
      "supportTarget": true
    }
   ]
}

Die Liste ist alphabetisch nach Sprachcode sortiert. Diese Abfrage gibt die Sprachcodes für unterstützte Sprachen nach ISO-639-1 zurück. Einige enthalten auch einen Ländercode wie zh-CN oder zh-TW. Beispiel:

   {
      "languageCode": "zh-TW",
      "supportSource": true,
      "supportTarget": true
    },

C#

Folgen Sie der Einrichtungsanleitung für C# unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für C#.


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

namespace GoogleCloudSamples
{
    public static class GetSupportedLanguages
    {
        /// <summary>
        /// Getting a list of supported language codes
        /// </summary>
        /// <param name="projectId">Your Google Cloud Project ID.</param>
        public static void GetSupportedLanguagesSample(string projectId = "[Google Cloud Project ID]")
        {
            TranslationServiceClient translationServiceClient = TranslationServiceClient.Create();
            GetSupportedLanguagesRequest request = new GetSupportedLanguagesRequest
            {
                ParentAsLocationName = new LocationName(projectId, "global"),
            };
            SupportedLanguages response = translationServiceClient.GetSupportedLanguages(request);
            // List language codes of supported languages
            foreach (SupportedLanguage language in response.Languages)
            {
                Console.WriteLine($"Language Code: {language.LanguageCode}");
            }
        }
    }

Go

Folgen Sie der Einrichtungsanleitung für Go unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für Go.

import (
	"context"
	"fmt"
	"io"

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

// getSupportedLanguages gets a list of supported language codes.
func getSupportedLanguages(w io.Writer, projectID string) error {
	// projectID := "my-project-id"

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

	req := &translatepb.GetSupportedLanguagesRequest{
		Parent: fmt.Sprintf("projects/%s/locations/global", projectID),
	}

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

	// List language codes of supported languages
	fmt.Fprintf(w, "Supported languages:\n")
	for _, language := range resp.GetLanguages() {
		fmt.Fprintf(w, "Language code: %v\n", language.GetLanguageCode())
	}

	return nil
}

Java

Folgen Sie der Einrichtungsanleitung für Java unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für Java.

import com.google.cloud.translate.v3.GetSupportedLanguagesRequest;
import com.google.cloud.translate.v3.LocationName;
import com.google.cloud.translate.v3.SupportedLanguage;
import com.google.cloud.translate.v3.SupportedLanguages;
import com.google.cloud.translate.v3.TranslationServiceClient;

import java.io.IOException;

public class GetSupportedLanguages {

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

  // Getting a list of supported language codes
  public static void getSupportedLanguages(String projectId) 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");
      GetSupportedLanguagesRequest request =
          GetSupportedLanguagesRequest.newBuilder().setParent(parent.toString()).build();

      SupportedLanguages response = client.getSupportedLanguages(request);

      // List language codes of supported languages
      for (SupportedLanguage language : response.getLanguagesList()) {
        System.out.printf("Language Code: %s\n", language.getLanguageCode());
      }
    }
  }
}

Node.js

Folgen Sie der Einrichtungsanleitung für Node.js unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für Node.js.

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

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

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

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

  try {
    // Get supported languages
    const [response] = await translationClient.getSupportedLanguages(request);

    for (const language of response.languages) {
      // Supported language code, generally consisting of its ISO 639-1 identifier, for
      // example, 'en', 'ja'. In certain cases, BCP-47 codes including language and
      // region identifiers are returned (for example, 'zh-TW' and 'zh-CN')
      console.log(`Language - Language Code: ${language.languageCode}`);
      // Human readable name of the language localized in the display language specified
      // in the request.
      console.log(`Language - Display Name: ${language.displayName}`);
      // Can be used as source language.
      console.log(`Language - Support Source: ${language.supportSource}`);
      // Can be used as target language.
      console.log(`Language - Support Target: ${language.supportTarget}`);
    }
  } catch (error) {
    console.error(error.details);
  }
}

getSupportedLanguages();

Python

Folgen Sie der Einrichtungsanleitung für Python unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für Python.

from google.cloud import translate

def sample_get_supported_languages(project_id):
    """Getting a list of supported language codes"""

    client = translate.TranslationServiceClient()

    # TODO(developer): Uncomment and set the following variables
    # project = '[Google Cloud Project ID]'
    parent = client.location_path(project_id, "global")

    response = client.get_supported_languages(parent=parent)

    # List language codes of supported languages
    print('Supported Languages:')
    for language in response.languages:
        print(u"Language Code: {}".format(language.language_code))

Ruby

Folgen Sie der Einrichtungsanleitung für Ruby unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für Ruby.

require "google/cloud/translate"

client = Google::Cloud::Translate.new

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

parent = client.class.location_path project_id, location_id

response = client.get_supported_languages parent

# List language codes of supported languages
response.languages.each do |language|
  puts "Language Code: #{language.language_code}"
end

Sprache erkennen

Mit Cloud Translation Basic, um die Quellsprache im Text mithilfe des folgenden Codes zu erkennen:

curl-Befehl

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     --data "{
  'q': 'Omnia Gallia est divisa in tres partes',
}" "https://translation.googleapis.com/language/translate/v2/detect"

Wenn die Anfrage erfolgreich ist, gibt der Server den HTTP-Statuscode 200 OK und die Antwort im JSON-Format zurück:

{
  "data": {
    "detections": [
      [
        {
          "confidence": 0.93554825,
          "isReliable": false,
          "language": "la"
        }
      ]
    ]
  }

Java

Folgen Sie der Einrichtungsanleitung für Java unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für Java.

// TODO(developer): Uncomment these lines.
// import com.google.cloud.translate.*;
// Translate translate = TranslateOptions.getDefaultInstance().getService();

List<String> texts = new LinkedList<>();
texts.add("Hello, World!");
texts.add("¡Hola Mundo!");
List<Detection> detections = translate.detect(texts);

System.out.println("Language(s) detected:");
for (Detection detection : detections) {
  System.out.printf("\t%s\n", detection);
}

Node.js

Folgen Sie der Einrichtungsanleitung für Node.js unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für Node.js.

// Imports the Google Cloud client library
const {Translate} = require('@google-cloud/translate').v2;

// Creates a client
const translate = new Translate();

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const text = 'The text for which to detect language, e.g. Hello, world!';

// Detects the language. "text" can be a string for detecting the language of
// a single piece of text, or an array of strings for detecting the languages
// of multiple texts.
async function detectLanguage() {
  let [detections] = await translate.detect(text);
  detections = Array.isArray(detections) ? detections : [detections];
  console.log('Detections:');
  detections.forEach(detection => {
    console.log(`${detection.input} => ${detection.language}`);
  });
}

detectLanguage();

Python

Folgen Sie der Einrichtungsanleitung für Python unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für Python.

"""Detects the text's language."""
from google.cloud import translate_v2 as translate
translate_client = translate.Client()

# Text can also be a sequence of strings, in which case this method
# will return a sequence of results for each text.
result = translate_client.detect_language(text)

print('Text: {}'.format(text))
print('Confidence: {}'.format(result['confidence']))
print('Language: {}'.format(result['language']))

Bei Cloud Translation Advanced müssen Sie beim Senden einer detectLanguage-Anfrage die Projektnummer oder Projekt-ID und den Projektstandort angeben – in der Regel global oder us-central1.

Außerdem können Sie die Anfrage konfigurieren, die Sie an Cloud Translation Advanced senden, damit Sie verschiedene MIME-Typen senden. Sie haben beispielsweise die Möglichkeit, text/html oder text/plain anzufordern. Der Standardwert ist text/html.

REST UND BEFEHLSZEILE

Bevor Sie die unten aufgeführten Anfragedaten verwenden, ersetzen Sie den folgenden Wert:

  • project-number-or-id: Projektnummer oder ID Ihres GCP-Projekts

HTTP-Methode und URL:

POST https://translation.googleapis.com/v3/projects/project-number-or-id/locations/global:detectLanguage

JSON-Text der Anfrage:

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

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

curl

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus:

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

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus:

$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

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

{
  "languages": [
    {
      "languageCode": "ru",
      "confidence": 1
    }
  ]
}
In der Antwort wird mit languageCode der Sprachcode der erkannten Sprache angegeben. Für confidence gilt ein Bereich von 0 bis 1. Bei 1 beträgt der Konfidenzwert 100 %.

C#

Folgen Sie der Einrichtungsanleitung für C# unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für 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

Folgen Sie der Einrichtungsanleitung für Go unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für 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
}

Node.js

Folgen Sie der Einrichtungsanleitung für Node.js unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für 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();

Python

Folgen Sie der Einrichtungsanleitung für Python unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für Python.

from google.cloud import translate

def sample_detect_language(text, project_id):
    """
    Detecting the language of a text string

    Args:
      text The text string for performing language detection
    """

    client = translate.TranslationServiceClient()

    # TODO(developer): Uncomment and set the following variables
    # text = 'Hello, world!'
    # project_id = '[Google Cloud project_id ID]'
    parent = client.location_path(project_id, "global")

    response = client.detect_language(
        content=text,
        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(u"Language code: {}".format(language.language_code))
        # Confidence of detection result for this language
        print(u"Confidence: {}".format(language.confidence))

Ruby

Folgen Sie der Einrichtungsanleitung für Ruby unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für Ruby.

require "google/cloud/translate"

client = Google::Cloud::Translate.new

project_id = "[Google Cloud Project ID]"
location_id = "[LOCATION ID]"
# The text string for performing language detection
content = "Hello, world!"
# Optional. Can be "text/plain" or "text/html".
mime_type = "text/plain"

parent = client.class.location_path project_id, location_id

response = client.detect_language 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

Ruby

Folgen Sie der Einrichtungsanleitung für Ruby unter Kurzanleitung: Clientbibliotheken verwenden, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für Ruby.

require "google/cloud/translate"

client = Google::Cloud::Translate.new

project_id = "[Google Cloud Project ID]"
location_id = "[LOCATION ID]"
# The text string for performing language detection
content = "Hello, world!"
# Optional. Can be "text/plain" or "text/html".
mime_type = "text/plain"

parent = client.class.location_path project_id, location_id

response = client.detect_language 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