API ສໍາລັບການແປເອກະສານ ພາສາອັງກິດ ເປັນ ພາສາຈີນ: ຄູ່ມືທີ່ໄວ ແລະ ຊັດເຈນ

ເປັນຫຍັງການແປເອກະສານຜ່ານ API ຈຶ່ງມີຄວາມຊັບຊ້ອນຢ່າງຫຼວງຫຼາຍ

ການເຊື່ອມໂຍງວິທີແກ້ໄຂແບບອັດຕະໂນມັດ ເພື່ອແປເອກະສານຈາກ ພາສາອັງກິດ ເປັນ ພາສາຈີນ ອາດຈະເບິ່ງຄືວ່າງ່າຍດາຍໃນຕອນຕົ້ນ.
ແນວໃດກໍ່ຕາມ, ນັກພັດທະນາຈະພົບກັບອຸປະສັກທາງດ້ານເຕັກນິກທີ່ສໍາຄັນ ທີ່ API ການແປຂໍ້ຄວາມທໍາມະດາບໍ່ສາມາດຈັດການໄດ້ຢ່າງໄວວາ.
ການນໍາໃຊ້ API ສະເພາະເພື່ອແປເອກະສານ ພາສາອັງກິດ ເປັນ ພາສາຈີນ ແມ່ນມີຄວາມຈໍາເປັນ ເພາະວ່າມັນແກ້ໄຂບັນຫາທີ່ກ່ຽວຂ້ອງກັບຄວາມສົມບູນຂອງໄຟລ໌, ການເຂົ້າລະຫັດ, ແລະ ຄວາມຊັດເຈນຂອງຮູບພາບ.

ອຸປະສັກສໍາຄັນທໍາອິດແມ່ນການເຂົ້າລະຫັດຕົວອັກສອນ, ເຊິ່ງເປັນປັດໃຈສໍາຄັນໃນເວລາຈັດການກັບສະຄຣິບທີ່ບໍ່ແມ່ນພາສາລາຕິນ ເຊັ່ນ ພາສາຈີນ.
ໃນຂະນະທີ່ຕົວອັກສອນ ພາສາອັງກິດ ເຂົ້າກັນໄດ້ຢ່າງຄ່ອງແຄ້ວໃນ ASCII, ພາສາຈີນ ຮຽກຮ້ອງໃຫ້ມີຊຸດຕົວອັກສອນຫຼາຍໄບທ໌ ເຊັ່ນ UTF-8, GB2312, ຫຼື Big5.
ການຈັດການການເຂົ້າລະຫັດຜິດພາດໃນລະຫວ່າງການອ່ານໄຟລ໌, ການສົ່ງຜ່ານ API, ຫຼື ຂະບວນການຂຽນໄຟລ໌ ສາມາດນໍາໄປສູ່ຂໍ້ຄວາມທີ່ຜິດປົກກະຕິ, ເຊິ່ງເອີ້ນວ່າ “mojibake,” ເຮັດໃຫ້ເອກະສານບໍ່ສາມາດອ່ານໄດ້ຢ່າງສົມບູນ ແລະ ບໍ່ເປັນມືອາຊີບ.

ສິ່ງທ້າທາຍທີສອງ, ແລະ ມີຄວາມສໍາຄັນເທົ່າທຽມກັນ, ແມ່ນການຮັກສາຮູບແບບ ແລະ ການຈັດຮູບແບບເດີມຂອງເອກະສານ.
ເອກະສານມືອາຊີບ ເຊັ່ນ: ສັນຍາທາງກົດໝາຍ, ແຜ່ນພັບການຕະຫຼາດ, ຫຼື ຄູ່ມືດ້ານເຕັກນິກ ແມ່ນອີງໃສ່ໂຄງສ້າງຂອງພວກມັນຢ່າງໜັກ, ລວມທັງຕາຕະລາງ, ຖັນ, ຫົວຂໍ້, ທ້າຍຂໍ້ຄວາມ, ແລະ ການຈັດວາງຮູບພາບ.
ການແປແບບບໍ່ມີການວາງແຜນ ທີ່ພຽງແຕ່ສະກັດ ແລະ ທົດແທນສະຕຣິງຂໍ້ຄວາມ ຈະເຮັດໃຫ້ໂຄງສ້າງນີ້ແຕກຫັກຢ່າງຫຼີກລ່ຽງບໍ່ໄດ້, ສົ່ງຜົນໃຫ້ໄຟລ໌ມີຄວາມວຸ້ນວາຍ ແລະ ບໍ່ສາມາດນໍາໃຊ້ໄດ້ ເຊິ່ງຮຽກຮ້ອງໃຫ້ມີການປັບປຸງດ້ວຍຕົນເອງຢ່າງກວ້າງຂວາງ.

