Rychlý Start: Vyhledání slov pomocí dvojjazyčného slovníkuQuickstart: Look up words with bilingual dictionary

V tomto rychlém startu se dozvíte, jak získat alternativní překlady pro termín a také příklady použití těchto alternativních překladů pomocí překladatele.In this quickstart, you'll learn how to get alternate translations for a term, and also usage examples of those alternate translations, using the Translator.

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 alternate-sample
cd alternate-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 alternate-sample .It creates a new .NET console application, and creates a directory named alternate-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

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 Newtonsoft.Json;

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 získání alternativních překladůCreate a function to get alternate translations

V rámci Program třídy vytvořte funkci s názvem AltTranslation .Within the Program class, create a function called AltTranslation. Tato třída zapouzdřuje kód používaný k volání zdroje slovníku a vytiskne výsledek do konzoly.This class encapsulates the code used to call the Dictionary resource and prints the result to console.

static void AltTranslation()
{
  /*
   * The code for your call to the translation service will be added to this
   * function in the next few sections.
   */
}

Sestavit identifikátor URIConstruct the URI

Přidejte tyto řádky do AltTranslation funkce.Add these lines to the AltTranslation function. Všimněte si, že spolu s api-version , byly deklarovány dva další parametry.You'll notice that along with the api-version, two additional parameters have been declared. Tyto parametry slouží k nastavení vstupu a výstupu překladu.These parameters are used to set the translation input and output. V této ukázce se jedná o angličtinu ( en ) a španělštinu ( es ).In this sample, these are English (en) and Spanish (es).

string route = "/dictionary/lookup?api-version=3.0";
static string params_ = "from=en&to=es";
static string uri = endpoint + path + params_;

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 poli můžete předat více než jeden objekt body .Keep in mind, you can pass more than one object in the body array.

System.Object[] body = new System.Object[] { new { Text = @"Elephants" } };
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
  • Tisk odpovědiPrint the response

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

// Set the method to POST
request.Method = HttpMethod.Post;

// Construct the full URI
request.RequestUri = new Uri(uri);

// Add the serialized JSON object to your request
request.Content = new StringContent(requestBody, Encoding.UTF8, "application/json");

// Add the authorization header
request.Headers.Add("Ocp-Apim-Subscription-Key", subscriptionKey);

// Send request, get response
var response = client.SendAsync(request).Result;
var jsonResponse = response.Content.ReadAsStringAsync().Result;

// Print the response
Console.WriteLine(PrettyPrint(jsonResponse));
Console.WriteLine("Press any key to continue.");

Přidat PrettyPrint pro přidání formátování do odpovědi JSON:Add PrettyPrint to add formatting to your JSON response:

static string PrettyPrint(string s)
{
    return JsonConvert.SerializeObject(JsonConvert.DeserializeObject(s), Formatting.Indented);
}

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í AltTranslation() Main funkce.The last step is to call AltTranslation() in the Main function. Vyhledejte static void Main(string[] args) a přidejte tyto řádky:Locate static void Main(string[] args) and add these lines:

AltTranslation();
Console.WriteLine("Press any key to continue.");
Console.ReadKey();

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

[
    {
        "displaySource": "elephants",
        "normalizedSource": "elephants",
        "translations": [
            {
                "backTranslations": [
                    {
                        "displayText": "elephants",
                        "frequencyCount": 1207,
                        "normalizedText": "elephants",
                        "numExamples": 5
                    }
                ],
                "confidence": 1.0,
                "displayTarget": "elefantes",
                "normalizedTarget": "elefantes",
                "posTag": "NOUN",
                "prefixWord": ""
            }
        ]
    }
]

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 přejít pomocí oblíbeného integrovaného vývojového prostředí (IDE) nebo nové složky na ploše.Create a new Go project using your favorite IDE / editor or new folder on your desktop. Potom tento fragment kódu zkopírujte do svého projektu nebo složky v souboru s názvem dictionaryLookup.go .Then copy this code snippet into your project/folder in a file named dictionaryLookup.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 + "/dictionary/lookup?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.
     */
    dictionaryLookup(subscriptionKey, uri)
}

