Rychlý Start: použití překladatele k překladu textuQuickstart: Use the Translator to translate text

V tomto rychlém startu se dozvíte, jak přeložit textový řetězec z angličtiny do němčiny, italštiny, japonštiny a thajštiny pomocí REST API překladatele.In this quickstart, you'll learn how to translate a text string from English to German, Italian, Japanese, and Thai using the Translator REST API.

Tento rychlý Start vyžaduje účet Azure Cognitive Services s prostředkem překladatele.This quickstart requires an Azure Cognitive Services account with a Translator resource. Pokud účet nemáte, můžete k získání klíče předplatného použít bezplatnou zkušební verzi.If you don't have an account, you can use the free trial to get a subscription key.

PožadavkyPrerequisites

K tomuto rychlému startu potřebujete:This quickstart requires:

NastaveníSet up

Vytvoření prostředku překladateleCreate a Translator resource

Azure Cognitive Services jsou představovány prostředky Azure, ke kterým jste se přihlásili.Azure Cognitive Services are represented by Azure resources that you subscribe to. Vytvořte prostředek pro překladatele pomocí Azure Portal nebo rozhraní příkazového řádku Azure CLI na místním počítači.Create a resource for Translator using the Azure portal or Azure CLI on your local machine. Můžete také:You can also:

  • Získejte zkušební klíč platný po dobu 7 dnů zdarma.Get a trial key valid for 7 days for free. Po registraci bude k dispozici na webu Azure.After signing up, it will be available on the Azure website.
  • Zobrazení existujícího prostředku v Azure Portal.View an existing resource in the Azure portal.

Po získání klíče ze zkušebního předplatného nebo prostředku vytvořte dvě proměnné prostředí:After you get a key from your trial subscription or resource, create two environment variables:

  • TRANSLATOR_TEXT_SUBSCRIPTION_KEY– Klíč předplatného pro váš prostředek překladatele.TRANSLATOR_TEXT_SUBSCRIPTION_KEY - The subscription key for your Translator resource.
  • TRANSLATOR_TEXT_ENDPOINT– Globální koncový bod pro překladatele.TRANSLATOR_TEXT_ENDPOINT - The global endpoint for Translator. Použijte https://api.cognitive.microsofttranslator.com/.Use https://api.cognitive.microsofttranslator.com/.

Vytvoření projektu .NET CoreCreate a .NET Core project

Otevřete nový příkazový řádek (nebo relaci terminálu) a spusťte tyto příkazy:Open a new command prompt (or terminal session) and run these commands:

dotnet new console -o translate-sample
cd translate-sample

První příkaz provede dvě věci.The first command does two things. Vytvoří novou konzolovou aplikaci .NET a vytvoří adresář s názvem translate-sample .It creates a new .NET console application, and creates a directory named translate-sample. Druhý příkaz změní adresář pro váš projekt.The second command changes to the directory for your project.

V dalším kroku budete muset nainstalovat Json.Net.Next, you'll need to install Json.Net. Z adresáře projektu spusťte:From your project's directory, run:

dotnet add package Newtonsoft.Json --version 11.0.2

Vyberte verzi jazyka C#.Select the C# language version

Tento rychlý Start vyžaduje C# 7,1 nebo novější.This quickstart requires C# 7.1 or later. Existuje několik způsobů, jak změnit verzi v jazyce C# pro váš projekt.There are a few ways to change the C# version for your project. V této příručce vám ukážeme, jak translate-sample.csproj soubor upravit.In this guide, we'll show you how to adjust the translate-sample.csproj file. Všechny dostupné možnosti, jako je například změna jazyka v aplikaci Visual Studio, najdete v tématu Výběr jazykové verze jazyka C#.For all available options, such as changing the language in Visual Studio, see Select the C# language version.

Otevřete projekt a pak otevřete translate-sample.csproj .Open your project, then open translate-sample.csproj. Ujistěte se, že LangVersion je nastavená na 7,1 nebo novější.Make sure that LangVersion is set to 7.1 or later. Pokud pro danou jazykovou verzi není skupina vlastností, přidejte tyto řádky:If there isn't a property group for the language version, add these lines:

<PropertyGroup>
   <LangVersion>7.1</LangVersion>
</PropertyGroup>

Přidání požadovaných oborů názvů do projektuAdd required namespaces to your project

dotnet new consolePříkaz, který jste spustili dříve, vytvořil projekt, včetně Program.cs .The dotnet new console command that you ran earlier created a project, including Program.cs. Do tohoto souboru umístíte kód aplikace.This file is where you'll put your application code. Otevřete Program.cs a nahraďte existující příkazy using.Open Program.cs, and replace the existing using statements. Tyto příkazy zajistí, že máte přístup ke všem typům vyžadovaným pro sestavení a spuštění ukázkové aplikace.These statements ensure that you have access to all the types required to build and run the sample app.

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
// Install Newtonsoft.Json with NuGet
using Newtonsoft.Json;

Vytvoření tříd pro odpověď JSONCreate classes for the JSON response

Nyní vytvoříme sadu tříd, které se použijí při deserializaci odpovědi JSON vrácené překladatelem.Next, we're going to create a set of classes that are used when deserializing the JSON response returned by the Translator.

/// <summary>
/// The C# classes that represents the JSON returned by the Translator.
/// </summary>
public class TranslationResult
{
    public DetectedLanguage DetectedLanguage { get; set; }
    public TextResult SourceText { get; set; }
    public Translation[] Translations { get; set; }
}

public class DetectedLanguage
{
    public string Language { get; set; }
    public float Score { get; set; }
}

public class TextResult
{
    public string Text { get; set; }
    public string Script { get; set; }
}

public class Translation
{
    public string Text { get; set; }
    public TextResult Transliteration { get; set; }
    public string To { get; set; }
    public Alignment Alignment { get; set; }
    public SentenceLength SentLen { get; set; }
}

public class Alignment
{
    public string Proj { get; set; }
}

public class SentenceLength
{
    public int[] SrcSentLen { get; set; }
    public int[] TransSentLen { get; set; }
}