ສຸດທ້າຍ, ໂຄງສ້າງພື້ນຖານຂອງໄຟລ໌ເອກະສານທີ່ທັນສະໄໝ ເພີ່ມຄວາມຊັບຊ້ອນອີກຊັ້ນໜຶ່ງ.
ຮູບແບບຕ່າງໆ ເຊັ່ນ DOCX, PPTX, ຫຼື XLSX ບໍ່ແມ່ນໄຟລ໌ຂໍ້ຄວາມທໍາມະດາ; ພວກມັນແມ່ນໄຟລ໌ເກັບທີ່ຖືກບີບອັດ ທີ່ມີໄຟລ໌ XML ຫຼາຍອັນ, stylesheets, ສື່ຕ່າງໆ, ແລະ metadata.
ວິທີແກ້ໄຂການແປທີ່ແຂງແຮງ ຕ້ອງສາມາດວິເຄາະຊຸດທັງໝົດນີ້ໄດ້, ກໍານົດເນື້ອໃນຂໍ້ຄວາມທີ່ສາມາດແປໄດ້ພາຍໃນໂນດ XML ທີ່ຖືກຕ້ອງ, ແລະ ຫຼັງຈາກນັ້ນ ສ້າງໄຟລ໌ເກັບຄືນໃໝ່ຢ່າງສົມບູນດ້ວຍເນື້ອໃນທີ່ຖືກແປ, ເຊິ່ງເປັນໜ້າວຽກທີ່ຢູ່ເໜືອຂອບເຂດຂອງ API ຂໍ້ຄວາມພື້ນຖານ.

ການນໍາສະເໜີ Doctranslate API ສໍາລັບການແປເອກະສານທີ່ລຽບງ່າຍ

Doctranslate API ຖືກອອກແບບມາສະເພາະ ເພື່ອເອົາຊະນະສິ່ງທ້າທາຍທີ່ສັບສົນເຫຼົ່ານີ້, ໂດຍໃຫ້ວິທີແກ້ໄຂທີ່ມີປະສິດທິພາບ ແລະ ເຊື່ອຖືໄດ້ສໍາລັບນັກພັດທະນາ.
ຖືກສ້າງຂຶ້ນເປັນ RESTful API, ມັນດໍາເນີນການຕາມຮູບແບບທີ່ງ່າຍດາຍ, ສາມາດຄາດເດົາໄດ້ ໂດຍນໍາໃຊ້ວິທີການ HTTP ມາດຕະຖານ ແລະ ສົ່ງຄືນຄໍາຕອບທີ່ຈັດຮູບແບບ JSON.
ການອອກແບບນີ້ຮັບປະກັນການເຊື່ອມໂຍງງ່າຍເຂົ້າໄປໃນເກືອບທຸກພາສາການຂຽນໂປຣແກຣມ ຫຼື ຊຸດແອັບພລິເຄຊັນ, ຕັ້ງແຕ່ web backends ໄປຈົນເຖິງ desktop applications.

ໂດຍຫຼັກແລ້ວ, API ຖືກອອກແບບມາສໍາລັບ ການແປໄຟລ໌ຕໍ່ໄຟລ໌ທີ່ມີຄວາມຖືກຕ້ອງສູງ, ໝາຍຄວາມວ່າມັນປະມວນຜົນເອກະສານທັງໝົດ, ບໍ່ແມ່ນແຕ່ຂໍ້ຄວາມເທົ່ານັ້ນ.
ມັນວິເຄາະໄຟລ໌ຕົ້ນສະບັບຢ່າງສະຫຼາດ, ບໍ່ວ່າຈະເປັນ PDF, DOCX, ຫຼື ຮູບແບບທີ່ຮອງຮັບອື່ນໆ, ຮັກສາຮູບແບບທີ່ສັບສົນ, ຟອນ, ແລະ ຮູບພາບ.
ຈາກນັ້ນ, ລະບົບຈະແປເນື້ອໃນຂໍ້ຄວາມ ໂດຍນໍາໃຊ້ເຄື່ອງຈັກແປພາສາອັດຕະໂນມັດຂັ້ນສູງ ກ່ອນທີ່ຈະສ້າງເອກະສານຄືນໃໝ່ຢ່າງລະອຽດໃນພາສາເປົ້າໝາຍ, ສົ່ງມອບໄຟລ໌ທີ່ພ້ອມສໍາລັບການນໍາໃຊ້ທັນທີ.

