หน้าแรก>การเขียนโปรแกรมที่เกี่ยวข้อง>ซอร์สโค้ดอื่น ๆ
ดาวน์โหลด

deepl-โหนด

ไลบรารีไคลเอ็นต์ Node.js อย่างเป็นทางการสำหรับ DeepL API

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

ไลบรารี DeepL Node.js นำเสนอวิธีที่สะดวกสำหรับแอปพลิเคชันที่เขียนสำหรับ Node.js เพื่อโต้ตอบกับ DeepL API เราตั้งใจที่จะสนับสนุนฟังก์ชัน API ทั้งหมดด้วยไลบรารี แม้ว่าการรองรับคุณสมบัติใหม่ ๆ อาจถูกเพิ่มลงในไลบรารีหลังจากที่เพิ่มลงใน API แล้ว

กำลังรับคีย์การรับรองความถูกต้อง

หากต้องการใช้แพ็คเกจ คุณจะต้องมีคีย์การตรวจสอบสิทธิ์ API หากต้องการรับรหัส โปรดสร้างบัญชีที่นี่ ด้วยบัญชี DeepL API Free คุณสามารถแปลได้ถึง 500,000 ตัวอักษร/เดือนฟรี

การติดตั้ง

npm install deepl-node

ความต้องการ

แพ็คเกจรองรับ Node.js เวอร์ชัน 12, 14, 16, 17 และ 18 อย่างเป็นทางการ

ตั้งแต่ปี 2024 เป็นต้นไป เราจะยกเลิกการรองรับโหนดเวอร์ชันเก่าที่หมดอายุการใช้งานอย่างเป็นทางการแล้ว คุณสามารถดูเวอร์ชันของโหนดและไทม์ไลน์การสนับสนุนได้ที่นี่ หากต้องการใช้ไลบรารีนี้ต่อไป คุณควรอัปเดตเป็น Node 18+

การใช้งาน

นำเข้าแพ็คเกจและสร้าง Translator อาร์กิวเมนต์แรกคือสตริงที่มีคีย์การตรวจสอบสิทธิ์ API ของคุณตามที่พบในบัญชี DeepL Pro ของคุณ

ระวังอย่าเปิดเผยคีย์ของคุณ เช่น เมื่อแชร์ซอร์สโค้ด

ตัวอย่างการใช้ async / await และ ES Modules: 

 import * as deepl from 'deepl-node' ;

const authKey = "f63c02c5-f056-..." ; // Replace with your key
const translator = new deepl . Translator ( authKey ) ;

( async ( ) => {
    const result = await translator . translateText ( 'Hello, world!' , null , 'fr' ) ;
    console . log ( result . text ) ; // Bonjour, le monde !
} ) ( ) ;

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

หากคุณใช้ CommonJS คุณควรต้องการแพ็คเกจแทน: 

 const deepl = require ( 'deepl-node' ) ;
const translator = new deepl . Translator ( authKey ) ;

Translator ยอมรับตัวเลือกเป็นอาร์กิวเมนต์ที่สอง ดูการกำหนดค่าสำหรับข้อมูลเพิ่มเติม

ฟังก์ชัน Translator ทั้งหมดส่งคืนสัญญา และเพื่อความกระชับ ตัวอย่างในไฟล์นี้ใช้ await และ try / catch บล็อก อย่างไรก็ตาม Promise-chaining ก็เป็นไปได้เช่นกัน: 

 translator
    . translateText ( 'Hello, world!' , null , 'fr' )
    . then ( ( result ) => {
        console . log ( result . text ) ; // Bonjour, le monde !
    } )
    . catch ( ( error ) => {
        console . error ( error ) ;
    } ) ;

แพ็คเกจนี้ยังรองรับ TypeScript: 

 import * as deepl from 'deepl-node' ;

( async ( ) => {
    const targetLang : deepl . TargetLanguageCode = 'fr' ;
    const results = await translator . translateText (
        [ 'Hello, world!' , 'How are you?' ] ,
        null ,
        targetLang ,
    ) ;
    results . map ( ( result : deepl . TextResult ) => {
        console . log ( result . text ) ; // Bonjour, le monde !
    } ) ;
} ) ( ) ;

การแปลข้อความ