Vytvoření funkce pro získání alternativních překladůCreate a function to get alternate translations

Pojďme vytvořit funkci, která získá alternativní překlady.Let's create a function to get alternate translations. 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 dictionaryLookup(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 se překládáme z angličtiny na španělštinu.In this sample, we're translating from English to Spanish.

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

// Build the request URL. See: https://golang.org/pkg/net/url/#example_URL_Parse
u, _ := url.Parse(uri)
q := u.Query()
q.Add("from", "en")
q.Add("to", "es")
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: Lookup Dictionary.For more information about endpoints, routes, and request parameters, see Translator 3.0: Dictionary Lookup.

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 altTranslations funkce.Add this code to the altTranslations function.

// Create an anonymous struct for your request body and encode it to JSON
body := []struct {
    Text string
}{
    {Text: "Pineapples"},
}
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 altTranslations funkce k dekódování odpovědi JSON a pak formátujte a tiskněte výsledek.Add this code to the altTranslations 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 dictionaryLookup.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

[
  {
    "displaySource": "pineapples",
    "normalizedSource": "pineapples",
    "translations": [
      {
        "backTranslations": [
          {
            "displayText": "pineapples",
            "frequencyCount": 158,
            "normalizedText": "pineapples",
            "numExamples": 5
          },
          {
            "displayText": "cones",
            "frequencyCount": 13,
            "normalizedText": "cones",
            "numExamples": 5
          },
          {
            "displayText": "piña",
            "frequencyCount": 5,
            "normalizedText": "piña",
            "numExamples": 3
          },
          {
            "displayText": "ganks",
            "frequencyCount": 3,
            "normalizedText": "ganks",
            "numExamples": 2
          }
        ],
        "confidence": 0.7016,
        "displayTarget": "piñas",
        "normalizedTarget": "piñas",
        "posTag": "NOUN",
        "prefixWord": ""
      },
      {
        "backTranslations": [
          {
            "displayText": "pineapples",
            "frequencyCount": 16,
            "normalizedText": "pineapples",
            "numExamples": 2
          }
        ],
        "confidence": 0.2984,
        "displayTarget": "ananás",
        "normalizedTarget": "ananás",
        "posTag": "NOUN",
        "prefixWord": ""
      }
    ]
  }
]

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 alt-translation-sample
cd alt-translation-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 = "AltTranslation"
}
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 AltTranslation.java .Next, in this folder, create a file named AltTranslation.java.

Importovat požadované knihovnyImport required libraries

Otevřete AltTranslation.java a přidejte tyto příkazy pro import:Open AltTranslation.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 AltTranslation {
  // All project code goes here...
}

Přidejte tyto řádky do AltTranslation třídy.Add these lines to the AltTranslation 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í vstupu a výstupu překladu.These parameters are used to set the translation input and output. V této ukázce se jedná o angličtinu ( en ) a španělštinu ( es ).In this sample, these are English (en) and Spanish (es).

private static String subscriptionKey = System.getenv("TRANSLATOR_TEXT_SUBSCRIPTION_KEY");
private static String endpoint = System.getenv("TRANSLATOR_TEXT_ENDPOINT");
String url = endpoint + "/dictionary/lookup?api-version=3.0&from=en&to=es";

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 AltTranslation třídy pro vytvoření instance OkHttpClient :Add this line to the AltTranslation 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.

// 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\": \"Pineapples\"\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 {
        AltTranslation altTranslationRequest = new AltTranslation();
        String response = altTranslationRequest.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