ຟັງຊັນທີ່ມີປະສິດທິພາບນີ້ ຊ່ວຍໃຫ້ນັກພັດທະນາສາມາດເຊື່ອມໂຍງຄວາມສາມາດໃນການແປເອກະສານທີ່ມີຄຸນນະພາບສູງເຂົ້າໄປໃນແອັບພລິເຄຊັນຂອງຕົນເອງໂດຍກົງ, ແລະ ທ່ານສາມາດ ຄົ້ນຫາແພລດຟອມຂອງພວກເຮົາ ເພື່ອເບິ່ງວ່າ Doctranslate ປັບປຸງຂະບວນການແປເອກະສານໃຫ້ງ່າຍຂຶ້ນທັນທີໄດ້ແນວໃດ.
ຂະບວນການທັງໝົດແມ່ນ asynchronous, ເຮັດໃຫ້ມັນສາມາດປັບຂະໜາດໄດ້ສູງ ແລະ ເໝາະສົມສໍາລັບການຈັດການໄຟລ໌ຂະໜາດໃຫຍ່ ຫຼື ຄໍາຮ້ອງຂໍທີ່ມີປະລິມານສູງ ໂດຍບໍ່ມີການບລັອກ main thread ຂອງແອັບພລິເຄຊັນຂອງທ່ານ.
ນັກພັດທະນາພຽງແຕ່ສົ່ງ job ແລະ ສາມາດກວດສອບສະຖານະຂອງມັນໄດ້, ໂດຍໄດ້ຮັບເອກະສານທີ່ສໍາເລັດເມື່ອການແປສໍາເລັດແລ້ວ.

ຄູ່ມືຂັ້ນຕອນຕໍ່ຂັ້ນຕອນໃນການເຊື່ອມໂຍງ Doctranslate API

ການເຊື່ອມໂຍງ API ຂອງພວກເຮົາ ເພື່ອແປເອກະສານ ພາສາອັງກິດ ເປັນ ພາສາຈີນ ແມ່ນຂະບວນການທີ່ລຽບງ່າຍ.
ຄູ່ມືນີ້ຈະນໍາພາທ່ານຜ່ານຂັ້ນຕອນທີ່ສໍາຄັນ, ຕັ້ງແຕ່ການກວດສອບຄໍາຮ້ອງຂໍຂອງທ່ານໄປຈົນເຖິງການດຶງເອົາໄຟລ໌ທີ່ຖືກແປສຸດທ້າຍ.
ພວກເຮົາຈະໃຊ້ Python ສໍາລັບຕົວຢ່າງລະຫັດຂອງພວກເຮົາ ເພື່ອສະແດງໃຫ້ເຫັນການຈັດຕັ້ງປະຕິບັດຢ່າງຈະແຈ້ງ ແລະ ຫຍໍ້.

ຂໍ້ກໍານົດເບື້ອງຕົ້ນ: ເອົາລະຫັດ API ຂອງທ່ານ

ກ່ອນທີ່ທ່ານຈະສາມາດໂທຫາ API ໃດໆກໍຕາມ, ທ່ານຕ້ອງການລະຫັດ API ເພື່ອກວດສອບຄໍາຮ້ອງຂໍຂອງທ່ານ.
ທ່ານສາມາດເອົາລະຫັດຂອງທ່ານໄດ້ໂດຍການລົງທະບຽນຢູ່ໃນພອດທໍນັກພັດທະນາ Doctranslate.
ລະຫັດນີ້ຕ້ອງຖືກລວມຢູ່ໃນ `Authorization` header ຂອງທຸກໆຄໍາຮ້ອງຂໍທີ່ທ່ານສົ່ງໄປຫາ API, ຮັບປະກັນວ່າການເຂົ້າເຖິງຂອງທ່ານມີຄວາມປອດໄພ ແລະ ຖືກກໍານົດຢ່າງຖືກຕ້ອງ.