Získání informací o předplatném z proměnných prostředíGet subscription information from environment variables

Do třídy přidejte následující řádky Program .Add the following lines to the Program class. Tyto řádky čtou klíč předplatného a koncový bod z proměnných prostředí a vyvolá chybu, pokud narazíte na nějaké problémy.These lines read your subscription key and endpoint from environment variables, and throws an error if you run into any issues.

private const string key_var = "TRANSLATOR_TEXT_SUBSCRIPTION_KEY";
private static readonly string subscriptionKey = Environment.GetEnvironmentVariable(key_var);

private const string endpoint_var = "TRANSLATOR_TEXT_ENDPOINT";
private static readonly string endpoint = Environment.GetEnvironmentVariable(endpoint_var);

static Program()
{
    if (null == subscriptionKey)
    {
        throw new Exception("Please set/export the environment variable: " + key_var);
    }
    if (null == endpoint)
    {
        throw new Exception("Please set/export the environment variable: " + endpoint_var);
    }
}
// The code in the next section goes here.

Vytvoření funkce pro překlad textuCreate a function to translate text

Ve Program třídě Vytvořte asynchronní funkci s názvem TranslateTextRequest() .In the Program class, create an asynchronous function called TranslateTextRequest(). Tato funkce přijímá čtyři argumenty: subscriptionKey , host , a route inputText .This function takes four arguments: subscriptionKey, host, route, and inputText.

// This sample requires C# 7.1 or later for async/await.
// Async call to the Translator
static public async Task TranslateTextRequest(string subscriptionKey, string endpoint, string route, string inputText)
{
  /*
   * The code for your call to the translation service will be added to this
   * function in the next few sections.
   */
}

Serializace požadavku překladuSerialize the translation request

Dále je potřeba vytvořit a serializovat objekt JSON, který obsahuje text, který chcete přeložit.Next, we need to create and serialize the JSON object that includes the text you want to translate. Mějte na paměti, že v nástroji můžete předat více než jeden objekt body .Keep in mind, you can pass more than one object in the body.

object[] body = new object[] { new { Text = inputText } };
var requestBody = JsonConvert.SerializeObject(body);

Vytvoření instance klienta a vytvoření žádostiInstantiate the client and make a request

Tyto řádky vytváří instanci HttpClient a HttpRequestMessage :These lines instantiate the HttpClient and the HttpRequestMessage:

using (var client = new HttpClient())
using (var request = new HttpRequestMessage())
{
  // In the next few sections you'll add code to construct the request.
}

Sestavte požadavek a vytiskněte odpověď.Construct the request and print the response

V rámci HttpRequestMessage budete:Inside the HttpRequestMessage you'll:

  • Deklarace metody HTTPDeclare the HTTP method
  • Sestavit identifikátor URI žádostiConstruct the request URI
  • Vložit text žádosti (serializovaný objekt JSON)Insert the request body (serialized JSON object)
  • Přidat požadovaná záhlavíAdd required headers
  • Vytvořit asynchronní požadavekMake an asynchronous request
  • Vytiskněte odpověď pomocí tříd, které jste vytvořili dříve.Print the response using the classes you created earlier

Přidejte tento kód do HttpRequestMessage :Add this code to the HttpRequestMessage:

// Build the request.
// Set the method to Post.
request.Method = HttpMethod.Post;
// Construct the URI and add headers.
request.RequestUri = new Uri(endpoint + route);
request.Content = new StringContent(requestBody, Encoding.UTF8, "application/json");
request.Headers.Add("Ocp-Apim-Subscription-Key", subscriptionKey);

// Send the request and get response.
HttpResponseMessage response = await client.SendAsync(request).ConfigureAwait(false);
// Read response as a string.
string result = await response.Content.ReadAsStringAsync();
// Deserialize the response using the classes created earlier.
TranslationResult[] deserializedOutput = JsonConvert.DeserializeObject<TranslationResult[]>(result);
// Iterate over the deserialized results.
foreach (TranslationResult o in deserializedOutput)
{
    // Print the detected input language and confidence score.
    Console.WriteLine("Detected input language: {0}\nConfidence score: {1}\n", o.DetectedLanguage.Language, o.DetectedLanguage.Score);
    // Iterate over the results and print each translation.
    foreach (Translation t in o.Translations)
    {
        Console.WriteLine("Translated to {0}: {1}", t.To, t.Text);
    }
}

Pokud používáte Cognitive Services předplatné s více službami, musíte taky zahrnout Ocp-Apim-Subscription-Region do parametrů žádosti.If you are using a Cognitive Services multi-service subscription, you must also include the Ocp-Apim-Subscription-Region in your request parameters. Přečtěte si další informace o ověřování pomocí předplatného s více službami.Learn more about authenticating with the multi-service subscription.

Spojení všech součástí dohromadyPut it all together

Posledním krokem je volání TranslateTextRequest() Main funkce.The last step is to call TranslateTextRequest() in the Main function. V této ukázce se překládáme na němčinu ( de ), italštinu ( it ), japonštinu ( ja ) a thajštinu ( th ).In this sample, we're translating to German (de), Italian (it), Japanese (ja), and Thai (th). Vyhledejte static void Main(string[] args) ho a nahraďte ho tímto kódem:Locate static void Main(string[] args) and replace it with this code:

static async Task Main(string[] args)
{
    // This is our main function.
    // Output languages are defined in the route.
    // For a complete list of options, see API reference.
    // https://docs.microsoft.com/azure/cognitive-services/translator/reference/v3-0-translate
    string route = "/translate?api-version=3.0&to=de&to=it&to=ja&to=th";
    // Prompts you for text to translate. If you'd prefer, you can
    // provide a string as textToTranslate.
    Console.Write("Type the phrase you'd like to translate? ");
    string textToTranslate = Console.ReadLine();
    await TranslateTextRequest(subscriptionKey, endpoint, route, textToTranslate);
    Console.WriteLine("Press any key to continue.");
    Console.ReadKey();
}

