เครื่องแปลง JSON ที่รักษาโครงสร้าง | เครื่องมือแปลภาษาฟรี
เครื่องแปลภาษา JSON ฟรีที่คงโครงสร้างเดิมไว้ แปลไฟล์ i18n การตอบกลับ API และ JSON แบบซ้อนโดยคงคีย์ ประเภทข้อมูล และการจัดรูปแบบ เหมาะสำหรับแอปพลิเคชันหลายภาษา i18next
เครื่องมือแปลโครงสร้าง JSON
เครื่องมือนี้แปลเนื้อหาของออบเจ็กต์ JSON โดยคงโครงสร้างเดิมไว้ วางข้อมูล JSON ในแผงด้านซ้าย เลือกภาษาเป้าหมาย และดูผลลัพธ์การแปลในแผงด้านขวา
ผลลัพธ์การแปลจะปรากฏที่นี่...
วิธีใช้งาน
- วาง JSON ของคุณในช่อง JSON ต้นฉบับ
- เลือกภาษาเป้าหมายจากเมนูแบบดึงลง
- JSON ที่แปลแล้วจะปรากฏในแผงด้านขวาโดยอัตโนมัติ
- คลิกปุ่มคัดลอกเพื่อคัดลอก JSON ที่แปลแล้วไปยังคลิปบอร์ด
เอกสารประกอบการใช้งาน
JSON Structure-Preserving Translator คืออะไร?
เคยลองคัดลอก JSON ไปแปลด้วย Google Translate แล้วพบว่าคีย์เสีย วงเล็บหาย หรือไวยากรณ์เพี้ยนไหม? นี่คือปัญหาที่เครื่องมือนี้จะช่วยแก้ไข
JSON structure-preserving translator จะแปลเฉพาะ ค่าสตริง ภายใน JSON objects โดยคงโครงสร้างเดิมไว้ — คีย์ยังคงเดิม ตัวเลขยังคงเป็นตัวเลข ค่าบูลีนยังคงเป็นบูลีน และโครงสร้างซ้อนไม่ถูกทำลาย
นี่คือสิ่งที่แตกต่างจากเครื่องมือแปลทั่วไป: เมื่อคุณแปลไฟล์ i18n ที่มีคีย์ซ้อนกว่า 50 คีย์ คุณต้องการให้โครงสร้างคงเดิมเพื่อให้โค้ดของคุณยังสามารถอ้างอิง user.profile.displayName ในภาษาสเปน ฝรั่งเศส หรือญี่ปุ่นได้ หากโครงสร้างพัง คุณจะต้องดีบั๊กนานหลายชั่วโมง
เครื่องมือนี้จัดการการสแกนแบบเรียกซ้ำโดยอัตโนมัติ ระบุว่าสตริงใดต้องแปล และองค์ประกอบใดบ้าง (เช่น API keys, ค่าการกำหนดค่า หรือ numeric IDs) ที่ควรคงเดิมตามเดิม
วิธีการรักษาโครงสร้าง JSON
ทำไมการรักษาโครงสร้างจึงสำคัญ
เมื่อคุณกำลังทำงานกับการแปล JSON คุณมักจะเผชิญกับสถานการณ์เหล่านี้:
- ไฟล์ i18n ที่แอปพลิเคชันของคุณคาดหวัง
en.jsonและfr.jsonให้มีคีย์ที่เหมือนกัน - การตอบกลับ API ที่ต้องการโครงสร้างที่สอดคล้องกันในทุกภาษาสำหรับการประมวลผลของไคลเอนต์
- ไฟล์การกำหนดค่า ที่การเปลี่ยนชื่อคีย์จะทำให้แอปพลิเคชันของคุณทั้งหมดเสีย
- การส่งออกฐานข้อมูล ที่ความสัมพันธ์ขึ้นอยู่กับชื่อฟิลด์เฉพาะ
ความท้าทาย: JSON ไม่ใช่แค่ข้อความ แต่เป็นข้อมูลที่มีโครงสร้างซึ่งโค้ดของคุณอ้างอิง การเปลี่ยน "userName" เป็น "nombreUsuario" ระหว่างการแปล จะทำให้แอปพลิเคชันของคุณโยนข้อผิดพลาด undefined
วิธีการทำงานของกระบวนการแปล
นี่คือสิ่งที่เกิดขึ้นเบื้องหลังเมื่อคุณแปล JSON:
1. การตรวจสอบและตรวจผ่าน เครื่องมือจะตรวจสอบไวยากรณ์ JSON ของคุณก่อน หากคุณขาดเครื่องหมายจุลภาค หรือมีวงเล็บเกิน คุณจะได้รับข้อความแสดงข้อผิดพลาดที่ชัดเจนก่อนที่การแปลจะเริ่มขึ้น—ช่วยป้องกันผลลัพธ์ที่เสีย
2. การสำรวจแบบเรียกซ้ำ เริ่มจากรากราก อัลกอริทึมจะเดินผ่านทุกโหนดในต้นไม้ JSON สำหรับแต่ละองค์ประกอบ จะตรวจสอบประเภทข้อมูล:
- สตริง? ใส่คิวเพื่อแปล
- ตัวเลข, บูลีน, ค่าว่าง? ข้ามไปเลย
- ออบเจ็กต์หรืออาร์เรย์? เรียกซ้ำเข้าไป
3. การแปลที่ปลอดภัยตามประเภท
เฉพาะค่าสตริงเท่านั้นที่ส่งไปยัง API แปลภาษา "quantity": 42 ยังคงเป็น 42 ไม่ใช่ "สี่สิบสอง" "isActive": true ยังคงเป็น true ไม่ใช่ "จริง"
4. การรักษาคีย์
คีย์ออบเจ็กต์ทั้งหมดยังคงอยู่ในภาษาเดิม นี่สำคัญเพราะ translations.header.welcomeMessage ต้องเป็นเส้นทางเดียวกันในไฟล์ภาษาทุกภาษา
5. การประกอบโครงสร้างใหม่ สตริงที่แปลแล้วจะถูกแทรกกลับไปในตำแหน่งเดิมอย่างแน่นอน โดยรักษาระดับการซ้อน ดัชนีอาร์เรย์ และลำดับชั้นออบเจ็กต์
ข้อผิดพลาดทั่วไป: นักพัฒนาบางคนพยายาม JSON.stringify() ออบเจ็กต์ แปลสตริงทั้งหมด แล้วแยกวิเคราะห์กลับ วิธีนี้จะทำให้เสียเพราะตัวแปลจะแก้ไขคีย์ วงเล็บ และไวยากรณ์ วิธีการเรียกซ้ำจะหลีกเลี่ยงปัญหานี้ได้อย่างสมบูรณ์
การใช้เครื่องมือแปลโครงสร้าง JSON
คู่มือทีละขั้นตอน
1. วางข้อมูล JSON ของคุณ คัดลอกออบเจ็กต์ JSON ของคุณและวางในแผงด้านซ้าย เครื่องมือสามารถจัดการ JSON ที่ถูกต้องได้ทุกประเภท—ไม่ว่าจะเป็นออบเจ็กต์ธรรมดาที่มี 5 คีย์หรือโครงสร้างที่ซับซ้อนพร้อมอาร์เรย์และหลายระดับ
2. เลือกภาษาปลายทาง เลือกจากเมนูดรอปดาวน์ภาษา: สเปน ฝรั่งเศส เยอรมัน อิตาลี โปรตุเกส จีน ญี่ปุ่น เกาหลี รัสเซีย และอื่นๆ หากคุณกำลังแปลสำหรับโปรเจ็กต์ i18next ให้จับคู่รหัสภาษาที่เฟรมเวิร์คของคุณคาดหวัง
3. รับการแปลทันที ผลลัพธ์การแปลจะปรากฏขึ้นโดยอัตโนมัติในแผงด้านขวา ไม่ต้องมีปุ่ม "แปล"—จะประมวลผลทันทีเมื่อคุณมี JSON ที่ถูกต้องและเลือกภาษา
4. คัดลอกและใช้ คลิกปุ่ม "คัดลอก" เพื่อดึง JSON ที่แปลแล้ว พร้อมวางลงในโปรเจ็กต์ของคุณทันที—ไม่ต้องทำความสะอาด
5. ล้างเพื่อแปลต่อ กด "ล้างทั้งหมด" เมื่อคุณพร้อมแปลไฟล์อื่น เครื่องมือจะรีเซ็ตทั้งสองแผงทันที
ปัญหาทั่วไปและวิธีแก้ไข
ข้อผิดพลาด "รูปแบบ JSON ไม่ถูกต้อง" คุณจะเห็นข้อความนี้เมื่อมีปัญหาไวยากรณ์ สาเหตุทั่วไป:
- ขาดเครื่องหมายจุลภาคระหว่างคู่คีย์-ค่า
- เครื่องหมายจุลภาคต่อท้ายรายการสุดท้าย (ใช้ได้ใน JavaScript แต่ไม่ใช่ JSON)
- เครื่องหมายอัญประกาศเดี่ยวแทนเครื่องหมายอัญประกาศคู่
- อักขระพิเศษที่ไม่ได้หลีกเลี่ยงในสตริง
วิธีแก้ไขด่วน: ส่ง JSON ของคุณผ่านตัวตรวจสอบเช่น JSONLint ก่อนวาง
การแปลล้มเหลวโดยเงียบ หากแผงผลลัพธ์ยังคงว่าง:
- ตรวจสอบการเชื่อมต่ออินเทอร์เน็ต—การแปลต้องใช้การเข้าถึง API
- ตรวจสอบว่าคุณเลือกภาษาปลายทาง
- ลองกับส่วนย่อย JSON เพื่อแยกปัญหา
ผลลัพธ์การแปลที่ไม่คาดคิด การแปลด้วยเครื่องทำงานได้ดีกับวลีมาตรฐาน แต่มีปัญหากับ:
- ศัพท์เทคนิคหรือคำศัพท์เฉพาะด้าน
- ชื่อแบรนด์ (ซึ่งควรคงเดิมไม่แปล)
- ไวยากรณ์ตัวยึดตำแหน่งเช่น
{{username}}หรือ%s
สำหรับแอปพลิเคชันระดับการผลิต ให้ใช้เครื่องมือนี้เป็นการผ่านแรก จากนั้นให้ผู้พูดภาษาเจ้าของตรวจสอบเนื้อหาเฉพาะด้านหรือที่ติดต่อลูกค้า
เคล็ดลับระดับมืออาชีพเพื่อผลลัพธ์ที่ดีขึ้น
แยกสตริงทางเทคนิค หากข้อมูล JSON ของคุณผสมข้อความที่ติดต่อผู้ใช้กับตัวระบุทางเทคนิค ให้พิจารณาแยกออก ตัวอย่างเช่น:
1{
2 "display": {"welcome": "ยินดีต้อนรับอีกครั้ง"},
3 "config": {"apiKey": "abc123", "endpoint": "https://api.example.com"}
4}
5แปลออบเจ็กต์ display แยกกันเพื่อหลีกเลี่ยงการประมวลผล config โดยไม่ตั้งใจ
ใช้บริบทในสตริงของคุณ "ส่ง" อาจแปลต่างกันขึ้นอยู่กับบริบท "ส่งแบบฟอร์ม" หรือ "ส่งการชำระเงิน" ให้บริบทที่ดีแก่ตัวแปลทั้งมนุษย์และเครื่อง
ทดสอบด้วยข้อมูลจริง ก่อนแปลไฟล์ i18n ทั้งหมดที่มี 500+ คีย์ ให้ทดสอบกับตัวอย่างเล็กที่มีชนิดข้อมูลทั้งหมด—สตริง ตัวเลข ออบเจ็กต์ซ้อน อาร์เรย์
ตัวอย่างโค้ด
แปลภาษา JSON ด้วย JavaScript
1// ตัวอย่างวิธีการใช้ฟังก์ชันที่คล้ายกันใน JavaScript
2function translateJsonStructure(jsonObj, targetLanguage) {
3 // ฟังก์ชันช่วยแปลสตริง
4 function translateString(str, lang) {
5 // ในการใช้งานจริง ฟังก์ชันนี้จะเรียก Translation API
6 return `[${lang}] ${str}`;
7 }
8
9 // ฟังก์ชันวนซ้ำเพื่อแปลและค้นหา JSON
10 function processNode(node) {
11 if (node === null) return null;
12
13 if (typeof node === 'string') {
14 return translateString(node, targetLanguage);
15 }
16
17 if (Array.isArray(node)) {
18 return node.map(item => processNode(item));
19 }
20
21 if (typeof node === 'object') {
22 const result = {};
23 for (const key in node) {
24 result[key] = processNode(node[key]);
25 }
26 return result;
27 }
28
29 // ส่งคืนตัวเลข บูลีน ฯลฯ โดยไม่เปลี่ยนแปลง
30 return node;
31 }
32
33 return processNode(jsonObj);
34}
35
36// ตัวอย่างการใช้งาน
37const sourceJson = {
38 "product": {
39 "name": "หูฟังไร้สาย",
40 "description": "หูฟังไร้สายคุณภาพสูงพร้อมระบบตัดเสียงรบกวน",
41 "features": ["Bluetooth 5.0", "อายุการใช้งานแบตเตอรี่ 40 ชั่วโมง", "ดีไซน์พับได้"],
42 "price": 99.99,
43 "inStock": true
44 }
45};
46
47const translatedJson = translateJsonStructure(sourceJson, "es");
48console.log(JSON.stringify(translatedJson, null, 2));
49แปลภาษา JSON ด้วย Python
1import json
2
3def translate_json_structure(json_obj, target_language):
4 """
5 แปลค่าสตริงใน JSON object โดยคงโครงสร้างเดิม
6
7 Args:
8 json_obj: JSON object ที่ถูก parse
9 target_language: รหัสภาษาเป้าหมาย (เช่น 'es', 'fr')
10
11 Returns:
12 JSON object ที่แปลแล้วโดยคงโครงสร้างเดิม
13 """
14 def translate_string(text, lang):
15 # ในการใช้งานจริง ฟังก์ชันนี้จะเรียก translation API
16 return f"[{lang}] {text}"
17
18 def process_node(node):
19 if node is None:
20 return None
21
22 if isinstance(node, str):
23 return translate_string(node, target_language)
24
25 if isinstance(node, list):
26 return [process_node(item) for item in node]
27
28 if isinstance(node, dict):
29 result = {}
30 for key, value in node.items():
31 result[key] = process_node(value)
32 return result
33
34 # ส่งคืนตัวเลข บูลีน ฯลฯ โดยไม่เปลี่ยนแปลง
35 return node
36
37 return process_node(json_obj)
38
39# ตัวอย่างการใช้งาน
40source_json = {
41 "user": {
42 "name": "เจน สมิธ",
43 "bio": "นักพัฒนาซอฟต์แวร์และผู้สนับสนุนโอเพนซอร์ส",
44 "skills": ["JavaScript", "Python", "React"],
45 "active": True,
46 "followers": 245
47 }
48}
49
50translated_json = translate_json_structure(source_json, "fr")
51print(json.dumps(translated_json, indent=2))
52แปลภาษา JSON ด้วย PHP
1<?php
2/**
3 * แปลโครงสร้าง JSON โดยคงโครงสร้างเดิม
4 *
5 * @param mixed $jsonObj JSON object ที่ถูก parse
6 * @param string $targetLanguage รหัสภาษาเป้าหมาย
7 * @return mixed JSON object ที่แปลแล้ว
8 */
9function translateJsonStructure($jsonObj, $targetLanguage) {
10 // ฟังก์ชันช่วยแปลสตริง
11 function translateString($text, $lang) {
12 // ในการใช้งานจริง ฟังก์ชันนี้จะเรียก translation API
13 return "[$lang] $text";
14 }
15
16 // ฟังก์ชันวนซ้ำเพื่อประมวลผลแต่ละโหนด
17 function processNode($node, $lang) {
18 if ($node === null) {
19 return null;
20 }
21
22 if (is_string($node)) {
23 return translateString($node, $lang);
24 }
25
26 if (is_array($node)) {
27 // ตรวจสอบว่าเป็นอาเรย์แบบ associative (object) หรือ indexed array
28 if (array_keys($node) !== range(0, count($node) - 1)) {
29 // อาเรย์แบบ associative (object)
30 $result = [];
31 foreach ($node as $key => $value) {
32 $result[$key] = processNode($value, $lang);
33 }
34 return $result;
35 } else {
36 // Indexed array
37 return array_map(function($item) use ($lang) {
38 return processNode($item, $lang);
39 }, $node);
40 }
41 }
42
43 // ส่งคืนตัวเลข บูลีน ฯลฯ โดยไม่เปลี่ยนแปลง
44 return $node;
45 }
46
47 return processNode($jsonObj, $targetLanguage);
48}
49
50// ตัวอย่างการใช้งาน
51$sourceJson = [
52 "company" => [
53 "name" => "โซลูชันเทคโนโลยีระดับโลก",
54 "description" => "บริษัทพัฒนาซอฟต์แวร์นวัตกรรม",
55 "founded" => 2010,
56 "services" => ["การพัฒนาเว็บ", "แอปพลิเคชันมือถือ", "โซลูชันคลาวด์"],
57 "active" => true
58 ]
59];
60
61$translatedJson = translateJsonStructure($sourceJson, "de");
62echo json_encode($translatedJson, JSON_PRETTY_PRINT);
63?>
64กรณีการใช้งานในโลกแห่งความเป็นจริง
ไฟล์ i18n สำหรับเว็บแอปพลิเคชัน
เฟรมเวิร์กสมัยใหม่ส่วนใหญ่ เช่น Next.js, React หรือ Vue จะจัดเก็บการแปลในรูปแบบ JSON เมื่อคุณต้องการเพิ่มภาษาใหม่ในแอปของคุณ คุณกำลังเผชิญกับทางเลือก: คัดลอกและแปลแต่ละคีย์ด้วยตนเอง (เสี่ยงต่อข้อผิดพลาด) หรือใช้เครื่องมือนี้เพื่อสร้างร่างแรกภายในไม่กี่นาที
สถานการณ์จริง: แอปของคุณมี en.json ที่มีคีย์การแปลมากกว่า 200 คีย์ในหมวดหมู่ที่ซ้อนกัน—การนำทาง, แบบฟอร์ม, ข้อความแสดงข้อผิดพลาด, คำแนะนำเครื่องมือ คุณต้องการเวอร์ชันภาษาฝรั่งเศสและเยอรมันภายในสปรินต์ถัดไป
อินพุต (en.json):
1{
2 "common": {
3 "welcome": "Welcome to our application",
4 "login": "Log in",
5 "signup": "Sign up",
6 "errorMessages": {
7 "required": "This field is required",
8 "invalidEmail": "Please enter a valid email address"
9 }
10 }
11}
12แปลเป็นภาษาฝรั่งเศส รับ fr.json ที่มีโครงสร้างเหมือนกัน รหัสของคุณยังคงอ้างอิง t('common.errorMessages.required') โดยไม่มีการเปลี่ยนแปลง
สิ่งที่ฉันพบว่าใช้งานได้ดี: สร้างการแปลด้วยเครื่องมือนี้ จากนั้นให้สมาชิกทีมที่สามารถใช้สองภาษาตรวจสอบคำศัพท์ทางเทคนิคและป้ายชื่อปุ่ม นี่จะช่วยจับกรณีที่ "Submit" อาจต้องการการแปลที่แตกต่างกันสำหรับ "Submit form" กับ "Submit payment"
การแปลผลตอบกลับ API
กำลังสร้าง API ที่ให้บริการหลายประเทศ? คุณต้องการโครงสร้างผลตอบกลับที่สอดคล้องกันในทุกภาษา API การแจ้งเตือนอาจส่งคืน:
1{
2 "status": "success",
3 "notification": {
4 "title": "Order Shipped",
5 "message": "Your order #12345 has been shipped",
6 "priority": 1,
7 "timestamp": 1678901234
8 }
9}
10แอปมือถือของคุณแยกวิเคราะห์ notification.title และ notification.message หากการแปลภาษาฝรั่งเศสเปลี่ยนโครงสร้างคีย์ แอปจะเสียหายสำหรับผู้ใช้ชาวฝรั่งเศส
เครื่องมือนี้รับประกันว่า notification.title ยังคงเป็น notification.title ในทุกภาษา โดยมีเพียงค่าสตริงที่ถูกแปล รหัสไคลเอนต์ของคุณทำงานเหมือนกันในทุกโลแคล
ข้อจำกัดที่ควรทราบ: การแปลอัตโนมัติไม่เข้าใจโดเมนของคุณ "Shipped" ในบริบทอีคอมเมิร์ซอาจแปลแตกต่างจากในบริบทโลจิสติกส์หรือทางทะเล สำหรับ API ที่ติดต่อกับลูกค้า ควรตรวจสอบผลลัพธ์ก่อนการใช้งาน
การแปลเนื้อหา Headless CMS
แพลตฟอร์ม Headless CMS เช่น Contentful หรือ Strapi มักจะส่งออกเนื้อหาเป็น JSON เมื่อคุณมีบล็อกโพสต์ 50 รายการพร้อมข้อมูลเมตาที่มีโครงสร้าง (ผู้เขียน, แท็ก, URL รูปภาพหลัก, วันที่เผยแพร่) คุณต้องการแปลเนื้อหาและชื่อเรื่องโดยไม่แตะข้อมูลเมตา
การส่งออกทั่วไปประกอบด้วยสตริงเนื้อหาและการกำหนดค่า:
- เนื้อหา: เนื้อหาบทความ, หัวข้อ, ข้อความสรุป
- โครงสร้าง: รหัสผู้เขียน, เส้นทางรูปภาพ, slug หมวดหมู่, การประทับเวลา
การแปลด้วยตนเองเสี่ยงต่อการเปลี่ยน slug จาก technology เป็น tecnología ซึ่งจะทำให้การกำหนดเส้นทางเสีย การแปลที่รักษาโครงสร้างจะจัดการเฉพาะฟิลด์เนื้อหา
ไฟล์การกำหนดค่าสำหรับการปรับใช้งานหลายภูมิภาค
กำลังปรับใช้งานข้ามภูมิภาค? ไฟล์การกำหนดค่าของคุณอาจต้องมีสตริงที่ท้องถิ่นขณะที่คงปลายทาง, ข้อมูลประจำตัว และฟีเจอร์แฟล็กให้เหมือนเดิม:
1{
2 "region": "eu-west",
3 "welcomeMessage": "Welcome to our service",
4 "endpoint": "https://api.eu.example.com",
5 "retryAttempts": 3,
6 "features": {"darkMode": true}
7}
8แปล welcomeMessage เป็นภาษาเยอรมันโดยไม่แตะ endpoint, retryAttempts และ features
การเปรียบเทียบวิธีการแปล
| วิธี | เหมาะสำหรับ | ความเร็ว | ความแม่นยำ | ความปลอดภัยของโครงสร้าง | ค่าใช้จ่าย |
|---|---|---|---|---|---|
| เครื่องมือนี้ | การสร้างไฟล์ i18n อย่างรวดเร็ว, ต้นแบบ, เครื่องมือภายใน | ทันที | ดีสำหรับเนื้อหามาตรฐาน | คงไว้ 100% | ฟรี |
| Google Translate (คัดลอก/วาง) | ประโยคเดี่ยว, ข้อความที่ไม่เป็นทางเทคนิค | ทันที | แตกต่างกัน | ทำลาย JSON | ฟรี |
| การแปลแบบมืออาชีพ | เนื้อหาที่ติดต่อลูกค้า, เอกสารทางกฎหมาย, การตลาด | หลายวัน | ดีเยี่ยม | ต้องทำด้วยมือ | $0.08-0.15 ต่อคำ |
| ระบบการจัดการการแปล (Lokalise, Phrase) | แอปพลิเคชันระดับองค์กร, เวิร์กโฟลว์การทำงานร่วมกัน | ชั่วโมง-วัน | ดีเยี่ยมพร้อมการตรวจทาน | รองรับ JSON ในตัว | $$$+ |
เมื่อไรควรใช้เครื่องมือนี้: โครงการในช่วงเริ่มต้น, สร้างร่างเพื่อตรวจทาน, แอปพลิเคชันภายในที่การแปลไม่จำเป็นต้องสมบูรณ์แบบ
เมื่อไรควรลงทุนในการแปลแบบมืออาชีพ: เนื้อหาที่ติดต่อลูกค้า, ข้อความทางกฎหมาย/การปฏิบัติตามข้อกำหนด, ข้อความแบรนด์ หรือเมื่อรายละเอียดทางวัฒนธรรมสำคัญกว่าความเร็ว
การพิจารณาทางเทคนิคและกรณีพิเศษ
สิ่งที่ถูกแปล (และสิ่งที่ไม่ถูกแปล)
เครื่องมือใช้การตรวจสอบประเภทเพื่อกำหนดว่าจะแปลอะไร:
✅ แปล:
- ค่าสตริง:
"Welcome"→"ยินดีต้อนรับ" - สตริงในอาร์เรย์:
["Hello", "World"]→["สวัสดี", "โลก"] - สตริงในระดับการซ้อนใดๆ
❌ ไม่แปล:
- ตัวเลข:
42,3.14,-10คงเดิม - ค่าบูลีน:
trueและfalseคงเดิม - ค่าว่าง:
nullคงเป็นnull - คีย์ของออบเจ็กต์:
"userName"เป็นคีย์คงเป็น"userName" - สตริงว่าง:
""คงเป็น""
การจัดการอักขระพิเศษ
ยูนิโคดและอีโมจิ เครื่องมือจัดการ UTF-8 ได้อย่างถูกต้อง ดังนั้นอีโมจิและอักขระนอกละตินทำงานได้ดี:
1{"greeting": "👋 Hello"}
2แปลเป็นภาษาไทยได้เป็น:
1{"greeting": "👋 สวัสดี"}
2ลำดับหลบหนี
ลำดับหลบหนีของ JSON (\n, \t, \") จะถูกเก็บรักษาไว้:
1{"message": "Line 1\nLine 2"}
2\n ยังคงอยู่เหมือนเดิมในการแปล
ตัวยึดตำแหน่ง
นี่คือปัญหาที่อาจเกิดขึ้น: หากสตริงของคุณมีตัวยึดตำแหน่งเช่น {username} หรือ %s อาจถูกแปลหรือเรียงใหม่ ในภาษาที่เขียนจากขวาไปซ้าย ตำแหน่งของตัวยึดตำแหน่งอาจเลื่อน ควรตรวจสอบอย่างระมัดระวัง
ประสิทธิภาพของ JSON ขนาดใหญ่
เครื่องมือเว็บจัดการไฟล์ i18n ทั่วไป (ต่ำกว่า 500KB) โดยไม่มีปัญหา สำหรับชุดข้อมูลที่ใหญ่กว่า:
- 500KB - 2MB: ทำงานได้ แต่อาจช้าในเบราว์เซอร์
- มากกว่า 2MB: ควรแบ่งออกเป็นส่วนตามตรรกะ (เช่น แยกไฟล์ตามคุณสมบัติหรือส่วน)
หน่วยความจำของเบราว์เซอร์เป็นปัจจัยจำกัด ไม่ใช่อัลกอริทึม
คำถามที่พบบ่อย
มีความแตกต่างจากการวาง JSON ลงใน Google Translate อย่างไร?
Google Translate จะปฏิบัติต่อ JSON เสมือนข้อความธรรมดา ซึ่งหมายความว่าจะพยายามแปลทุกอย่าง—รวมถึงคีย์ อักขระไวยากรณ์ และค่าตัวเลข คุณจะได้ผลลัพธ์เช่น:
1{ "nom d'utilisateur": "Jean Dupont", "âge": "vingt-cinq" }
2สังเกตเห็นว่า "username" กลายเป็น "nom d'utilisateur" และตัวเลข 25 กลายเป็นสตริง "vingt-cinq"? โค้ดของคุณจะแตกทันที
เครื่องมือนี้เข้าใจโครงสร้าง JSON และแปลเฉพาะค่าสตริง โดยคงคีย์และชนิดข้อมูลอื่นๆ ไว้เหมือนเดิม
จะจัดการ JSON ที่ซ้อนลึกพร้อมอาร์เรย์ได้หรือไม่?
ได้ อัลกอริทึมแบบเรียกซ้ำจะประมวลผลทุกระดับการซ้อน:
1{
2 "users": [
3 {"name": "John", "roles": ["admin", "editor"]},
4 {"name": "Jane", "roles": ["viewer"]}
5 ]
6}
7มันจะแปลค่าสตริงทั้งหมด ("John", "Jane", "admin", "editor", "viewer") โดยคงโครงสร้างเดิมไว้อย่างเป๊ะ
ถ้า JSON ของฉันมีทั้งภาษาอังกฤษและเนื้อหาที่แปลแล้ว?
เครื่องมือจะแปลสตริงทุกตัวที่พบ แม้ว่าบางตัวจะอยู่ในภาษาเป้าหมายแล้ว หากคุณกำลังเพิ่มคีย์ใหม่ในไฟล์การแปลที่มีอยู่ ให้แปลเฉพาะส่วนใหม่แยกต่างหาก แล้วรวมผลลัพธ์
ใช้กับไฟล์ i18next หรือ react-intl ได้หรือไม่?
แน่นอน โครงสร้างผลลัพธ์ตรงกับสิ่งที่เฟรมเวิร์กเหล่านี้คาดหวัง ไฟล์ JSON ของ i18next เช่น:
1{"translation": {"welcome": "Hello", "goodbye": "Goodbye"}}
2จะกลายเป็น:
1{"translation": {"welcome": "Hola", "goodbye": "Adiós"}}
2การเรียก t('translation.welcome') ของคุณจะทำงานเหมือนเดิม
การแปลอัตโนมัติสำหรับเนื้อหาทางเทคนิคมีความแม่นยำเพียงใด?
ขึ้นอยู่กับบริบท:
- ข้อความ UI ทั่วไป: "Save", "Cancel", "Submit" → มักจะแม่นยำ
- ศัพท์เทคนิค: "webhook", "OAuth2", "idempotent" → อาจแปลผิดหรือคงเดิม
- คำศัพท์เฉพาะด้าน: "patient record" (ทางการแพทย์) กับ "patient" (ความอดทน) → มักพลาดบริบท
สำหรับแอปพลิเคชันระดับการผลิต ให้ใช้นี่เป็นการผ่านแรก แล้วให้ใครสักคนตรวจสอบคำศัพท์ทางเทคนิคและเฉพาะด้าน
แล้วภาษาที่มีชุดอักขระต่างกัน (จีน อาหรับ รัสเซีย) ล่ะ?
เครื่องมือจัดการ Unicode ได้อย่างถูกต้อง ดังนั้นทุกชุดอักขระจะทำงานได้ สิ่งที่ต้องระวัง: อาหรับและฮิบรูเป็นภาษาจากขวาไปซ้าย (RTL) ซึ่งอาจส่งผลต่อวิธีการแสดงตัวยึดตำแหน่งในสตริงที่แปล โครงสร้าง JSON จะคงเดิม แต่ให้ตรวจสอบความสามารถในการอ่านของข้อความที่แปลแล้ว
จะคงรูปแบบ (การเยื้อง การขึ้นบรรทัดใหม่) ไว้ได้หรือไม่?
ผลลัพธ์เป็น JSON ที่ถูกต้อง แต่การจัดรูปแบบ (ช่องว่าง การเยื้อง) อาจแตกต่างจากอินพุตของคุณ หากต้องการรูปแบบเฉพาะ ให้นำผลลัพธ์ผ่านตัวจัดรูปแบบ JSON ด้วยการตั้งค่าที่คุณต้องการ
สามารถแปลค่าการกำหนดค่า เช่น URL หรือคีย์ API ได้หรือไม่?
เครื่องมือจะแปลสตริงทั้งหมด รวมถึง URL และค่าการกำหนดค่า เพื่อป้องกัน:
- แยก JSON ของคุณออกเป็นเนื้อหาที่เห็นโดยผู้ใช้และการกำหนดค่า
- แปลเฉพาะส่วนเนื้อหา
- เก็บการกำหนดค่าไว้ไม่แปล
ดีกว่านั้น ให้จัดโครงสร้างไฟล์เพื่อแยกเนื้อหาที่แปลได้ออกจากค่าทางเทคนิคตั้งแต่แรก
นี่ฟรีหรือไม่? มีขีดจำกัดการใช้งานหรือไม่?
เครื่องมือบนเว็บนี้ฟรีสำหรับการใช้งานทั่วไป การแปลปริมาณสูง (หลายร้อยไฟล์ต่อนาที) อาจกระทบกับขีดจำกัดของบริการแปลที่อยู่เบื้องหลัง สำหรับเวิร์กโฟลว์การพัฒนาส่วนใหญ่ คุณจะไม่พบขีดจำกัด
การอ้างอิงและการอ่านเพิ่มเติม
สำหรับความเข้าใจที่ลึกซึ้งเกี่ยวกับโครงสร้าง JSON มาตรฐานการแปลภาษา และแนวปฏิบัติที่ดีที่สุด:
-
ECMA-404: ไวยากรณ์การแลกเปลี่ยนข้อมูล JSON - ข้อกำหนด JSON อย่างเป็นทางการโดย Ecma International ที่กำหนดรูปแบบมาตรฐาน: ecma-international.org/publications-and-standards/standards/ecma-404/
-
MDN Web Docs: การทำงานกับ JSON - คู่มือที่ครอบคลุมของ Mozilla เกี่ยวกับการแยกวิเคราะห์ JSON การแปลงเป็นสตริง และโครงสร้าง: developer.mozilla.org/en-US/docs/Learn/JavaScript/Objects/JSON
-
กิจกรรมการทำให้เป็นสากล W3C (i18n) - มาตรฐานและแนวปฏิบัติที่ดีที่สุดสำหรับการทำให้เว็บเป็นสากล: w3.org/International/
-
RFC 8259: รูปแบบการแลกเปลี่ยนข้อมูล JSON - ข้อกำหนด IETF สำหรับไวยากรณ์และความหมายของ JSON: datatracker.ietf.org/doc/html/rfc8259
เริ่มแปลไฟล์ JSON ของคุณ
ต้องการสร้างไฟล์แปลสำหรับแอปพลิเคชันหลายภาษาอย่างรวดเร็วหรือไม่? วางข้อมูล JSON ของคุณ เลือกภาษาเป้าหมาย และรับการแปลที่คงโครงสร้างทันที ใช้งานได้กับ i18next, react-intl, vue-i18n และเฟรมเวิร์กอื่นๆ ที่ต้องการโครงสร้าง JSON ที่สอดคล้องกันในแต่ละภาษา
เริ่มแปลเดี๋ยวนี้: