API เอกสารภาษาอังกฤษเป็นโปรตุเกส | รักษาเค้าโครง | คู่มือ

ความซับซ้อนที่ซ่อนอยู่ของการแปลเอกสารผ่าน API

การผสานรวม API การแปลเอกสารจากภาษาอังกฤษเป็นภาษาโปรตุเกสเข้ากับแอปพลิเคชันของคุณอาจดูตรงไปตรงมาในแวบแรก อย่างไรก็ตาม นักพัฒนาจะประสบกับอุปสรรคทางเทคนิคที่สำคัญอย่างรวดเร็ว ซึ่งเกินกว่าการแทนที่สตริงข้อความธรรมดามาก
ความท้าทายเหล่านี้อาจส่งผลกระทบต่อความสมบูรณ์ของเอกสาร ประสบการณ์ของผู้ใช้ และความสำเร็จโดยรวมของโครงการโลคัลไลเซชันของคุณ หากไม่ได้รับการจัดการโดยบริการเฉพาะทาง

ความยากลำบากหลักอยู่ที่โครงสร้างที่ซับซ้อนของรูปแบบเอกสารสมัยใหม่ ไฟล์ต่างๆ เช่น DOCX, PDF, และ PPTX ไม่ใช่แค่ที่เก็บข้อความเท่านั้น แต่ยังเก็บข้อมูลเค้าโครงที่ซับซ้อน รูปภาพฝังตัว ตาราง และรูปแบบตัวอักษรเฉพาะ
แนวทางการแปลแบบง่ายๆ ที่แยกข้อความออกมาแล้วใส่กลับเข้าไปเกือบจะทำลายโครงสร้างภาพอย่างแน่นอน ทำให้เอกสารดูไม่เป็นมืออาชีพและมักใช้งานไม่ได้
กระบวนการนี้ต้องใช้เอนจิ้นที่ซับซ้อนซึ่งสามารถแยกวิเคราะห์ แปล และสร้างการจัดรูปแบบดั้งเดิมของเอกสารขึ้นใหม่ได้อย่างสมบูรณ์แบบ

รูปแบบไฟล์และการรักษาเค้าโครง

หนึ่งในความท้าทายที่สำคัญที่สุดคือการรักษาเค้าโครงและการจัดรูปแบบดั้งเดิมของเอกสาร รูปแบบต่างๆ เช่น PDF ขึ้นชื่อว่าจัดการได้ยาก โดยมีกระแสข้อความ ตาราง และกราฟิกแบบเวกเตอร์ถูกจัดวางด้วยพิกัดสัมบูรณ์
เมื่อแปลจากภาษาอังกฤษเป็นภาษาโปรตุเกส ความยาวของประโยคมักจะเปลี่ยนไปอย่างมาก ซึ่งอาจทำให้ข้อความล้นขอบเขตที่กำหนดไว้
API ที่แข็งแกร่งจะต้องจัดเรียงข้อความใหม่ ปรับขนาดคอนเทนเนอร์ และปรับระยะห่างอย่างชาญฉลาดเพื่อรองรับความแตกต่างทางภาษา โดยไม่ทำให้ความเที่ยงตรงทางภาพของไฟล์ต้นฉบับเสียหาย

ยิ่งไปกว่านั้น องค์ประกอบต่างๆ เช่น ส่วนหัว ส่วนท้าย แผนภูมิ และกล่องข้อความ จะต้องถูกระบุและแปลเนื้อหาขององค์ประกอบเหล่านั้นตามบริบท การแปลเพียงเนื้อหาหลักของข้อความไม่เพียงพอต่อการสร้างเอกสารที่โลคัลไลซ์อย่างมืออาชีพ
API ต้องแยกวิเคราะห์แบบจำลองวัตถุเอกสารทั้งหมด แปลองค์ประกอบที่เป็นข้อความแต่ละส่วน แล้วประกอบไฟล์กลับคืนอย่างสมบูรณ์แบบ
สิ่งนี้ทำให้มั่นใจได้ว่าเอกสารภาษาโปรตุเกสฉบับสุดท้ายจะเป็นภาพสะท้อนที่แท้จริงของแหล่งข้อมูลภาษาอังกฤษ ไม่เพียงแต่ในเนื้อหาเท่านั้น แต่ยังรวมถึงการนำเสนออย่างมืออาชีพด้วย