ຂັ້ນຕອນທີ 1: ສົ່ງເອກະສານເພື່ອແປ

ຂັ້ນຕອນທໍາອິດໃນຂະບວນການເຮັດວຽກແມ່ນການສົ່ງ translation job ໂດຍໃຊ້ `POST` request ໄປຫາ endpoint `/v3/jobs`.
ຄໍາຮ້ອງຂໍນີ້ຮຽກຮ້ອງໃຫ້ທ່ານລະບຸພາສາຕົ້ນສະບັບ ແລະ ພາສາເປົ້າໝາຍ ແລະ ໃຫ້ເນື້ອໃນເອກະສານທີ່ຖືກເຂົ້າລະຫັດໃນ Base64.
Base64 encoding ຮັບປະກັນວ່າ binary data ຂອງໄຟລ໌ຂອງທ່ານຖືກສົ່ງຢ່າງປອດໄພພາຍໃນ JSON payload ໂດຍບໍ່ມີການເສຍຫາຍ.

JSON payload ຂອງທ່ານຄວນປະກອບມີ `source_language` (ເຊັ່ນ: ‘en’ ສໍາລັບ ພາສາອັງກິດ) ແລະ `target_language` (ເຊັ່ນ: ‘zh-CN’ ສໍາລັບ ພາສາຈີນແບບງ່າຍ).
ຊ່ອງຂໍ້ມູນ `documents` ແມ່ນ array, ຊ່ວຍໃຫ້ທ່ານສາມາດສົ່ງຫຼາຍໄຟລ໌ໃນ job ດຽວໄດ້ຖ້າຈໍາເປັນ.
ແຕ່ລະ document object ໃນ array ຕ້ອງປະກອບດ້ວຍ `content` ຂອງມັນ (Base64 string) ແລະ `name` ສໍາລັບການລະບຸຕົວຕົນ.

import requests
import base64
import json
import time

# Your API key from the Doctranslate developer portal
API_KEY = "YOUR_API_KEY"

# Path to your source document
file_path = "path/to/your/document.docx"

# 1. Read the file and encode it to Base64
with open(file_path, "rb") as f:
    encoded_string = base64.b64encode(f.read()).decode('utf-8')

# 2. Prepare the API request payload
url = "https://api.doctranslate.io/v3/jobs"
headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}
payload = {
    "source_language": "en",
    "target_language": "zh-CN", # Use zh-TW for Traditional Chinese
    "documents": [
        {
            "content": encoded_string,
            "name": "my-english-document.docx"
        }
    ]
}

# 3. Submit the translation job
response = requests.post(url, headers=headers, data=json.dumps(payload))

if response.status_code == 201:
    job_data = response.json()
    job_id = job_data.get("id")
    print(f"Successfully created job with ID: {job_id}")
else:
    print(f"Error creating job: {response.status_code} {response.text}")


ຂັ້ນຕອນທີ 2: ກວດສອບສະຖານະ Job
ເນື່ອງຈາກການແປແມ່ນ asynchronous process, ທ່ານຈໍາເປັນຕ້ອງກວດສອບສະຖານະຂອງ job ຂອງທ່ານເປັນໄລຍະ.
 ທ່ານສາມາດເຮັດໄດ້ໂດຍການສົ່ງ `GET` request ໄປຫາ endpoint `/v3/jobs/{job_id}`, ບ່ອນທີ່ `{job_id}` ແມ່ນ ID ທີ່ທ່ານໄດ້ຮັບໃນຄໍາຕອບຈາກຂັ້ນຕອນກ່ອນໜ້ານີ້.
 ນີ້ອະນຸຍາດໃຫ້ແອັບພລິເຄຊັນຂອງທ່ານລໍຖ້າໃຫ້ job ສໍາເລັດໂດຍບໍ່ມີການຖືກບລັອກ.