Všimněte si, že v Main , deklarujete subscriptionKey , endpoint a route .You'll notice that in Main, you're declaring subscriptionKey, endpoint, and route. Kromě toho vyzýváte uživatele k zadání Console.Readline() a přiřazení hodnoty k textToTranslate .Additionally, you're prompting the user for input with Console.Readline() and assigning the value to textToTranslate.

Spuštění ukázkové aplikaceRun the sample app

To je to, že jste připraveni spustit ukázkovou aplikaci.That's it, you're ready to run your sample app. Z příkazového řádku (nebo relace Terminálové služby) přejděte do adresáře projektu a spusťte příkaz:From the command line (or terminal session), navigate to your project directory and run:

dotnet run

Ukázková odpověďSample response

Po spuštění ukázky by se měla zobrazit následující tištěná do terminálu:After you run the sample, you should see the following printed to terminal:

Detected input language: en
Confidence score: 1

Translated to de: Hallo Welt!
Translated to it: Salve, mondo!
Translated to ja: ハローワールド!
Translated to th: หวัดดีชาวโลก!

Tato zpráva je sestavena z nezpracovaného formátu JSON, který bude vypadat takto:This message is built from the raw JSON, which will look like this:

[
  {
    "detectedLanguage": {
      "language": "en",
      "score": 1.0
    },
    "translations": [
      {
        "text": "Hallo Welt!",
        "to": "de"
      },
      {
        "text": "Salve, mondo!",
        "to": "it"
      },
      {
        "text": "ハローワールド!",
        "to": "ja"
      },
      {
        "text": "หวัดดีชาวโลก!",
        "to": "th"
      }
    ]
  }
]

Vyčištění prostředkůClean up resources

Nezapomeňte ze zdrojového kódu ukázkové aplikace odebrat všechny důvěrné informace, jako jsou klíče předplatného.Make sure to remove any confidential information from your sample app's source code, like subscription keys.

Další krokyNext steps

Podívejte se na reference k rozhraní API, abyste porozuměli všem, co můžete s překladatelem dělat.Take a look at the API reference to understand everything you can do with the Translator.

PožadavkyPrerequisites

K tomuto rychlému startu potřebujete:This quickstart requires:

NastaveníSet up

Vytvoření prostředku překladateleCreate a Translator resource

Azure Cognitive Services jsou představovány prostředky Azure, ke kterým jste se přihlásili.Azure Cognitive Services are represented by Azure resources that you subscribe to. Vytvořte prostředek pro překladatele pomocí Azure Portal nebo rozhraní příkazového řádku Azure CLI na místním počítači.Create a resource for Translator using the Azure portal or Azure CLI on your local machine. Můžete také:You can also:

  • Získejte zkušební klíč platný po dobu 7 dnů zdarma.Get a trial key valid for 7 days for free. Po registraci bude k dispozici na webu Azure.After signing up, it will be available on the Azure website.
  • Zobrazení existujícího prostředku v Azure Portal.View an existing resource in the Azure portal.

Po získání klíče ze zkušebního předplatného nebo prostředku vytvořte dvě proměnné prostředí:After you get a key from your trial subscription or resource, create two environment variables:

  • TRANSLATOR_TEXT_SUBSCRIPTION_KEY– Klíč předplatného pro váš prostředek překladatele.TRANSLATOR_TEXT_SUBSCRIPTION_KEY - The subscription key for your Translator resource.
  • TRANSLATOR_TEXT_ENDPOINT– Globální koncový bod pro překladatele.TRANSLATOR_TEXT_ENDPOINT - The global endpoint for Translator. Použijte https://api.cognitive.microsofttranslator.com/.Use https://api.cognitive.microsofttranslator.com/.

Vytvoření projektu a import požadovaných modulůCreate a project and import required modules

Vytvořte nový projekt pro procházení pomocí oblíbených rozhraní IDE nebo editoru.Create a new Go project using your favorite IDE or editor. Pak do svého projektu, do souboru s názvem translate-text.go, zkopírujte tento fragment kódu.Then copy this code snippet into your project in a file named translate-text.go.

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "net/url"
    "os"
)

Vytvoření funkce mainCreate the main function

Tato ukázka se pokusí přečíst klíč předplatného vašeho převaděče a koncový bod z těchto proměnných prostředí: TRANSLATOR_TEXT_SUBSCRIPTION_KEY a TRANSLATOR_TEXT_ENDPOINT .This sample will try to read your Translator subscription key and endpoint from these environment variables: TRANSLATOR_TEXT_SUBSCRIPTION_KEY and TRANSLATOR_TEXT_ENDPOINT. Pokud nejste obeznámeni s proměnnými prostředí, můžete nastavit subscriptionKey a endpoint jako řetězce a komentovat podmíněné příkazy.If you're not familiar with environment variables, you can set subscriptionKey and endpoint as strings and comment out the conditional statements.

Zkopírujte do svého projektu tento kód:Copy this code into your project:

func main() {
    /*
    * Read your subscription key from an env variable.
    * Please note: You can replace this code block with
    * var subscriptionKey = "YOUR_SUBSCRIPTION_KEY" if you don't
    * want to use env variables. If so, be sure to delete the "os" import.
    */
    if "" == os.Getenv("TRANSLATOR_TEXT_SUBSCRIPTION_KEY") {
      log.Fatal("Please set/export the environment variable TRANSLATOR_TEXT_SUBSCRIPTION_KEY.")
    }
    subscriptionKey := os.Getenv("TRANSLATOR_TEXT_SUBSCRIPTION_KEY")
    if "" == os.Getenv("TRANSLATOR_TEXT_ENDPOINT") {
      log.Fatal("Please set/export the environment variable TRANSLATOR_TEXT_ENDPOINT.")
    }
    endpoint := os.Getenv("TRANSLATOR_TEXT_ENDPOINT")
    uri := endpoint + "/translate?api-version=3.0"
    /*
     * This calls our breakSentence function, which we'll
     * create in the next section. It takes a single argument,
     * the subscription key.
     */
    translate(subscriptionKey, uri)
}

Vytvoření funkce pro překlad textuCreate a function to translate text