หากต้องการแปลข้อความ ให้เรียก translateText() อาร์กิวเมนต์แรกคือสตริงที่มีข้อความที่คุณต้องการแปล หรืออาร์เรย์ของสตริงหากคุณต้องการแปลหลายข้อความ

อาร์กิวเมนต์ที่สองและสามคือรหัสภาษาต้นทางและเป้าหมาย รหัสภาษาเป็นสตริง ที่ไม่คำนึงถึงขนาดตัวพิมพ์ ตามมาตรฐาน ISO 639-1 เช่น 'de' , 'fr' , 'ja'' ภาษาเป้าหมายบางภาษายังรวมถึงรูปแบบภูมิภาคตามมาตรฐาน ISO 3166-1 เช่น 'en-US' หรือ 'pt-BR' ภาษาต้นฉบับยังยอมรับ null เพื่อเปิดใช้งานการตรวจจับภาษาต้นฉบับโดยอัตโนมัติ

อาร์กิวเมนต์สุดท้ายของ translateText() เป็นทางเลือก และระบุตัวเลือกการแปลเพิ่มเติม โปรดดูตัวเลือกการแปลข้อความด้านล่าง

translateText() ส่งคืน Promise ที่สอดคล้องกับ TextResult หรืออาร์เรย์ของ TextResult ที่สอดคล้องกับข้อความที่คุณป้อน TextResult มีคุณสมบัติดังต่อไปนี้:

  • text คือข้อความที่แปล
  • detectedSourceLang เป็นรหัสภาษาต้นฉบับที่ตรวจพบ
  • billedCharacters คือจำนวนอักขระที่เรียกเก็บเงินสำหรับข้อความ
  • modelTypeUsed ระบุถึงโมเดลการแปลที่ใช้ แต่ undefined เว้นแต่จะระบุตัวเลือก modelType 
 // Translate text into a target language, in this case, French:
const translationResult = await translator . translateText ( 'Hello, world!' , 'en' , 'fr' ) ;
console . log ( translationResult . text ) ; // 'Bonjour, le monde !'

// Translate multiple texts into British English:
const translations = await translator . translateText (
    [ 'お元気ですか？' , '¿Cómo estás?' ] ,
    null ,
    'en-GB' ,
) ;
console . log ( translations [ 0 ] . text ) ; // 'How are you?'
console . log ( translations [ 0 ] . detectedSourceLang ) ; // 'ja'
console . log ( translations [ 0 ] . billedCharacters ) ; // 7 - the number of characters in the source text "お元気ですか？"
console . log ( translations [ 1 ] . text ) ; // 'How are you?'
console . log ( translations [ 1 ] . detectedSourceLang ) ; // 'es'
console . log ( translations [ 1 ] . billedCharacters ) ; // 12 - the number of characters in the source text "¿Cómo estás?"

// Translate into German with less and more Formality:
console . log ( await translator . translateText ( 'How are you?' , null , 'de' , { formality : 'less' } ) ) ; // 'Wie geht es dir?'
console . log ( await translator . translateText ( 'How are you?' , null , 'de' , { formality : 'more' } ) ) ; // 'Wie geht es Ihnen?'