API ຈະສົ່ງຄືນ status field ໃນ JSON response ຂອງມັນ, ເຊິ່ງສາມາດເປັນ `pending`, `running`, `completed`, ຫຼື `failed`.
 ທ່ານຄວນຈັດຕັ້ງປະຕິບັດ polling mechanism, ສົ່ງຄໍາຮ້ອງຂໍໃນທຸກໆສອງສາມວິນາທີ, ຈົນກ່ວາສະຖານະປ່ຽນເປັນ `completed` ຫຼື `failed`.
 ນີ້ຮັບປະກັນວ່າທ່ານພຽງແຕ່ພະຍາຍາມດຶງເອົາເອກະສານເມື່ອມັນພ້ອມແລ້ວ, ເຊິ່ງເປັນ best practice ສໍາລັບການຈັດການ asynchronous workflows ຢ່າງມີປະສິດທິພາບ.
ຂັ້ນຕອນທີ 3: ດຶງເອົາເອກະສານທີ່ຖືກແປ
ເມື່ອ job status ເປັນ `completed`, JSON response ຈາກ endpoint `GET /v3/jobs/{job_id}` ຈະປະກອບດ້ວຍລາຍລະອຽດຂອງເອກະສານທີ່ຖືກແປ.
 ເນື້ອໃນທີ່ຖືກແປຈະຢູ່ໃນ `result` field ສໍາລັບແຕ່ລະເອກະສານ, ເຊິ່ງຖືກເຂົ້າລະຫັດໃນ Base64 ເຊັ່ນກັນ.
 ຂັ້ນຕອນສຸດທ້າຍຂອງທ່ານແມ່ນການຖອດລະຫັດ Base64 string ນີ້ກັບຄືນສູ່ binary format ເດີມຂອງມັນ ແລະ ບັນທຶກມັນເປັນໄຟລ໌ໃໝ່.
Python code snippet ຕໍ່ໄປນີ້ ສະແດງໃຫ້ເຫັນວິທີການກວດສອບສໍາລັບ job completion ແລະ ຫຼັງຈາກນັ້ນ ບັນທຶກໄຟລ໌ທີ່ໄດ້ຮັບ.
 ມັນປະກອບມີ simple loop ທີ່ກວດສອບສະຖານະ ແລະ, ເມື່ອສໍາເລັດ, ຖອດລະຫັດ ແລະ ຂຽນເອກະສານທີ່ຖືກແປໃສ່ disk.
 ນີ້ສໍາເລັດການເຊື່ອມໂຍງແບບ end-to-end, ຕັ້ງແຕ່ການສົ່ງໄຟລ໌ຕົ້ນສະບັບໄປຈົນເຖິງການໄດ້ຮັບສະບັບທີ່ຖືກແປຢ່າງສົມບູນ.

# This code follows the job creation snippet from Step 1

if 'job_id' in locals():
    status_url = f"https://api.doctranslate.io/v3/jobs/{job_id}"
    status_headers = {"Authorization": f"Bearer {API_KEY}"}
    
    # 4. Poll for job completion
    while True:
        status_response = requests.get(status_url, headers=status_headers)
        status_data = status_response.json()
        job_status = status_data.get("status")
        
        print(f"Current job status: {job_status}")
        
        if job_status == "completed":
            # 5. Retrieve and decode the translated document
            translated_doc = status_data['documents'][0]['result']
            decoded_content = base64.b64decode(translated_doc)
            
            # 6. Save the translated file
            output_file_path = "path/to/your/translated-document-zh.docx"
            with open(output_file_path, "wb") as f:
                f.write(decoded_content)
            print(f"Translated document saved to: {output_file_path}")
            break
        elif job_status == "failed":
            print("Job failed.")
            print(status_data.get("error"))
            break
        
        # Wait for 5 seconds before checking again
        time.sleep(5)