Pojďme vytvořit funkci pro překlad textu.Let's create a function to translate text. Tato funkce bude mít jeden argument, váš klíč předplatného překladatele.This function will take a single argument, your Translator subscription key.

func translate(subscriptionKey string, uri string) {
    /*  
     * In the next few sections, we'll add code to this
     * function to make a request and handle the response.
     */
}

Nyní vytvoříme adresu URL.Next, let's construct the URL. Adresa URL je sestavena pomocí Parse() Query() metod a.The URL is built using the Parse() and Query() methods. Všimněte si, že parametry jsou přidány s Add() metodou.You'll notice that parameters are added with the Add() method. V této ukázce budete překládáte z angličtiny do němčiny a italštiny: de a it .In this sample, you're translating from English to German and Italian: de and it.

Zkopírujte tento kód do translate funkce.Copy this code into the translate function.

// Build the request URL. See: https://golang.org/pkg/net/url/#example_URL_Parse
u, _ := url.Parse(uri)
q := u.Query()
q.Add("to", "de")
q.Add("to", "it")
u.RawQuery = q.Encode()

Poznámka

Další informace o koncových bodech, trasách a parametrech požadavků naleznete v tématu Translator 3,0: přeložit.For more information about endpoints, routes, and request parameters, see Translator 3.0: Translate.

Vytvoření struktury pro tělo žádostiCreate a struct for your request body

Dále vytvořte anonymní strukturu pro text žádosti a zakódovat ji jako JSON pomocí json.Marshal() .Next, create an anonymous structure for the request body and encode it as JSON with json.Marshal(). Přidejte tento kód do translate funkce.Add this code to the translate function.

// Create an anonymous struct for your request body and encode it to JSON
body := []struct {
    Text string
}{
    {Text: "Hello, world!"},
}
b, _ := json.Marshal(body)

Sestavení požadavkuBuild the request

Teď, když jste zakódovi tělo požadavku jako JSON, můžete sestavit požadavek POST a volat překladatele.Now that you've encoded the request body as JSON, you can build your POST request, and call the Translator.

// Build the HTTP POST request
req, err := http.NewRequest("POST", u.String(), bytes.NewBuffer(b))
if err != nil {
    log.Fatal(err)
}
// Add required headers to the request
req.Header.Add("Ocp-Apim-Subscription-Key", subscriptionKey)
req.Header.Add("Content-Type", "application/json")

// Call the Translator
res, err := http.DefaultClient.Do(req)
if err != nil {
    log.Fatal(err)
}

Pokud používáte Cognitive Services předplatné s více službami, musíte taky zahrnout Ocp-Apim-Subscription-Region do parametrů žádosti.If you are using a Cognitive Services multi-service subscription, you must also include the Ocp-Apim-Subscription-Region in your request parameters. Přečtěte si další informace o ověřování pomocí předplatného s více službami.Learn more about authenticating with the multi-service subscription.

Zpracuje a vytiskne odpověď.Handle and print the response

Přidejte tento kód do translate funkce k dekódování odpovědi JSON a pak formátujte a tiskněte výsledek.Add this code to the translate function to decode the JSON response, and then format and print the result.

// Decode the JSON response
var result interface{}
if err := json.NewDecoder(res.Body).Decode(&result); err != nil {
    log.Fatal(err)
}
// Format and print the response to terminal
prettyJSON, _ := json.MarshalIndent(result, "", "  ")
fmt.Printf("%s\n", prettyJSON)

Spojení všech součástí dohromadyPut it all together

To je to, že jste připravili jednoduchý program, který bude volat překladatele a vrátil odpověď JSON.That's it, you've put together a simple program that will call the Translator and return a JSON response. Teď je čas program spustit:Now it's time to run your program:

go run translate-text.go

Pokud chcete porovnat svůj kód s naším, kompletní ukázka je k dispozici na GitHubu.If you'd like to compare your code against ours, the complete sample is available on GitHub.

Ukázková odpověďSample response

Úspěšná odpověď se vrátí ve formátu JSON, jak je znázorněno v následujícím příkladu:A successful response is returned in JSON as shown in the following example:

[
  {
    "detectedLanguage": {
      "language": "en",
      "score": 1.0
    },
    "translations": [
      {
        "text": "Hallo Welt!",
        "to": "de"
      },
      {
        "text": "Salve, mondo!",
        "to": "it"
      }
    ]
  }
]

Další krokyNext steps

Podívejte se na reference k rozhraní API, abyste porozuměli všem, co můžete s překladatelem dělat.Take a look at the API reference to understand everything you can do with the Translator.

PožadavkyPrerequisites

K tomuto rychlému startu potřebujete:This quickstart requires:

NastaveníSet up

Vytvoření prostředku překladateleCreate a Translator resource

Azure Cognitive Services jsou představovány prostředky Azure, ke kterým jste se přihlásili.Azure Cognitive Services are represented by Azure resources that you subscribe to. Vytvořte prostředek pro překladatele pomocí Azure Portal nebo rozhraní příkazového řádku Azure CLI na místním počítači.Create a resource for Translator using the Azure portal or Azure CLI on your local machine. Můžete také:You can also:

  • Získejte zkušební klíč platný po dobu 7 dnů zdarma.Get a trial key valid for 7 days for free. Po registraci bude k dispozici na webu Azure.After signing up, it will be available on the Azure website.
  • Zobrazení existujícího prostředku v Azure Portal.View an existing resource in the Azure portal.

Po získání klíče ze zkušebního předplatného nebo prostředku vytvořte dvě proměnné prostředí:After you get a key from your trial subscription or resource, create two environment variables:

  • TRANSLATOR_TEXT_SUBSCRIPTION_KEY– Klíč předplatného pro váš prostředek překladatele.TRANSLATOR_TEXT_SUBSCRIPTION_KEY - The subscription key for your Translator resource.
  • TRANSLATOR_TEXT_ENDPOINT– Globální koncový bod pro překladatele.TRANSLATOR_TEXT_ENDPOINT - The global endpoint for Translator. Použijte https://api.cognitive.microsofttranslator.com/.Use https://api.cognitive.microsofttranslator.com/.