การเข้ารหัสอักขระและอักขระพิเศษ

การจัดการการเข้ารหัสอักขระอย่างถูกต้องเป็นอีกแง่มุมที่สำคัญ โดยเฉพาะอย่างยิ่งสำหรับภาษาเช่นภาษาโปรตุเกส ภาษาโปรตุเกสใช้เครื่องหมายกำกับเสียงและอักขระพิเศษที่หลากหลาย เช่น the cedilla (ç) และสระที่มีเครื่องหมายเน้นเสียงต่างๆ (á, â, à, ã, é, ê, í, ó, ô, õ, ú)
หาก API หรือโค้ดผสานรวมของคุณจัดการการเข้ารหัสอักขระผิดพลาด คุณจะลงเอยด้วยข้อความที่เสียหายอย่างหลีกเลี่ยงไม่ได้ ซึ่งมักแสดงเป็น mojibake (e.g., black diamonds with question marks).
สิ่งนี้ไม่เพียงแต่ทำให้เอกสารอ่านไม่ได้เท่านั้น แต่ยังทำลายความน่าเชื่อถือของแอปพลิเคชันของคุณและคุณภาพการแปลที่รับรู้อย่างรุนแรงอีกด้วย

API การแปลที่เชื่อถือได้ต้องจัดการการแปลงการเข้ารหัสทั้งหมดโดยเนื้อแท้ โดยปกติแล้วจะกำหนดมาตรฐานเป็น UTF-8 ตลอดกระบวนการ จะต้องสามารถอ่านไฟล์ต้นฉบับได้โดยไม่คำนึงถึงการเข้ารหัสเริ่มต้น ประมวลผลเนื้อหาได้อย่างถูกต้อง และส่งออกไฟล์ที่แปลแล้วพร้อมการเข้ารหัสที่ถูกต้องสำหรับอักขระภาษาโปรตุเกสทั้งหมด
นักพัฒนาไม่ควรกังวลเกี่ยวกับชุดอักขระและเครื่องหมายลำดับไบต์
API ควรแยกความซับซ้อนนี้ออกไป โดยมอบประสบการณ์ที่ราบรื่นตั้งแต่การอัปโหลดไฟล์ไปจนถึงการดาวน์โหลดไฟล์ที่แปลแล้ว

ความสามารถในการปรับขนาดและการประมวลผลแบบอะซิงโครนัส

การแปลเอกสารเป็นงานที่ต้องใช้ทรัพยากรมาก ซึ่งไม่สามารถดำเนินการให้เสร็จสิ้นได้ภายในข้อจำกัดด้านเวลาของคำขอ HTTP แบบซิงโครนัสมาตรฐานเสมอไป การแปลไฟล์ PDF ที่ซับซ้อนหลายหน้าอาจใช้เวลาหลายวินาทีหรือหลายนาที ซึ่งนานเกินไปที่ไคลเอนต์จะรอการตอบกลับ
การพยายามจัดการสิ่งนี้แบบซิงโครนัสจะนำไปสู่การหมดเวลาของคำขอ ผู้ใช้รู้สึกหงุดหงิด และการผสานรวมที่ไม่น่าเชื่อถือ
สถาปัตยกรรมที่ปรับขนาดได้ต้องใช้รูปแบบการประมวลผลแบบอะซิงโครนัสเพื่อจัดการงานที่ใช้เวลานานเหล่านี้อย่างมีประสิทธิภาพและเชื่อถือได้

แนวทางแบบอะซิงโครนัสนี้มักเกี่ยวข้องกับเวิร์กโฟลว์หลายขั้นตอน นักพัฒนาจะอัปโหลดเอกสารก่อน และ API จะส่งคืนตัวระบุงานหรือเอกสารทันที
จากนั้นนักพัฒนาสามารถใช้ตัวระบุนี้เพื่อตรวจสอบปลายทางสถานะเป็นระยะ หรือในระบบขั้นสูงกว่านั้น สามารถรับการแจ้งเตือน webhook เมื่อการแปลเสร็จสมบูรณ์
สิ่งนี้จะแยกคำขอเริ่มต้นออกจากผลลัพธ์สุดท้าย สร้างระบบที่ไม่บล็อกซึ่งมีความยืดหยุ่นและปรับขนาดได้มากขึ้นสำหรับการจัดการการประมวลผลเป็นชุดหรือไฟล์ขนาดใหญ่