ตัวเลือกการแปลข้อความ

  • splitSentences : ระบุวิธีการแยกข้อความที่ป้อนเป็นประโยค ค่าเริ่มต้น: 'on'
    • 'on' : ข้อความที่ป้อนจะถูกแบ่งออกเป็นประโยคโดยใช้ทั้งบรรทัดใหม่และเครื่องหมายวรรคตอน
    • 'off' : ข้อความที่ป้อนจะไม่ถูกแบ่งออกเป็นประโยค ใช้สิ่งนี้สำหรับแอปพลิเคชันที่แต่ละข้อความอินพุตมีเพียงประโยคเดียว
    • 'nonewlines' : ข้อความที่ป้อนจะถูกแบ่งออกเป็นประโยคโดยใช้เครื่องหมายวรรคตอน แต่จะไม่มีการขึ้นบรรทัดใหม่
  • preserveFormatting : ควบคุมการแก้ไขการจัดรูปแบบอัตโนมัติ ตั้งค่าเป็น true เพื่อป้องกันการแก้ไขการจัดรูปแบบโดยอัตโนมัติ ค่าเริ่มต้น: false
  • formality : ควบคุมว่าการแปลควรเน้นไปที่ภาษาที่ไม่เป็นทางการหรือเป็นทางการ ตัวเลือกนี้ใช้ได้เฉพาะกับภาษาเป้าหมายบางภาษาเท่านั้น โปรดดูรายการภาษาที่ใช้ได้ ใช้ตัวเลือก prefer_* เพื่อใช้พิธีการหากพร้อมใช้งานสำหรับเป้าหมาย
    ภาษาหรือทางเลือกอื่นเป็นค่าเริ่มต้น
    • 'less' : ใช้ภาษาที่ไม่เป็นทางการ
    • 'more' : ใช้ภาษาที่เป็นทางการและสุภาพมากขึ้น
    • 'default' : ใช้รูปแบบเริ่มต้น
    • 'prefer_less' : ใช้ภาษาที่ไม่เป็นทางการ หากมี มิฉะนั้นจะเป็นค่าเริ่มต้น
    • 'prefer_more' : ใช้ภาษาที่เป็นทางการและสุภาพมากขึ้น หากมี ไม่เช่นนั้นจะเป็นค่าเริ่มต้น
  • glossary : ระบุอภิธานศัพท์ที่จะใช้กับการแปล ไม่ว่าจะเป็นสตริงที่มี ID อภิธานศัพท์ หรือ GlossaryInfo ที่ส่งคืนโดย getGlossary()
  • context : ระบุบริบทเพิ่มเติมที่จะมีอิทธิพลต่อการแปลซึ่งไม่ได้แปลเอง อักขระในพารามิเตอร์ context จะไม่นับรวมในการเรียกเก็บเงิน ดูเอกสารประกอบ API สำหรับข้อมูลเพิ่มเติมและตัวอย่างการใช้งาน
  • modelType : ระบุประเภทของโมเดลการแปลที่จะใช้ ตัวเลือกคือ:
    • 'quality_optimized' : ใช้โมเดลการแปลที่เพิ่มคุณภาพการแปลสูงสุด โดยแลกกับเวลาตอบสนอง ตัวเลือกนี้อาจใช้ไม่ได้กับบางคู่ภาษา
    • 'prefer_quality_optimized' : ใช้โมเดลการแปลคุณภาพสูงสุดสำหรับคู่ภาษาที่กำหนด
    • 'latency_optimized' : ใช้โมเดลการแปลที่ลดเวลาตอบสนองให้เหลือน้อยที่สุด โดยแลกกับคุณภาพการแปล
  • tagHandling : ประเภทของแท็กที่จะแยกวิเคราะห์ก่อนการแปล ตัวเลือกคือ 'html' และ 'xml'

ตัวเลือกต่อไปนี้จะใช้เฉพาะในกรณีที่ tagHandling เป็น 'xml' :

  • outlineDetection : ระบุ false เพื่อปิดใช้งานการตรวจจับแท็กอัตโนมัติ ค่าเริ่มต้นคือ true
  • splittingTags : รายการแท็ก XML ที่ควรใช้เพื่อแยกข้อความออกเป็นประโยค แท็กอาจระบุเป็นอาร์เรย์ของสตริง ( ['tag1', 'tag2'] ) หรือรายการสตริงที่คั่นด้วยเครื่องหมายจุลภาค ( 'tag1,tag2' ) ค่าเริ่มต้นคือรายการว่าง
  • nonSplittingTags : รายการแท็ก XML ที่ไม่ควรใช้แบ่งข้อความออกเป็นประโยค รูปแบบและค่าเริ่มต้นเหมือนกับ splittingTags
  • ignoreTags : รายการแท็ก XML ที่มีเนื้อหาที่ไม่ควรแปล รูปแบบและค่าเริ่มต้นเหมือนกับ splittingTags
  • extraRequestParameters : พารามิเตอร์เนื้อหาเพิ่มเติมที่จะส่งไปพร้อมกับคำขอ HTTP อนุญาตเฉพาะค่าสตริงเท่านั้น ตัวอย่างเช่น: {'param': 'value', 'param2': 'value2'}

แปลเอกสาร