Inicializovat projekt pomocí GradleInitialize a project with Gradle

Pojďme začít vytvořením pracovního adresáře pro tento projekt.Let's start by creating a working directory for this project. Z příkazového řádku (nebo terminálu) spusťte tento příkaz:From the command line (or terminal), run this command:

mkdir translator-sample
cd translator-sample

Teď budete chtít inicializovat projekt Gradle.Next, you're going to initialize a Gradle project. Tento příkaz vytvoří základní soubory sestavení pro Gradle, co je nejdůležitější, a build.gradle.kts který se používá za běhu k vytvoření a konfiguraci vaší aplikace.This command will create essential build files for Gradle, most importantly, the build.gradle.kts, which is used at runtime to create and configure your application. Spusťte tento příkaz z pracovního adresáře:Run this command from your working directory:

gradle init --type basic

Po zobrazení výzvy k výběru DSLvyberte Kotlin.When prompted to choose a DSL, select Kotlin.

Konfigurovat soubor sestaveníConfigure the build file

Vyhledejte build.gradle.kts ho a otevřete ho pomocí svého oblíbeného integrovaného vývojového prostředí nebo textového editoru.Locate build.gradle.kts and open it with your favorite IDE or text editor. Pak zkopírujte do této konfigurace sestavení:Then copy in this build configuration:

plugins {
    java
    application
}
application {
    mainClassName = "Translate"
}
repositories {
    mavenCentral()
}
dependencies {
    compile("com.squareup.okhttp:okhttp:2.5.0")
    compile("com.google.code.gson:gson:2.8.5")
}

Všimněte si, že tato ukázka obsahuje závislosti na OkHttp pro požadavky HTTP a gson pro zpracování a analýzu JSON.Take note that this sample has dependencies on OkHttp for HTTP requests, and Gson to handle and parse JSON. Pokud se chcete dozvědět více o konfiguracích sestavení, přečtěte si téma vytváření nových Gradle sestavení.If you'd like to learn more about build configurations, see Creating New Gradle Builds.

Vytvoření souboru JavaCreate a Java file

Pojďme vytvořit složku pro ukázkovou aplikaci.Let's create a folder for your sample app. V pracovním adresáři spusťte:From your working directory, run:

mkdir -p src/main/java

Potom v této složce vytvořte soubor s názvem Translate.java .Next, in this folder, create a file named Translate.java.

Importovat požadované knihovnyImport required libraries

Otevřete Translate.java a přidejte tyto příkazy pro import:Open Translate.java and add these import statements:

import java.io.*;
import java.net.*;
import java.util.*;
import com.google.gson.*;
import com.squareup.okhttp.*;

Definování proměnnýchDefine variables

Nejprve budete muset vytvořit veřejnou třídu pro svůj projekt:First, you'll need to create a public class for your project:

public class Translate {
  // All project code goes here...
}

Přidejte tyto řádky do Translate třídy.Add these lines to the Translate class. Nejdřív se klíč předplatného a koncový bod čtou z proměnných prostředí.First, the subscription key and endpoint are being read from environment variables. Pak si všimněte, že spolu s, byly api-version do nástroje připojeny dva další parametry url .Then, you'll notice that along with the api-version, two additional parameters have been appended to the url. Tyto parametry slouží k nastavení výstupů překladu.These parameters are used to set the translation outputs. V této ukázce je nastavena na hodnotu němčina ( de ) a italština ( it ).In this sample, it's set to German (de) and Italian (it).

private static String subscriptionKey = System.getenv("TRANSLATOR_TEXT_SUBSCRIPTION_KEY");
private static String endpoint = System.getenv("TRANSLATOR_TEXT_ENDPOINT");
String url = endpoint + "/translate?api-version=3.0&to=de,it";

Pokud používáte Cognitive Services předplatné s více službami, musíte taky zahrnout Ocp-Apim-Subscription-Region do parametrů žádosti.If you are using a Cognitive Services multi-service subscription, you must also include the Ocp-Apim-Subscription-Region in your request parameters. Přečtěte si další informace o ověřování pomocí předplatného s více službami.Learn more about authenticating with the multi-service subscription.

Vytvoření klienta a sestavení žádostiCreate a client and build a request

Přidejte tento řádek do Translate třídy pro vytvoření instance OkHttpClient :Add this line to the Translate class to instantiate the OkHttpClient:

// Instantiates the OkHttpClient.
OkHttpClient client = new OkHttpClient();

Nyní sestavíme požadavek POST.Next, let's build the POST request. Můžete změnit text pro překlad.Feel free to change the text for translation. Text musí být uvozený řídicím znakem.The text must be escaped.

// This function performs a POST request.
public String Post() throws IOException {
    MediaType mediaType = MediaType.parse("application/json");
    RequestBody body = RequestBody.create(mediaType,
            "[{\n\t\"Text\": \"Welcome to Microsoft Translator. Guess how many languages I speak!\"\n}]");
    Request request = new Request.Builder()
            .url(url).post(body)
            .addHeader("Ocp-Apim-Subscription-Key", subscriptionKey)
            .addHeader("Content-type", "application/json").build();
    Response response = client.newCall(request).execute();
    return response.body().string();
}

Vytvoření funkce pro analýzu odpovědiCreate a function to parse the response

Tato jednoduchá funkce analyzuje a prettifies odpověď JSON ze služby Translator.This simple function parses and prettifies the JSON response from the Translator service.

// This function prettifies the json response.
public static String prettify(String json_text) {
    JsonParser parser = new JsonParser();
    JsonElement json = parser.parse(json_text);
    Gson gson = new GsonBuilder().setPrettyPrinting().create();
    return gson.toJson(json);
}

Spojení všech součástí dohromadyPut it all together

Posledním krokem je vytvoření žádosti a získání odpovědi.The last step is to make a request and get a response. Přidejte tyto řádky do projektu:Add these lines to your project:

public static void main(String[] args) {
    try {
        Translate translateRequest = new Translate();
        String response = translateRequest.Post();
        System.out.println(prettify(response));
    } catch (Exception e) {
        System.out.println(e);
    }
}

Spuštění ukázkové aplikaceRun the sample app

To je to, že jste připraveni spustit ukázkovou aplikaci.That's it, you're ready to run your sample app. Z příkazového řádku (nebo relace Terminálové služby) přejděte do kořenového adresáře svého pracovního adresáře a spusťte příkaz:From the command line (or terminal session), navigate to the root of your working directory and run:

gradle build

Po dokončení sestavení spusťte:When the build completes, run:

gradle run

Ukázková odpověďSample response

[
  {
    "detectedLanguage": {
      "language": "en",
      "score": 1.0
    },
    "translations": [
      {
        "text": "Willkommen bei Microsoft Translator. Erraten Sie, wie viele Sprachen ich spreche!",
        "to": "de"
      },
      {
        "text": "Benvenuti a Microsoft Translator. Indovinate quante lingue parlo!",
        "to": "it"
      }
    ]
  }
]

Další krokyNext steps

Podívejte se na reference k rozhraní API, abyste porozuměli všem, co můžete s překladatelem dělat.Take a look at the API reference to understand everything you can do with the Translator.

PožadavkyPrerequisites

K tomuto rychlému startu potřebujete:This quickstart requires:

NastaveníSet up

Vytvoření prostředku překladateleCreate a Translator resource

Azure Cognitive Services jsou představovány prostředky Azure, ke kterým jste se přihlásili.Azure Cognitive Services are represented by Azure resources that you subscribe to. Vytvořte prostředek pro překladatele pomocí Azure Portal nebo rozhraní příkazového řádku Azure CLI na místním počítači.Create a resource for Translator using the Azure portal or Azure CLI on your local machine. Můžete také:You can also:

  • Získejte zkušební klíč platný po dobu 7 dnů zdarma.Get a trial key valid for 7 days for free. Po registraci bude k dispozici na webu Azure.After signing up, it will be available on the Azure website.
  • Zobrazení existujícího prostředku v Azure Portal.View an existing resource in the Azure portal.

Po získání klíče ze zkušebního předplatného nebo prostředku vytvořte dvě proměnné prostředí:After you get a key from your trial subscription or resource, create two environment variables:

  • TRANSLATOR_TEXT_SUBSCRIPTION_KEY– Klíč předplatného pro váš prostředek překladatele.TRANSLATOR_TEXT_SUBSCRIPTION_KEY - The subscription key for your Translator resource.
  • TRANSLATOR_TEXT_ENDPOINT– Globální koncový bod pro překladatele.TRANSLATOR_TEXT_ENDPOINT - The global endpoint for Translator. Použijte https://api.cognitive.microsofttranslator.com/.Use https://api.cognitive.microsofttranslator.com/.

Vytvoření projektu a import požadovaných modulůCreate a project and import required modules

Vytvořte nový projekt pomocí oblíbeného integrovaného vývojového prostředí (IDE) nebo nové složky se souborem s názvem translate-text.js na vašem počítači.Create a new project using your favorite IDE or editor, or a new folder with a file named translate-text.js on your desktop. Potom tento fragment kódu zkopírujte do svého projektu nebo souboru:Then copy this code snippet into your project/file:

const request = require('request');
const uuidv4 = require('uuid/v4');

Poznámka

Pokud jste tyto moduly ještě nikdy nepoužili, budete je muset před spuštěním programu nainstalovat.If you haven't used these modules you'll need to install them before running your program. Tyto balíčky nainstalujete spuštěním příkazu npm install request uuidv4.To install these packages, run: npm install request uuidv4.

Tyto moduly jsou potřeba k vytvoření požadavku HTTP a jedinečného identifikátoru pro hlavičku 'X-ClientTraceId'.These modules are required to construct the HTTP request, and create a unique identifier for the 'X-ClientTraceId' header.

Nastavení klíče předplatného a koncového boduSet the subscription key and endpoint

Tato ukázka se pokusí přečíst klíč předplatného vašeho převaděče a koncový bod z těchto proměnných prostředí: TRANSLATOR_TEXT_SUBSCRIPTION_KEY a TRANSLATOR_TEXT_ENDPOINT .This sample will try to read your Translator subscription key and endpoint from these environment variables: TRANSLATOR_TEXT_SUBSCRIPTION_KEY and TRANSLATOR_TEXT_ENDPOINT. Pokud nejste obeznámeni s proměnnými prostředí, můžete nastavit subscriptionKey a endpoint jako řetězce a komentovat podmíněné příkazy.If you're not familiar with environment variables, you can set subscriptionKey and endpoint as strings and comment out the conditional statements.

Zkopírujte do svého projektu tento kód:Copy this code into your project:

var key_var = 'TRANSLATOR_TEXT_SUBSCRIPTION_KEY';
if (!process.env[key_var]) {
    throw new Error('Please set/export the following environment variable: ' + key_var);
}
var subscriptionKey = process.env[key_var];
var endpoint_var = 'TRANSLATOR_TEXT_ENDPOINT';
if (!process.env[endpoint_var]) {
    throw new Error('Please set/export the following environment variable: ' + endpoint_var);
}
var endpoint = process.env[endpoint_var];

Konfigurace požadavkuConfigure the request

Metoda request() zpřístupněná prostřednictvím modulu požadavků nám umožňuje předat metodu HTTP, adresu URL, parametry požadavku, hlavičky a text JSON jako objekt options.The request() method, made available through the request module, allows us to pass the HTTP method, URL, request params, headers, and the JSON body as an options object. V tomto fragmentu kódu nakonfigurujeme požadavek:In this code snippet, we'll configure the request:

Poznámka

Další informace o koncových bodech, trasách a parametrech požadavků naleznete v tématu Translator 3,0: přeložit.For more information about endpoints, routes, and request parameters, see Translator 3.0: Translate.