ขอแนะนำ Doctranslate API สำหรับการแปลที่ราบรื่น

The Doctranslate API เป็นบริการ RESTful ที่ออกแบบมาโดยเฉพาะเพื่อแก้ปัญหาที่ซับซ้อนเหล่านี้ โดยมอบเครื่องมืออันทรงพลังแก่นักพัฒนาสำหรับการผสานรวม API การแปลเอกสารจากภาษาอังกฤษเป็นภาษาโปรตุเกส มันจะแยกความยุ่งยากในการแยกวิเคราะห์ไฟล์ การรักษาเค้าโครง และการประมวลผลแบบอะซิงโครนัสออกไป ทำให้คุณสามารถมุ่งเน้นไปที่ตรรกะหลักของแอปพลิเคชันของคุณได้
ด้วยชุดปลายทางที่เรียบง่ายแต่แข็งแกร่ง คุณสามารถทำให้เวิร์กโฟลว์โลคัลไลเซชันเอกสารทั้งหมดของคุณเป็นแบบอัตโนมัติได้ด้วยความพยายามเพียงเล็กน้อย
สำหรับนักพัฒนาที่กำลังมองหาโซลูชันที่ครอบคลุม คุณสามารถ บรรลุการแปลเอกสารที่สมบูรณ์แบบในขณะที่ยังคงการจัดรูปแบบเดิมไว้ โดยใช้แพลตฟอร์มที่ทรงพลังของ Doctranslate

API ของเราสร้างขึ้นบนรากฐานของหลักการสำคัญหลายประการที่ออกแบบมาเพื่อประสิทธิภาพการทำงานของนักพัฒนาและความน่าเชื่อถือระดับองค์กร เรานำเสนอ การรองรับรูปแบบไฟล์ที่หลากหลาย รวมถึงรูปแบบที่ซับซ้อน เช่น DOCX, PDF, PPTX, XLSX, และอื่นๆ เพื่อให้มั่นใจว่าคุณสามารถจัดการเอกสารใดๆ ที่ผู้ใช้ของคุณให้มาได้
หัวใจหลักของบริการของเราคือ เอนจิ้นการรักษาเค้าโครงที่ล้ำสมัย ซึ่งช่วยให้มั่นใจว่าเอกสารภาษาโปรตุเกสที่แปลแล้วจะมีลักษณะทางสายตาเหมือนกับแหล่งข้อมูลภาษาอังกฤษทุกประการ
ทั้งหมดนี้ส่งมอบผ่าน สถาปัตยกรรมแบบอะซิงโครนัส โดยสมบูรณ์ ซึ่งให้การตอบสนองแบบ JSON เพื่อการผสานรวมที่ง่ายดายและปรับขนาดได้เพื่อตอบสนองความต้องการใดๆ

คำแนะนำทีละขั้นตอนสำหรับการผสานรวม API การแปลเอกสารภาษาอังกฤษเป็นโปรตุเกส

คู่มือนี้ให้คำแนะนำเชิงปฏิบัติในการแปลเอกสารจากภาษาอังกฤษเป็นภาษาโปรตุเกสโดยใช้ The Doctranslate API เราจะครอบคลุมทั้งกระบวนการ ตั้งแต่การตรวจสอบสิทธิ์และการอัปโหลดไฟล์ ไปจนถึงการตรวจสอบสถานะการแปลและการดาวน์โหลดผลลัพธ์สุดท้าย
การทำตามขั้นตอนเหล่านี้จะช่วยให้คุณสามารถสร้างคุณสมบัติการแปลเอกสารที่แข็งแกร่งและเป็นอัตโนมัติภายในแอปพลิเคชันของคุณได้
กระบวนการนี้ได้รับการออกแบบให้เป็นไปตามหลักเหตุผลและตรงไปตรงมาสำหรับนักพัฒนาทุกคนที่คุ้นเคยกับการใช้ REST APIs

ขั้นตอนที่ 1: การตรวจสอบสิทธิ์และการตั้งค่า