หากต้องการแปลเอกสาร ให้เรียก translateDocument() อาร์กิวเมนต์ที่หนึ่งและที่สองคือไฟล์อินพุตและเอาต์พุต อาร์กิวเมนต์เหล่านี้ยอมรับสตริงที่มีเส้นทางของไฟล์ หรือสตรีมหรือ FileHandles ที่เปิดสำหรับการอ่าน/การเขียน ไฟล์อินพุตอาจได้รับเป็นบัฟเฟอร์ที่มีข้อมูลไฟล์ โปรดทราบว่าหากไฟล์อินพุตไม่ได้รับการกำหนดเป็นพาธของไฟล์ ก็จำเป็นต้องมีตัวเลือก filename

อาร์กิวเมนต์ที่สามและสี่คือรหัสภาษาต้นฉบับและเป้าหมาย และทำงานเหมือนกับเมื่อแปลข้อความด้วย translateText() ทุกประการ

อาร์กิวเมนต์สุดท้ายของ translateDocument() เป็นทางเลือก และระบุตัวเลือกการแปลเพิ่มเติม โปรดดูตัวเลือกการแปลเอกสารด้านล่าง 

 // Translate a formal document from English to German:
try {
    await translator . translateDocument (
        'Instruction Manual.docx' ,
        'Bedienungsanleitung.docx' ,
        'en' ,
        'de' ,
        { formality : 'more' } ,
    ) ;
} catch ( error ) {
    // If the error occurs after the document was already uploaded,
    // documentHandle will contain the document ID and key
    if ( error . documentHandle ) {
        const handle = error . documentHandle ;
        console . log ( `Document ID: ${ handle . documentId } , ` + `Document key: ${ handle . documentKey } ` ) ;
    } else {
        console . log ( `Error occurred during document upload: ${ error } ` ) ;
    }
}

translateDocument() ล้อมการเรียก API หลายรายการ: การอัปโหลด สถานะการโพลจนกว่าการแปลจะเสร็จสิ้น และการดาวน์โหลด หากแอปพลิเคชันของคุณจำเป็นต้องดำเนินการขั้นตอนเหล่านี้แยกกัน คุณสามารถใช้ฟังก์ชันต่อไปนี้ได้โดยตรงแทน:

  • uploadDocument() ,
  • getDocumentStatus() (หรือ isDocumentTranslationComplete() ) และ
  • downloadDocument()

ตัวเลือกการแปลเอกสาร

  • formality : เช่นเดียวกับในตัวเลือกการแปลข้อความ
  • glossary : เช่นเดียวกับในตัวเลือกการแปลข้อความ
  • filename : หากไฟล์อินพุตไม่ได้ระบุเป็นพาธของไฟล์ จำเป็นต้องใช้ตัวเลือกนี้เพื่อระบุนามสกุลไฟล์
  • extraRequestParameters : เช่นเดียวกับในตัวเลือกการแปลข้อความ

อภิธานศัพท์

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

คุณสามารถสร้างอภิธานศัพท์ด้วยคำศัพท์และชื่อที่คุณต้องการได้โดยใช้ createGlossary() อภิธานศัพท์แต่ละรายการใช้กับคู่ภาษาเป้าหมายต้นทางคู่เดียว หมายเหตุ: รองรับอภิธานศัพท์สำหรับบางคู่ภาษาเท่านั้น โปรดดูข้อมูลเพิ่มเติมในเอกสารประกอบ DeepL API 

 // Create an English to German glossary with two terms:
const entries = new deepl . GlossaryEntries ( { entries : { artist : 'Maler' , prize : 'Gewinn' } } ) ;
const glossaryEnToDe = await translator . createGlossary ( 'My glossary' , 'en' , 'de' , entries ) ;

คุณยังสามารถอัปโหลดอภิธานศัพท์ที่ดาวน์โหลดจากเว็บไซต์ DeepL โดยใช้ createGlossaryWithCsv() แทนที่จะระบุรายการเป็นพจนานุกรม ให้ระบุไฟล์ CSV เป็นสตริงที่มีเส้นทางของไฟล์ หรือ Stream, Buffer หรือ FileHandle ที่มีเนื้อหาไฟล์ CSV: 

 const csvFilePath = '/path/to/glossary_file.csv' ;