[
  {
    "normalizedSource": "pineapples",
    "displaySource": "pineapples",
    "translations": [
      {
        "normalizedTarget": "piñas",
        "displayTarget": "piñas",
        "posTag": "NOUN",
        "confidence": 0.7016,
        "prefixWord": "",
        "backTranslations": [
          {
            "normalizedText": "pineapples",
            "displayText": "pineapples",
            "numExamples": 5,
            "frequencyCount": 158
          },
          {
            "normalizedText": "cones",
            "displayText": "cones",
            "numExamples": 5,
            "frequencyCount": 13
          },
          {
            "normalizedText": "piña",
            "displayText": "piña",
            "numExamples": 3,
            "frequencyCount": 5
          },
          {
            "normalizedText": "ganks",
            "displayText": "ganks",
            "numExamples": 2,
            "frequencyCount": 3
          }
        ]
      },
      {
        "normalizedTarget": "ananás",
        "displayTarget": "ananás",
        "posTag": "NOUN",
        "confidence": 0.2984,
        "prefixWord": "",
        "backTranslations": [
          {
            "normalizedText": "pineapples",
            "displayText": "pineapples",
            "numExamples": 2,
            "frequencyCount": 16
          }
        ]
      }
    ]
  }
]

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 editoru nebo vytvořte novou složku na ploše.Create a new project using your favorite IDE or editor, or create a new folder on your desktop. Zkopírujte tento fragment kódu do svého projektu nebo složky do souboru s názvem alt-translations.js .Copy this code snippet into your project/folder into a file named alt-translations.js.

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: Lookup Dictionary.For more information about endpoints, routes, and request parameters, see Translator 3.0: Dictionary Lookup.

let options = {
    method: 'POST',
    baseUrl: endpoint,
    url: 'dictionary/lookup',
    qs: {
      'api-version': '3.0',
      'from': 'en',
      'to': 'es'
    },
    headers: {
      'Ocp-Apim-Subscription-Key': subscriptionKey,
      'Content-type': 'application/json',
      'X-ClientTraceId': uuidv4().toString()
    },
    body: [{
          'text': 'Elephants'
    }],
    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 alt-translations.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

[
    {
        "displaySource": "elephants",
        "normalizedSource": "elephants",
        "translations": [
            {
                "backTranslations": [
                    {
                        "displayText": "elephants",
                        "frequencyCount": 1207,
                        "normalizedText": "elephants",
                        "numExamples": 5
                    }
                ],
                "confidence": 1.0,
                "displayTarget": "elefantes",
                "normalizedTarget": "elefantes",
                "posTag": "NOUN",
                "prefixWord": ""
            }
        ]
    }
]

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 Pythonu pomocí oblíbeného integrovaného vývojového prostředí (IDE) nebo editoru nebo vytvořte novou složku na ploše.Create a new Python project using your favorite IDE or editor, or create a new folder on your desktop. Zkopírujte tento fragment kódu do svého projektu nebo složky do souboru s názvem dictionary-lookup.py .Copy this code snippet into your project/folder into a file named dictionary-lookup.py.

# -*- 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 dictionary/lookup a určuje, že chceme cílit na rozhraní API verze 3.path sets the dictionary/lookup route and identifies that we want to hit version 3 of the API.

params slouží k nastavení jazyků zdroje a výstupu.The params are used to set the source and output languages. V této ukázce používáme angličtinu a španělštinu: en a es.In this sample we're using English and Spanish: en and es.

Poznámka

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

path = '/dictionary/lookup?api-version=3.0'
params = '&from=en&to=es'
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 vyhledání alternativních překladůCreate a request to find alternate translations

Definujte řetězec (nebo řetězce), pro který chcete vyhledat překlady:Define the string (or strings) that you want to find translations for:

# You can pass more than one object in body.
body = [{
    'text': 'Elephants'
}]

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 alt-translations.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

[
    {
        "displaySource": "elephants",
        "normalizedSource": "elephants",
        "translations": [
            {
                "backTranslations": [
                    {
                        "displayText": "elephants",
                        "frequencyCount": 1207,
                        "normalizedText": "elephants",
                        "numExamples": 5
                    }
                ],
                "confidence": 1.0,
                "displayTarget": "elefantes",
                "normalizedTarget": "elefantes",
                "posTag": "NOUN",
                "prefixWord": ""
            }
        ]
    }
]

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