ก่อนทำการเรียกใช้ API ใดๆ คุณต้องได้รับคีย์ API ที่ไม่ซ้ำกัน คุณสามารถค้นหาคีย์นี้ได้ใน Doctranslate developer dashboard ของคุณหลังจากลงทะเบียนบัญชี
คีย์นี้เป็นข้อมูลรับรองของคุณสำหรับการเข้าถึง API และต้องรวมอยู่ในส่วนหัวของทุกคำขอที่คุณทำ
สิ่งสำคัญคือต้องเก็บคีย์นี้ไว้เป็นความลับและปลอดภัย โดยถือว่าคีย์นี้เหมือนกับรหัสผ่านหรือข้อมูลรับรองที่ละเอียดอ่อนอื่นๆ ในระบบของคุณ

การตรวจสอบสิทธิ์จะได้รับการจัดการผ่านส่วนหัว HTTP ที่กำหนดเอง: X-API-Key คุณจะต้องส่งคีย์ API ของคุณในส่วนหัวนี้สำหรับทุกคำขอไปยังปลายทางที่ได้รับการป้องกัน
การไม่ให้คีย์ที่ถูกต้องจะส่งผลให้เกิดการตอบสนองข้อผิดพลาด 401 Unauthorized จากเซิร์ฟเวอร์
เราแนะนำให้จัดเก็บคีย์ API ของคุณไว้ในตัวแปรสภาพแวดล้อมที่ปลอดภัยหรือบริการจัดการความลับ แทนที่จะฮาร์ดโค้ดโดยตรงในซอร์สโค้ดของแอปพลิเคชันของคุณ

ขั้นตอนที่ 2: การอัปโหลดเอกสารของคุณเพื่อแปล

ขั้นตอนแรกในเวิร์กโฟลว์การแปลคือการอัปโหลดเอกสารต้นฉบับของคุณไปยัง Doctranslate API ซึ่งทำได้โดยการส่งคำขอ POST ไปยังปลายทาง /v3/documents
คำขอต้องจัดรูปแบบเป็น multipart/form-data และรวมไฟล์เองพร้อมกับพารามิเตอร์ที่ระบุภาษาต้นทางและภาษาเป้าหมาย
ในกรณีของเรา ภาษาต้นทางคือภาษาอังกฤษ (en) และภาษาเป้าหมายคือภาษาโปรตุเกส (pt)

ฟิลด์แบบฟอร์มที่จำเป็นคือ file, source_lang, และ target_lang API จะประมวลผลการอัปโหลด และเมื่อสำเร็จ จะตอบกลับด้วยวัตถุ JSON ที่มี document_id ที่ไม่ซ้ำกัน
ID นี้เป็นกุญแจสำคัญในการจัดการเอกสารเฉพาะนี้ตลอดวงจรชีวิตการแปลที่เหลือ
คุณต้องจัดเก็บ document_id นี้ไว้ เนื่องจากคุณจะต้องใช้สำหรับขั้นตอนถัดไปของการเริ่มต้นการแปลและการตรวจสอบสถานะ

ขั้นตอนที่ 3: การเริ่มต้นงานแปล

เมื่อเอกสารของคุณอัปโหลดสำเร็จแล้ว คุณจะมี document_id อย่างไรก็ตาม กระบวนการแปลจะไม่เริ่มโดยอัตโนมัติ
คุณต้องเรียกใช้กระบวนการนี้อย่างชัดเจนโดยการส่งคำขอ POST ไปยังปลายทาง /v3/documents/{document_id}/translate โดยแทนที่ {document_id} ด้วย ID ที่คุณได้รับในขั้นตอนก่อนหน้า
การออกแบบนี้ให้คุณควบคุมเวิร์กโฟลว์ของคุณได้มากขึ้น ทำให้คุณสามารถอัปโหลดเอกสารเป็นชุดก่อนที่จะตัดสินใจว่าจะเริ่มงานแปลเมื่อใด