const glossaryEnToDe = await translator . createGlossaryWithCsv (
    'My glossary' ,
    'en' ,
    'de' ,
    csvFilePath ) ;

เอกสารประกอบ API จะอธิบายรูปแบบ CSV ที่คาดหวังโดยละเอียด

นอกจากนี้ยังมีฟังก์ชันในการรับ แสดงรายการ และลบอภิธานศัพท์ที่จัดเก็บไว้อีกด้วย 

 // Find details about the glossary named 'My glossary'
const glossaries = await translator . listGlossaries ( ) ;
const glossary = glossaries . find ( ( glossary ) => glossary . name == 'My glossary' ) ;
console . log (
    `Glossary ID: ${ glossary . glossaryId } , source: ${ glossary . sourceLang } , ` +
        `target: ${ glossary . targetLang } , contains ${ glossary . entryCount } entries.` ,
) ;

หากต้องการใช้อภิธานศัพท์เมื่อแปลข้อความและเอกสาร ให้รวม ID (หรือวัตถุ Glossary ที่ส่งคืนโดย listGlossaries() หรือ createGlossary() ) ในการเรียกใช้ฟังก์ชัน ภาษาต้นทางและภาษาเป้าหมายต้องตรงกับอภิธานศัพท์ 

 const resultWithGlossary = await translator . translateText (
    'The artist was awarded a prize.' ,
    'en' ,
    'de' ,
    { glossary } ,
) ;
console . log ( resultWithGlossary . text ) ; // 'Der Maler wurde mit einem Gewinn ausgezeichnet.'
// Without using a glossary would give:  'Der Künstler wurde mit einem Preis ausgezeichnet.'

การตรวจสอบการใช้งานบัญชี

หากต้องการตรวจสอบการใช้งานบัญชี ให้ใช้ฟังก์ชัน getUsage()

ออบเจ็กต์ Usage ที่ส่งคืนมีประเภทย่อยการใช้งานสูงสุดสามประเภท ขึ้นอยู่กับประเภทบัญชีของคุณ: character document และ teamDocument สำหรับ character บัญชี API จะถูกกำหนด ส่วนตัวอื่น ๆ undefined

ประเภทย่อยการใช้งานแต่ละประเภท (หากกำหนด) มีคุณสมบัติ count และ limit โดยให้จำนวนที่ใช้และจำนวนสูงสุดตามลำดับ และฟังก์ชัน limitReached() ที่ตรวจสอบว่าการใช้งานถึงขีดจำกัดหรือไม่ ออบเจ็กต์ Usage ระดับบนสุดมีฟังก์ชัน anyLimitReached() เพื่อตรวจสอบประเภทย่อยการใช้งานทั้งหมด 

 const usage = await translator . getUsage ( ) ;
if ( usage . anyLimitReached ( ) ) {
    console . log ( 'Translation limit exceeded.' ) ;
}
if ( usage . character ) {
    console . log ( `Characters: ${ usage . character . count } of ${ usage . character . limit } ` ) ;
}
if ( usage . document ) {
    console . log ( `Documents: ${ usage . document . count } of ${ usage . document . limit } ` ) ;
}

รายชื่อภาษาที่ใช้ได้

คุณสามารถขอรายการภาษาที่ DeepL Translator รองรับสำหรับข้อความและเอกสารได้โดยใช้ฟังก์ชัน getSourceLanguages() และ getTargetLanguages() ทั้งสองส่งคืนอาร์เรย์ของอ็อบเจ็กต์ Language

คุณสมบัติ name จะให้ชื่อของภาษาเป็นภาษาอังกฤษ และคุณสมบัติ code จะให้รหัสภาษา คุณสมบัติ supportsFormality จะปรากฏสำหรับภาษาเป้าหมายเท่านั้น และเป็น Boolean ที่ระบุว่าภาษาเป้าหมายรองรับพารามิเตอร์ formality ทางเลือกหรือไม่ 

 const sourceLanguages = await translator . getSourceLanguages ( ) ;
for ( let i = 0 ; i < sourceLanguages . length ; i ++ ) {
    const lang = sourceLanguages [ i ] ;
    console . log ( ` ${ lang . name } ( ${ lang . code } )` ) ; // Example: 'English (en)'
}