let options = {
    method: 'POST',
    baseUrl: endpoint,
    url: 'translate',
    qs: {
      'api-version': '3.0',
      'to': ['de', 'it']
    },
    headers: {
      'Ocp-Apim-Subscription-Key': subscriptionKey,
      'Content-type': 'application/json',
      'X-ClientTraceId': uuidv4().toString()
    },
    body: [{
          'text': 'Hello World!'
    }],
    json: true,
};

Nejjednodušším způsobem, jak ověřit požadavek, je předat klíč předplatného jako hlavičku Ocp-Apim-Subscription-Key, což děláme i v této ukázce.The easiest way to authenticate a request is to pass in your subscription key as an Ocp-Apim-Subscription-Key header, which is what we use in this sample. Alternativně můžete klíč předplatného vyměnit za přístupový token a k ověření požadavku předat přístupový token jako hlavičku Authorization.As an alternative, you can exchange your subscription key for an access token, and pass the access token along as an Authorization header to validate your request.

Pokud používáte Cognitive Services předplatné s více službami, musíte taky zahrnout do Ocp-Apim-Subscription-Region hlaviček vaší žádosti.If you are using a Cognitive Services multi-service subscription, you must also include the Ocp-Apim-Subscription-Region in your request headers.

Další informace najdete v tématu Ověřování.For more information, see Authentication.

Vytvoření požadavku a tisk odpovědiMake the request and print the response

Dále pomocí metody request() vytvoříme požadavek.Next, we'll create the request using the request() method. Tato metoda jako první argument přebírá objekt options, který jsme vytvořili v předchozí části, a pak vytiskne očištěnou odpověď JSON.It takes the options object that we created in the previous section as the first argument, then prints the prettified JSON response.

request(options, function(err, res, body){
    console.log(JSON.stringify(body, null, 4));
});

Poznámka

V této ukázce definujeme požadavek HTTP v objektu options.In this sample, we're defining the HTTP request in the options object. Modul požadavků však podporuje také pomocné metody jako .post a .get.However, the request module also supports convenience methods, like .post and .get. Další informace najdete v článku věnovaném pomocným metodám.For more information, see convenience methods.

Spojení všech součástí dohromadyPut it all together

To je to, že jste připravili jednoduchý program, který bude volat překladatele a vrátil odpověď JSON.That's it, you've put together a simple program that will call the Translator and return a JSON response. Teď je čas program spustit:Now it's time to run your program:

node translate-text.js

Pokud chcete porovnat svůj kód s naším, kompletní ukázka je k dispozici na GitHubu.If you'd like to compare your code against ours, the complete sample is available on GitHub.

Ukázková odpověďSample response

[
    {
        "detectedLanguage": {
            "language": "en",
            "score": 1.0
        },
        "translations": [
            {
                "text": "Hallo Welt!",
                "to": "de"
            },
            {
                "text": "Salve, mondo!",
                "to": "it"
            }
        ]
    }
]

Vyčištění prostředkůClean up resources

Pokud jste do svého programu pevně zakódovali klíč předplatného, nezapomeňte po dokončení tohoto rychlého startu tento klíč předplatného odebrat.If you've hardcoded your subscription key into your program, make sure to remove the subscription key when you're finished with this quickstart.

Další krokyNext steps

Podívejte se na reference k rozhraní API, abyste porozuměli všem, co můžete s překladatelem dělat.Take a look at the API reference to understand everything you can do with the Translator.

PožadavkyPrerequisites

K tomuto rychlému startu potřebujete:This quickstart requires:

NastaveníSet up

Vytvoření prostředku překladateleCreate a Translator resource

Azure Cognitive Services jsou představovány prostředky Azure, ke kterým jste se přihlásili.Azure Cognitive Services are represented by Azure resources that you subscribe to. Vytvořte prostředek pro překladatele pomocí Azure Portal nebo rozhraní příkazového řádku Azure CLI na místním počítači.Create a resource for Translator using the Azure portal or Azure CLI on your local machine. Můžete také:You can also:

  • Získejte zkušební klíč platný po dobu 7 dnů zdarma.Get a trial key valid for 7 days for free. Po registraci bude k dispozici na webu Azure.After signing up, it will be available on the Azure website.
  • Zobrazení existujícího prostředku v Azure Portal.View an existing resource in the Azure portal.

Po získání klíče ze zkušebního předplatného nebo prostředku vytvořte dvě proměnné prostředí:After you get a key from your trial subscription or resource, create two environment variables:

  • TRANSLATOR_TEXT_SUBSCRIPTION_KEY– Klíč předplatného pro váš prostředek překladatele.TRANSLATOR_TEXT_SUBSCRIPTION_KEY - The subscription key for your Translator resource.
  • TRANSLATOR_TEXT_ENDPOINT– Globální koncový bod pro překladatele.TRANSLATOR_TEXT_ENDPOINT - The global endpoint for Translator. Použijte https://api.cognitive.microsofttranslator.com/.Use https://api.cognitive.microsofttranslator.com/.

Vytvoření projektu a import požadovaných modulůCreate a project and import required modules

Vytvořte nový projekt v jazyce Python v oblíbeném integrovaném vývojovém prostředí nebo editoru.Create a new Python project using your favorite IDE or editor. Pak do svého projektu, do souboru s názvem translate-text.py, zkopírujte tento fragment kódu.Then copy this code snippet into your project in a file named translate-text.py. Ujistěte se, že překladač vašeho IDE odkazuje na správnou verzi Pythonu, aby nedocházelo k rozpoznání knihoven.Be sure your IDE's interpreter references the correct version of Python to avoid libraries not being recognized.

# -*- coding: utf-8 -*-
import os, requests, uuid, json

Poznámka

Pokud jste tyto moduly ještě nikdy nepoužili, budete je muset před spuštěním programu nainstalovat.If you haven't used these modules you'll need to install them before running your program. Tyto balíčky nainstalujete spuštěním příkazu pip install requests uuid.To install these packages, run: pip install requests uuid.