ปลายทางนี้ไม่ต้องการเนื้อหาคำขอ; ID เอกสารใน URL ก็เพียงพอที่จะระบุงานได้ API จะตอบกลับด้วยข้อความยืนยัน และสถานะการแปลจะเปลี่ยนเป็น processing
การแปลจริงจะเกิดขึ้นแบบอะซิงโครนัสในเบื้องหลัง ทำให้แอปพลิเคชันของคุณสามารถดำเนินการงานอื่น ๆ ต่อไปได้โดยไม่ต้องรอ
การดำเนินการที่ไม่บล็อกนี้มีความสำคัญสำหรับการสร้างแอปพลิเคชันที่ตอบสนองและปรับขนาดได้

ขั้นตอนที่ 4: การตรวจสอบสถานะและการดาวน์โหลดผลลัพธ์

เนื่องจากการแปลเป็นกระบวนการแบบอะซิงโครนัส คุณจึงต้องมีวิธีตรวจสอบความคืบหน้า คุณสามารถทำได้โดยการตรวจสอบปลายทางสถานะด้วยคำขอ GET ไปยัง /v3/documents/{document_id}
การตอบกลับ JSON จากปลายทางนี้จะรวมฟิลด์ status ซึ่งจะระบุสถานะปัจจุบันของงาน เช่น uploaded, processing, หรือ done
คุณควรใช้กลไกการตรวจสอบในแอปพลิเคชันของคุณที่ตรวจสอบปลายทางนี้เป็นระยะจนกว่าสถานะจะกลายเป็น done

เมื่อสถานะเป็น done เอกสารที่แปลแล้วก็พร้อมสำหรับการดาวน์โหลด ในการเรียกข้อมูล คุณต้องส่งคำขอ GET สุดท้ายไปยังปลายทางการดาวน์โหลด: /v3/documents/{document_id}/download
API จะตอบกลับด้วยสตรีมไฟล์ไบนารีของเอกสารภาษาโปรตุเกสที่แปลแล้ว โดยยังคงรักษาชื่อไฟล์เดิมไว้
แอปพลิเคชันของคุณควรได้รับการกำหนดค่าให้จัดการสตรีมไฟล์นี้ ไม่ว่าจะโดยการบันทึกไปยังดิสก์หรือส่งต่อไปยังผู้ใช้ปลายทาง

ตัวอย่างโค้ด Python ที่สมบูรณ์

นี่คือสคริปต์ Python ที่สมบูรณ์ซึ่งแสดงเวิร์กโฟลว์ทั้งหมดโดยใช้ไลบรารี requests ยอดนิยม ตัวอย่างนี้ครอบคลุมการอัปโหลดไฟล์ การเริ่มการแปล การตรวจสอบความสมบูรณ์ และการดาวน์โหลดผลลัพธ์สุดท้าย
อย่าลืมแทนที่ 'YOUR_API_KEY' และ 'path/to/your/document.docx' ด้วยคีย์ API จริงและเส้นทางไฟล์ของคุณ
โค้ดนี้ให้เทมเพลตที่ใช้งานได้จริง ซึ่งคุณสามารถปรับเปลี่ยนและผสานรวมเข้ากับโครงการของคุณได้โดยตรง

import requests
import time
import os

# Configuration
API_KEY = os.getenv('DOCTRANSLATE_API_KEY', 'YOUR_API_KEY')
BASE_URL = 'https://developer.doctranslate.io/v3'
FILE_PATH = 'path/to/your/document.docx' # e.g., './english_report.docx'
SOURCE_LANG = 'en'
TARGET_LANG = 'pt'

headers = {
    'X-API-Key': API_KEY
}

def upload_document():
    """Uploads the document to the API."""
    print(f"Uploading {os.path.basename(FILE_PATH)}...")
    with open(FILE_PATH, 'rb') as f:
        files = {'file': (os.path.basename(FILE_PATH), f)}
        data = {'source_lang': SOURCE_LANG, 'target_lang': TARGET_LANG}
        response = requests.post(f"{BASE_URL}/documents", headers=headers, files=files, data=data)
        response.raise_for_status() # Raises an exception for bad status codes
        document_id = response.json().get('document_id')
        print(f"Document uploaded successfully. ID: {document_id}")
        return document_id

def start_translation(document_id):
    """Starts the translation process for the given document ID."""
    print(f"Starting translation for document {document_id}...")
    url = f"{BASE_URL}/documents/{document_id}/translate"
    response = requests.post(url, headers=headers)
    response.raise_for_status()
    print("Translation job initiated.")