const targetLanguages = await translator . getTargetLanguages ( ) ;
for ( let i = 0 ; i < targetLanguages . length ; i ++ ) {
    const lang = targetLanguages [ i ] ;
    if ( lang . supportsFormality ) {
        console . log ( ` ${ lang . name } ( ${ lang . code } ) supports formality` ) ;
        // Example: 'German (DE) supports formality'
    }
}

อภิธานศัพท์ได้รับการสนับสนุนสำหรับชุดย่อยของคู่ภาษา หากต้องการดึงข้อมูลภาษาเหล่านั้น ให้ใช้ฟังก์ชัน getGlossaryLanguagePairs() ซึ่งจะส่งคืนอาร์เรย์ของอ็อบเจ็กต์ GlossaryLanguagePair แต่ละรายการมีคุณสมบัติ sourceLang และ targetLang ที่ระบุว่าคู่รหัสภาษานั้นรองรับอภิธานศัพท์ 

 const glossaryLanguages = await translator . getGlossaryLanguagePairs ( ) ;
for ( let i = 0 ; i < glossaryLanguages . length ; i ++ ) {
    const languagePair = glossaryLanguages [ i ] ;
    console . log ( ` ${ languagePair . sourceLang } to ${ languagePair . targetLang } ` ) ;
    // Example: 'en to de', 'de to en', etc.
}

การเขียนปลั๊กอิน

หากคุณใช้ไลบรารีนี้ในแอปพลิเคชัน โปรดระบุแอปพลิเคชันด้วยฟิลด์ appInfo ใน TranslatorOptions ซึ่งใช้ชื่อและเวอร์ชันของแอป: 

 const options = { appInfo : { appName : 'sampleNodeTranslationApp' , appVersion : '1.2.3' } , } ;
const deepl = new deepl . Translator ( 'YOUR_AUTH_KEY' , options ) ;

ข้อมูลนี้จะถูกส่งต่อเมื่อไลบรารีทำการเรียกไปยัง DeepL API ต้องระบุทั้งชื่อและเวอร์ชัน

การกำหนดค่า

ตัวสร้าง Translator ยอมรับตัวเลือกการกำหนดค่าเป็นอาร์กิวเมนต์ที่สอง ตัวอย่างเช่น: 

 const options = { maxRetries : 5 , minTimeout : 10000 } ;
const deepl = new deepl . Translator ( 'YOUR_AUTH_KEY' , options ) ;

ตัวเลือกที่ใช้ได้คือ:

  • maxRetries : Number สูงสุดของคำขอ HTTP ที่ล้มเหลวในการลองอีกครั้ง ต่อการเรียกใช้ฟังก์ชัน ตามค่าเริ่มต้น จะมีการลองใหม่ 5 ครั้ง ดูคำขอลองอีกครั้ง
  • minTimeout : Number มิลลิวินาทีที่ใช้เป็นการหมดเวลาการเชื่อมต่อสำหรับการลองคำขอ HTTP แต่ละครั้งอีกครั้ง ค่าเริ่มต้นคือ 10,000 (10 วินาที)
  • serverUrl : string ที่มี URL ของ DeepL API สามารถแทนที่ได้เพื่อการทดสอบ ตามค่าเริ่มต้น URL จะถูกเลือกตามประเภทบัญชีผู้ใช้ (ฟรีหรือจ่ายเงิน)
  • headers : ส่วนหัว HTTP เพิ่มเติมที่แนบมากับทุกคำขอ HTTP ตามค่าเริ่มต้น จะไม่มีการใช้ส่วนหัวเพิ่มเติม โปรดทราบว่าส่วนหัวการอนุญาตและ User-Agent จะถูกเพิ่มโดยอัตโนมัติ แต่ตัวเลือกนี้อาจถูกแทนที่
  • proxy : กำหนดชื่อโฮสต์ และพอร์ตของพร็อกซีเซิร์ฟเวอร์ และเป็นทางเลือกโปรโตคอล และการอนุญาต (เป็นวัตถุรับรองความถูกต้องที่มีฟิลด์ชื่อผู้ใช้และรหัสผ่าน)

การบันทึก