První komentář říká interpretu Pythonu, že má použít kódování UTF-8.The first comment tells your Python interpreter to use UTF-8 encoding. Pak se naimportují požadované moduly, abyste si přečetli klíč předplatného z proměnné prostředí, sestavíte požadavek HTTP, vytvoříte jedinečný identifikátor a zpracujete odpověď JSON vrácenou překladatelem.Then required modules are imported to read your subscription key from an environment variable, construct the http request, create a unique identifier, and handle the JSON response returned by the Translator.

Nastavení klíče předplatného, koncového bodu a cestySet the subscription key, endpoint, and path

Tato ukázka se pokusí přečíst klíč a koncový bod předplatného překladatele z proměnných prostředí: TRANSLATOR_TEXT_KEY a TRANSLATOR_TEXT_ENDPOINT .This sample will try to read your Translator subscription key and endpoint from the environment variables: TRANSLATOR_TEXT_KEY and TRANSLATOR_TEXT_ENDPOINT. Pokud nejste obeznámeni s proměnnými prostředí, můžete nastavit subscription_key a endpoint jako řetězce a přidat komentář k podmíněným příkazům.If you're not familiar with environment variables, you can set subscription_key and endpoint as a strings and comment out the conditional statements.

Zkopírujte do svého projektu tento kód:Copy this code into your project:

key_var_name = 'TRANSLATOR_TEXT_SUBSCRIPTION_KEY'
if not key_var_name in os.environ:
    raise Exception('Please set/export the environment variable: {}'.format(key_var_name))
subscription_key = os.environ[key_var_name]

endpoint_var_name = 'TRANSLATOR_TEXT_ENDPOINT'
if not endpoint_var_name in os.environ:
    raise Exception('Please set/export the environment variable: {}'.format(endpoint_var_name))
endpoint = os.environ[endpoint_var_name]

Globální koncový bod překladatele je nastaven jako endpoint .The Translator global endpoint is set as the endpoint. path nastaví trasu translate a určuje, že chceme cílit na rozhraní API verze 3.path sets the translate route and identifies that we want to hit version 3 of the API.

params slouží k nastavení jazyků výstupu.The params are used to set the output languages. V této ukázce překládáme z angličtiny do italštiny a němčiny: it a de.In this sample we're translating from English to Italian and German: it and de.

Poznámka

Další informace o koncových bodech, trasách a parametrech požadavků naleznete v tématu Translator 3,0: přeložit.For more information about endpoints, routes, and request parameters, see Translator 3.0: Translate.

path = '/translate?api-version=3.0'
params = '&to=de&to=it'
constructed_url = endpoint + path + params

Přidání hlavičekAdd headers

Nejjednodušším způsobem, jak ověřit požadavek, je předat klíč předplatného jako hlavičku Ocp-Apim-Subscription-Key, což děláme i v této ukázce.The easiest way to authenticate a request is to pass in your subscription key as an Ocp-Apim-Subscription-Key header, which is what we use in this sample. Alternativně můžete klíč předplatného vyměnit za přístupový token a k ověření požadavku předat přístupový token jako hlavičku Authorization.As an alternative, you can exchange your subscription key for an access token, and pass the access token along as an Authorization header to validate your request. Další informace najdete v tématu Ověřování.For more information, see Authentication.

Zkopírujte do svého projektu tento fragment kódu:Copy this code snippet into your project:

headers = {
    'Ocp-Apim-Subscription-Key': subscription_key,
    'Content-type': 'application/json',
    'X-ClientTraceId': str(uuid.uuid4())
}

Pokud používáte Cognitive Services předplatné s více službami, musíte taky zahrnout Ocp-Apim-Subscription-Region do parametrů žádosti.If you are using a Cognitive Services multi-service subscription, you must also include the Ocp-Apim-Subscription-Region in your request parameters. Přečtěte si další informace o ověřování pomocí předplatného s více službami.Learn more about authenticating with the multi-service subscription.

Vytvoření požadavku na překlad textuCreate a request to translate text

Definujte řetězec (nebo řetězce), který chcete přeložit:Define the string (or strings) that you want to translate:

body = [{
    'text': 'Hello World!'
}]

Dále pomocí modulu requests vytvoříme požadavek POST.Next, we'll create a POST request using the requests module. Tento modul přebírá tři argumenty – zřetězenou adresu URL, hlavičky požadavku a text požadavku:It takes three arguments: the concatenated URL, the request headers, and the request body:

request = requests.post(constructed_url, headers=headers, json=body)
response = request.json()

Posledním krokem je vytisknout výsledky.The last step is to print the results. Tento fragment kódu očistí výsledky tím, že seřadí klíče, nastaví odsazení a deklaruje oddělovače položek a klíčů.This code snippet prettifies the results by sorting the keys, setting indentation, and declaring item and key separators.

print(json.dumps(response, sort_keys=True, indent=4,
                 ensure_ascii=False, separators=(',', ': ')))

Spojení všech součástí dohromadyPut it all together

To je to, že jste připravili jednoduchý program, který bude volat překladatele a vrátil odpověď JSON.That's it, you've put together a simple program that will call the Translator and return a JSON response. Teď je čas program spustit:Now it's time to run your program:

python translate-text.py

Pokud chcete porovnat svůj kód s naším, kompletní ukázka je k dispozici na GitHubu.If you'd like to compare your code against ours, the complete sample is available on GitHub.

Ukázková odpověďSample response

[
    {
        "detectedLanguage": {
            "language": "en",
            "score": 1.0
        },
        "translations": [
            {
                "text": "Hallo Welt!",
                "to": "de"
            },
            {
                "text": "Salve, mondo!",
                "to": "it"
            }
        ]
    }
]

Vyčištění prostředkůClean up resources

Pokud jste do svého programu pevně zakódovali klíč předplatného, nezapomeňte po dokončení tohoto rychlého startu tento klíč předplatného odebrat.If you've hardcoded your subscription key into your program, make sure to remove the subscription key when you're finished with this quickstart.

Další krokyNext steps

Podívejte se na reference k rozhraní API, abyste porozuměli všem, co můžete s překladatelem dělat.Take a look at the API reference to understand everything you can do with the Translator.

Viz takéSee also