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

V tomto rychlém startu se dozvíte, jak pomocí REST API překladatele přepínat text z jednoho skriptu na jiný.In this quickstart, you'll learn how to transliterate (convert) text from one script to another using the Translator REST API. V uvedené ukázce se provádí transkripce z japonštiny do latinky.In the sample provided, Japanese is transliterated to use the Latin alphabet.

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.

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:

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 transliterate-sample
cd transliterate-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 transliterate-sample .It creates a new .NET console application, and creates a directory named transliterate-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 transliterate-sample.csproj soubor upravit.In this guide, we'll show you how to adjust the transliterate-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 transliterate-sample.csproj .Open your project, then open transliterate-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 třídu, která se používá při deserializaci odpovědi JSON vrácené překladatelem.Next, we're going to create a class that's 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 TransliterationResult
{
    public string Text { get; set; }
    public string Script { 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řepis textuCreate a function to transliterate text

V rámci Program třídy vytvořte asynchronní funkci s názvem TransliterateTextRequest() .Within the Program class, create an asynchronous function called TransliterateTextRequest(). Tato funkce přijímá čtyři argumenty: subscriptionKey , endpoint , a route inputText .This function takes four arguments: subscriptionKey, endpoint, route, and inputText.

static public async Task TransliterateTextRequest(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
  • Tisk odpovědiPrint the response

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.
TransliterationResult[] deserializedOutput = JsonConvert.DeserializeObject<TransliterationResult[]>(result);
// Iterate over the deserialized results.
foreach (TransliterationResult o in deserializedOutput)
{
    Console.WriteLine("Transliterated to {0} script: {1}", o.Script, o.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í TransliterateTextRequest() Main funkce.The last step is to call TransliterateTextRequest() in the Main function. V této ukázce jsme transliterating z japonského skriptu na latinku.In this sample, we're transliterating from Japanese to latin script. 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-transliterate
    string route = "/transliterate?api-version=3.0&language=ja&fromScript=jpan&toScript=latn";
    string textToTransliterate = @"こんにちは";
    await TransliterateTextRequest(subscriptionKey, endpoint, route, textToTransliterate);
    Console.WriteLine("Press any key to continue.");
    Console.ReadKey();
}

Všimněte si, že v nástroji Main deklarujete subscriptionKey ,, endpoint route a skript pro přepis textToTransliterate .You'll notice that in Main, you're declaring subscriptionKey, endpoint, route, and the script to transliterate textToTransliterate.

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:

Transliterated to latn script: Kon\'nichiwa

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:

[
    {
        "script": "latn",
        "text": "konnichiwa"
    }
]

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:

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 transliterate-text.go, zkopírujte tento fragment kódu.Then copy this code snippet into your project in a file named transliterate-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 + "/transliterate?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.
     */
    transliterate(subscriptionKey, uri)
}

Vytvoření funkce pro přepis textuCreate a function to transliterate text

Pojďme vytvořit funkci pro přepis textu.Let's create a function to transliterate 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 transliterate(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 provádíme transkripci z japonštiny do latinky.In this sample, we're transliterating from Japanese to the Latin alphabet.

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

// Build the request URL. See: https://golang.org/pkg/net/url/#example_URL_Parse
u, _ := url.Parse(uri)
q := u.Query()
q.Add("language", "ja")
q.Add("fromScript", "jpan")
q.Add("toScript", "latn")
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: repřepised.For more information about endpoints, routes, and request parameters, see Translator 3.0: Transliterate.

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

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

[
  {
    "script": "latn",
    "text": "konnichiwa"
  }
]

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:

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

Importovat požadované knihovnyImport required libraries

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

Přidejte tyto řádky do Transliterate třídy.Add these lines to the Transliterate 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í vstupního jazyka a ke skriptům pro předávání.These parameters are used to set the input language, and the scripts for transliteration. V této ukázce je nastavená na japonštinu ( jpan ) a latinku ( latn ).In this sample, it's set to Japanese (jpan) and Latin (latn).

private static String subscriptionKey = System.getenv("TRANSLATOR_TEXT_SUBSCRIPTION_KEY");
private static String endpoint = System.getenv("TRANSLATOR_TEXT_ENDPOINT");
String url = endpoint + "/transliterate?api-version=3.0&language=ja&fromScript=jpan&toScript=latn";

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 Transliterate třídy pro vytvoření instance OkHttpClient :Add this line to the Transliterate 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 měnit text pro mezidobu.Feel free to change the text for transliteration.

// 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\": \"こんにちは\"\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 {
        Transliterate transliterateRequest = new Transliterate();
        String response = transliterateRequest.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

[
  {
    "text": "konnichiwa",
    "script": "latn"
  }
]

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:

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: repřepised.For more information about endpoints, routes, and request parameters, see Translator 3.0: Transliterate.

let options = {
    method: 'POST',
    baseUrl: endpoint,
    url: 'transliterate',
    qs: {
      'api-version': '3.0',
      'language': 'ja',
      'fromScript': 'jpan',
      'toScript': 'latn'
    },
    headers: {
      'Ocp-Apim-Subscription-Key': subscriptionKey,
      'Content-type': 'application/json',
      'X-ClientTraceId': uuidv4().toString()
    },
    body: [{
          'text': 'こんにちは'
    }],
    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 transliterate-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

[
    {
        "script": "latn",
        "text": "konnichiwa"
    }
]

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:

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 transliterate-text.py na vašem počítači.Create a new project using your favorite IDE or editor, or a new folder with a file named transliterate-text.py 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:

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

params slouží k nastavení jazyka vstupu a vstupního a výstupního skriptu.The params are used to set the input language, and the input and output scripts. V této ukázce provádíme transkripci z japonštiny do latinky.In this sample, we're transliterating from Japanese to the Latin alphabet.

Poznámka

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

path = '/transliterate?api-version=3.0'
params = '&language=ja&fromScript=jpan&toScript=latn'
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 transkripci textuCreate a request to transliterate text

Definujte řetězec (nebo řetězce), u kterého chcete provést transkripci:Define the string (or strings) that you want to transliterate:

# Transliterate "good afternoon" from source Japanese.
# Note: You can pass more than one object in body.
body = [{
    'text': 'こんにちは'
}]

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

[
    {
        "script": "latn",
        "text": "konnichiwa"
    }
]

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