การดีบักบันทึก deepl-node และข้อความข้อมูลสำหรับทุกคำขอ HTTP และการตอบกลับโดยใช้โมดูล loglevel ไปยังตัวบันทึก 'deepl' คุณสามารถกำหนดค่าระดับบันทึกใหม่ได้ดังต่อไปนี้: 

 import log from 'loglevel' ;

log . getLogger ( 'deepl' ) . setLevel ( 'debug' ) ; // Or 'info'

แพ็คเกจ loglevel ยังรองรับปลั๊กอิน โปรดดูเอกสารประกอบ

การกำหนดค่าพร็อกซี

คุณสามารถกำหนดค่าพร็อกซีได้โดยระบุอาร์กิวเมนต์ proxy เมื่อสร้าง deepl.Translator : 

 const options = { proxy : { host : 'localhost' , port : 3000 } } ;
const deepl = new deepl . Translator ( 'YOUR_AUTH_KEY' , options ) ;

อาร์กิวเมนต์พร็อกซีถูกส่งผ่านไปยังคำขอ axios พื้นฐาน โปรดดูเอกสารประกอบสำหรับ axios

ข้อมูลแพลตฟอร์มที่ไม่ระบุชื่อ

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

 const options = { sendPlatformInfo : false } ;
const deepl = new deepl . Translator ( 'YOUR_AUTH_KEY' , options ) ;

ขอลองอีกครั้ง

คำขอไปยัง DeepL API ที่ล้มเหลวเนื่องจากสภาวะชั่วคราว (เช่น การหมดเวลาของเครือข่ายหรือการโหลดเซิร์ฟเวอร์สูง) จะถูกลองอีกครั้ง สามารถกำหนดค่าจำนวนการลองใหม่สูงสุดได้เมื่อสร้างวัตถุ Translator โดยใช้ตัวเลือก maxRetries การหมดเวลาสำหรับความพยายามร้องขอแต่ละครั้งอาจถูกควบคุมโดยใช้ตัวเลือก minTimeout มีการใช้กลยุทธ์ Exponential-Backoff ดังนั้นคำขอที่ล้มเหลวหลายครั้งจะเกิดความล่าช้า

ปัญหา

หากคุณประสบปัญหาในการใช้ห้องสมุดหรือต้องการขอคุณสมบัติใหม่ โปรดเปิดปัญหา

การพัฒนา

เรายินดีรับคำขอดึง โปรดอ่านหลักเกณฑ์การมีส่วนร่วม

การทดสอบ

ดำเนินการทดสอบโดยใช้ npm test การทดสอบสื่อสารกับ DeepL API โดยใช้คีย์การตรวจสอบสิทธิ์ที่กำหนดโดยตัวแปรสภาพแวดล้อม DEEPL_AUTH_KEY

โปรดทราบว่าการทดสอบจะสร้างคำขอ DeepL API ที่มีส่วนสนับสนุนการใช้งาน API ของคุณ

ชุดทดสอบอาจได้รับการกำหนดค่าให้สื่อสารกับเซิร์ฟเวอร์จำลองที่จัดทำโดย deepl-mock แทน แม้ว่ากรณีทดสอบส่วนใหญ่จะใช้ได้กับทั้งสองกรณี แต่กรณีทดสอบบางกรณีใช้งานได้กับ DeepL API หรือเซิร์ฟเวอร์จำลองเท่านั้น และจะถูกข้ามไป กรณีทดสอบที่จำเป็นต้องมีข้อผิดพลาดเซิร์ฟเวอร์ทริกเกอร์เซิร์ฟเวอร์จำลองและทดสอบการจัดการข้อผิดพลาดของไคลเอ็นต์ หากต้องการดำเนินการทดสอบโดยใช้ deepl-mock ให้รันในเทอร์มินัลอื่นขณะดำเนินการทดสอบ ดำเนินการทดสอบโดยใช้ npm test ด้วยตัวแปรสภาพแวดล้อม DEEPL_MOCK_SERVER_PORT และ DEEPL_SERVER_URL ที่กำหนดโดยอ้างอิงถึงเซิร์ฟเวอร์จำลอง

ขยาย
ข้อมูลเพิ่มเติม
แอปที่เกี่ยวข้อง
แนะนำสำหรับคุณ
ข้อมูลที่เกี่ยวข้อง ทั้งหมด