ຂໍ້ພິຈາລະນາສຳຄັນສຳລັບການແປ ພາສາອັງກິດ ເປັນ ພາສາຈີນ
ເມື່ອທ່ານໃຊ້ API ເພື່ອແປເອກະສານ ພາສາອັງກິດ ເປັນ ພາສາຈີນ, ມີປັດໃຈສະເພາະພາສາຫຼາຍຢ່າງທີ່ຕ້ອງພິຈາລະນາເພື່ອໃຫ້ໄດ້ຜົນທີ່ດີທີ່ສຸດ.
 ຂໍ້ພິຈາລະນາເຫຼົ່ານີ້ ເກີນກວ່າການເຊື່ອມໂຍງດ້ານເຕັກນິກ ແລະ ກ່ຽວຂ້ອງກັບຄວາມແຕກຕ່າງດ້ານພາສາ ແລະ ວັດທະນະທໍາ.
 ການແກ້ໄຂບັນຫາເຫຼົ່ານີ້ຢ່າງຖືກຕ້ອງຮັບປະກັນວ່າເອກະສານສຸດທ້າຍຂອງທ່ານບໍ່ພຽງແຕ່ຖືກຕ້ອງຕາມດ້ານເຕັກນິກເທົ່ານັ້ນ ແຕ່ຍັງເໝາະສົມທາງດ້ານວັດທະນະທໍາ ແລະ ນໍາສະເໜີຢ່າງເປັນມືອາຊີບ.
ການເລືອກລະຫວ່າງ ພາສາຈີນແບບງ່າຍ ແລະ ພາສາຈີນແບບດັ້ງເດີມ
ໜຶ່ງໃນການຕັດສິນໃຈທີ່ສໍາຄັນທີ່ສຸດແມ່ນການເລືອກຕົວປ່ຽນພາສາຈີນທີ່ຖືກຕ້ອງສໍາລັບກຸ່ມເປົ້າໝາຍຂອງທ່ານ.
 ພາສາຈີນແບບງ່າຍ (`zh-CN`) ຖືກໃຊ້ໃນ ຈີນແຜ່ນດິນໃຫຍ່, ສິງກະໂປ, ແລະ ມາເລເຊຍ, ໃນຂະນະທີ່ ພາສາຈີນແບບດັ້ງເດີມ (`zh-TW`) ຖືກໃຊ້ໃນ ໄຕ້ຫວັນ, ຮົງກົງ, ແລະ ມາເກົາ.
 ການໃຊ້ສະຄຣິບທີ່ຜິດສາມາດເຮັດໃຫ້ກຸ່ມເປົ້າໝາຍຂອງທ່ານຮູ້ສຶກຫ່າງເຫີນ, ດັ່ງນັ້ນມັນຈໍາເປັນຕ້ອງລະບຸລະຫັດພາສາເປົ້າໝາຍທີ່ຖືກຕ້ອງໃນຄໍາຮ້ອງຂໍ API ຂອງທ່ານ ເພື່ອຮັບປະກັນວ່າຜົນໄດ້ຮັບກົງກັບຄວາມຄາດຫວັງຂອງພາກພື້ນ.
ການຈັດການການເຂົ້າລະຫັດຕົວອັກສອນຢ່າງສະໝໍ່າສະເໝີ
ໃນຂະນະທີ່ Doctranslate API ຈັດການການເຂົ້າລະຫັດພາຍໃນ, ມັນເປັນສິ່ງສໍາຄັນສໍາລັບແອັບພລິເຄຊັນຂອງທ່ານທີ່ຈະຈັດການຂໍ້ມູນຂໍ້ຄວາມຢ່າງຖືກຕ້ອງ, ໂດຍສະເພາະຖ້າທ່ານຈັດການ metadata ໃດໆກໍຕາມ.
 ຄວນໃຊ້ UTF-8 ເປັນ standard encoding ຂອງທ່ານສະເໝີ ຕະຫຼອດ workflow ທັງໝົດຂອງທ່ານ, ຕັ້ງແຕ່ການອ່ານໄຟລ໌ໄປຈົນເຖິງການສົ່ງຄໍາຮ້ອງຂໍ API ແລະ ການປະມວນຜົນຄໍາຕອບ.
 ການປະຕິບັດນີ້ປ້ອງກັນການເສຍຫາຍຂອງຕົວອັກສອນ ແລະ ຮັບປະກັນວ່າຕົວອັກສອນພາສາຈີນທັງໝົດຖືກສະແດງຢ່າງຖືກຕ້ອງໃນທົ່ວລະບົບ ແລະ ແພລດຟອມຕ່າງໆ, ຮັກສາຄວາມສົມບູນຂອງເນື້ອໃນຂອງທ່ານ.