def poll_translation_status(document_id):
    """Polls the API until the translation is complete."""
    print("Polling for translation status...")
    url = f"{BASE_URL}/documents/{document_id}"
    while True:
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        status = response.json().get('status')
        print(f"Current status: {status}")
        if status == 'done':
            print("Translation complete!")
            break
        elif status == 'error':
            raise Exception("Translation failed with an error.")
        time.sleep(5) # Wait for 5 seconds before polling again

def download_translated_document(document_id):
    """Downloads the final translated document."""
    print(f"Downloading translated document for ID: {document_id}")
    url = f"{BASE_URL}/documents/{document_id}/download"
    response = requests.get(url, headers=headers, stream=True)
    response.raise_for_status()

    # Construct a new filename for the translated document
    original_filename = os.path.basename(FILE_PATH)
    name, ext = os.path.splitext(original_filename)
    translated_filename = f"{name}_{TARGET_LANG}{ext}"

    with open(translated_filename, 'wb') as f:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)
    print(f"Translated document saved as {translated_filename}")

if __name__ == '__main__':
    if API_KEY == 'YOUR_API_KEY':
        print("Please set your API key.")
    elif not os.path.exists(FILE_PATH):
        print(f"File not found at {FILE_PATH}")
    else:
        try:
            doc_id = upload_document()
            start_translation(doc_id)
            poll_translation_status(doc_id)
            download_translated_document(doc_id)
        except requests.exceptions.HTTPError as e:
            print(f"An HTTP error occurred: {e.response.status_code} {e.response.text}")
        except Exception as e:
            print(f"An error occurred: {e}")


ข้อควรพิจารณาที่สำคัญสำหรับการแปลภาษาโปรตุเกส
ในขณะที่ API ที่ทรงพลังจัดการด้านเทคนิค นักพัฒนาควรตระหนักถึงความแตกต่างทางภาษาศาสตร์บางประการของภาษาโปรตุเกสเพื่อให้แน่ใจว่าได้ผลลัพธ์ที่มีคุณภาพสูงสุด ข้อควรพิจารณาเหล่านี้สามารถช่วยในการกำหนดความคาดหวังของผู้ใช้และในการดำเนินการประกันคุณภาพบนเอกสารที่แปลแล้ว
 การทำความเข้าใจรายละเอียดเหล่านี้ช่วยเชื่อมช่องว่างระหว่างการแปลที่ถูกต้องทางเทคนิคกับการแปลที่สอดคล้องกับวัฒนธรรม
 ความรู้นี้จะยกระดับแอปพลิเคชันของคุณจากเครื่องมือธรรมดาไปสู่โซลูชันที่ซับซ้อน
คำว่า ‘คุณ’ แบบทางการกับไม่เป็นทางการ (Tu กับ Você)
ภาษาโปรตุเกสมีคำสรรพนามที่แตกต่างกันสำหรับคำว่า ‘คุณ’ ซึ่งสามารถบ่งบอกถึงระดับความเป็นทางการที่แตกต่างกันและแตกต่างกันไปตามภูมิภาค ในบราซิล ‘você’ ถูกนำมาใช้กันอย่างแพร่หลายสำหรับทั้งบริบทที่เป็นทางการและไม่เป็นทางการ ในขณะที่ ‘tu’ ใช้ในบางภูมิภาคที่เฉพาะเจาะจง
 ในโปรตุเกส ‘tu’ เป็นคำสรรพนามที่ไม่เป็นทางการทั่วไป และ ‘você’ สงวนไว้สำหรับสถานการณ์ที่เป็นทางการมากขึ้น
 แม้ว่าเครื่องมือแปลสมัยใหม่จะมีความตระหนักถึงบริบทมากขึ้น แต่โทนเสียงของข้อความภาษาอังกฤษต้นฉบับของคุณสามารถมีอิทธิพลต่อรูปแบบที่เลือก ซึ่งส่งผลกระทบต่อการรับรู้ของผู้พูดภาษาแม่ต่อเอกสารฉบับสุดท้าย