ຄວາມສຳຄັນຂອງຮູບແບບໃນການພິມຂອງ ພາສາຈີນ
Typography ແລະ layout conventions ສາມາດແຕກຕ່າງກັນຢ່າງຫຼວງຫຼາຍລະຫວ່າງ ພາສາອັງກິດ ແລະ ພາສາຈີນ.
 ຂໍ້ຄວາມ ພາສາຈີນ ມັກຈະຕ້ອງການ line spacing ແລະ character spacing ທີ່ແຕກຕ່າງກັນ ເພື່ອຮັກສາຄວາມສາມາດໃນການອ່ານ, ແລະ line breaks ສາມາດມີ semantic weight ຫຼາຍກວ່າ.
 ໂຊກດີ, ການສຸມໃສ່ຂອງ Doctranslate API ຕໍ່ກັບ ການຮັກສາໂຄງສ້າງເອກະສານເດີມ ຫຼຸດຜ່ອນບັນຫາເຫຼົ່ານີ້ໄດ້ຫຼາຍທີ່ສຸດ, ເນື່ອງຈາກວ່າມັນປັບຂໍ້ຄວາມທີ່ຖືກແປພາຍໃນຮູບແບບທີ່ມີຢູ່ແລ້ວ, ປ້ອງກັນບັນຫາການຈັດຮູບແບບທົ່ວໄປທີ່ເກີດຂຶ້ນຈາກ text expansion ຫຼື contraction.
ສະຫຼຸບ: ປັບປຸງຂະບວນການແປຂອງທ່ານໃຫ້ລຽບງ່າຍ
ການເຮັດໃຫ້ການແປເອກະສານຈາກ ພາສາອັງກິດ ເປັນ ພາສາຈີນ ເປັນແບບອັດຕະໂນມັດ ນໍາສະເໜີສິ່ງທ້າທາຍທີ່ເປັນເອກະລັກທີ່ກ່ຽວຂ້ອງກັບຮູບແບບໄຟລ໌, ການເຂົ້າລະຫັດຕົວອັກສອນ, ແລະ ການຮັກສາຮູບແບບ.
 Generic text translation API ບໍ່ພຽງພໍສໍາລັບໜ້າວຽກເຫຼົ່ານີ້, ເຊິ່ງມັກຈະນໍາໄປສູ່ໄຟລ໌ທີ່ເສຍຫາຍ ແລະ ປະສົບການຜູ້ໃຊ້ທີ່ບໍ່ດີ.
 Doctranslate API ສະໜອງວິທີແກ້ໄຂທີ່ຄົບຖ້ວນ ແລະ ເປັນມິດກັບນັກພັດທະນາ ເຊິ່ງຖືກອອກແບບສະເພາະສໍາລັບການແປເອກະສານທີ່ມີຄວາມຖືກຕ້ອງສູງ.
ໂດຍການປະຕິບັດຕາມຂັ້ນຕອນທີ່ໄດ້ລະບຸໄວ້ໃນຄູ່ມືນີ້, ທ່ານສາມາດເຊື່ອມໂຍງ translation engine ທີ່ມີປະສິດທິພາບເຂົ້າໄປໃນແອັບພລິເຄຊັນຂອງທ່ານໄດ້ຢ່າງລຽບງ່າຍ.
 ລັກສະນະ asynchronous ຂອງ API ແລະ ຄວາມສາມາດໃນການຈັດການໄຟລ໌ທີ່ແຂງແຮງ ເຮັດໃຫ້ທ່ານສາມາດສ້າງຄຸນສົມບັດ internationalization ທີ່ສາມາດປັບຂະໜາດໄດ້, ມີປະສິດທິພາບ, ແລະ ເຊື່ອຖືໄດ້.
 ເພື່ອຮຽນຮູ້ເພີ່ມເຕີມກ່ຽວກັບ advanced features ແລະ ພາສາທີ່ຮອງຮັບອື່ນໆ, ພວກເຮົາຂໍແນະນໍາໃຫ້ທ່ານຄົ້ນຫາເອກະສານຂອງນັກພັດທະນາ Doctranslate ຢ່າງເປັນທາງການ ສໍາລັບລາຍລະອຽດທີ່ຄົບຖ້ວນ ແລະ ຄໍາແນະນໍາເພີ່ມເຕີມ.