คำนามและคำคุณศัพท์ที่มีเพศ
เช่นเดียวกับภาษาโรมานซ์อื่นๆ ภาษาโปรตุเกสมีเพศทางไวยากรณ์สำหรับคำนาม ซึ่งหมายความว่าคำนามจะถูกจัดประเภทเป็นเพศชายหรือเพศหญิง สิ่งนี้ส่งผลต่อคำนำหน้านาม (o/a) และคำคุณศัพท์ที่ขยายคำนามเหล่านั้น ซึ่งต้องสอดคล้องกับเพศและจำนวน
 วลีภาษาอังกฤษเช่น “The new system is fast” กำหนดให้ผู้แปลต้องทราบเพศของ “system” (o sistema, เพศชาย) เพื่อสร้างวลี “O novo sistema é rápido” อย่างถูกต้อง
 The Doctranslate API ได้รับการฝึกฝนบนชุดข้อมูลขนาดใหญ่เพื่อจัดการกฎไวยากรณ์เหล่านี้อย่างถูกต้อง แต่เป็นพื้นที่สำคัญที่ต้องตรวจสอบในระหว่างการควบคุมคุณภาพ โดยเฉพาะอย่างยิ่งสำหรับสื่อการตลาดหรือวัสดุทางเทคนิคที่ผู้ใช้เห็น
การจัดการสำนวนภาษา
สำนวนภาษาเป็นความท้าทายทั่วไปในโครงการแปลใดๆ วลีเช่น “it’s raining cats and dogs” ไม่สามารถแปลตามตัวอักษรเป็นภาษาโปรตุเกสได้โดยไม่ทำให้เกิดความสับสน
 เอนจิ้นการแปลที่มีคุณภาพสูงจะต้องตระหนักถึงลักษณะสำนวนของวลีและแทนที่ด้วยสำนวนภาษาโปรตุเกสที่เทียบเท่ากัน เช่น “está chovendo canivetes” (it’s raining pocketknives).
 ในขณะที่แบบจำลองพื้นฐานของ API ของเรามีความเชี่ยวชาญในเรื่องนี้ นักพัฒนาที่ผสานรวมการแปลสำหรับเนื้อหาที่สร้างสรรค์หรือทางการตลาดควรระวังภาษาที่เป็นสำนวนอย่างมาก และพิจารณาขั้นตอนการตรวจสอบโดยมนุษย์สำหรับเอกสารสำคัญ
บทสรุปและขั้นตอนถัดไป
การผสานรวม API การแปลเอกสารจากภาษาอังกฤษเป็นภาษาโปรตุเกสคุณภาพสูงเป็นขั้นตอนที่เปลี่ยนแปลงสำหรับแอปพลิเคชันใดๆ ที่ต้องการขยายขอบเขต แม้ว่างานนี้จะเต็มไปด้วยความท้าทายทางเทคนิค เช่น การรักษาเค้าโครงและการประมวลผลแบบอะซิงโครนัส แต่ The Doctranslate API ก็มอบโซลูชันที่แข็งแกร่งและเป็นมิตรกับนักพัฒนา
 ด้วยการแยกความซับซ้อนนี้ออกไป ทำให้คุณสามารถนำคุณสมบัติโลคัลไลเซชันที่ทรงพลังไปใช้อย่างรวดเร็วและเชื่อถือได้
 คู่มือนี้ได้แนะนำคุณตลอดกระบวนการผสานรวมทั้งหมด ตั้งแต่การทำความเข้าใจปัญหาหลักไปจนถึงการนำเวิร์กโฟลว์เต็มรูปแบบไปใช้พร้อมตัวอย่างโค้ดที่ใช้งานได้จริง
ตอนนี้คุณมีความรู้ที่จะทำให้การแปลเอกสารของคุณเป็นแบบอัตโนมัติ รักษาการจัดรูปแบบที่สำคัญ และจัดการความแตกต่างทางภาษาศาสตร์ของภาษาโปรตุเกสได้แล้ว เราขอแนะนำให้คุณสำรวจ API ต่อไป และดูว่ามันสามารถปรับปรุงความพยายามในการทำสากลของคุณได้อย่างไร
 ขั้นตอนต่อไปคือการรับคีย์ API ของคุณและเริ่มสร้าง
 สำหรับกรณีการใช้งานขั้นสูง การอ้างอิงปลายทางโดยละเอียด และข้อมูลเพิ่มเติม โปรดดูเอกสารประกอบ API อย่างเป็นทางการของเรา