การแปลซอร์สโค้ดจาก TypeScript โดยใช้ AI เกี่ยวข้องกับการใช้เทคนิคการประมวลผลภาษาธรรมชาติ (NLP) และอัลกอริธึมการเรียนรู้ของเครื่องเพื่อวิเคราะห์และทำความเข้าใจซอร์สโค้ด
| ปัญหาการแปล | TypeScript ตัวอย่างไวยากรณ์ | Java ตัวอย่างไวยากรณ์ | คะแนน |
|---|---|---|---|
| ประเภทรวม | type A = string | number; |
String or Number (ไม่รองรับโดยตรง) |
3 |
| ตัวตกแต่ง | @Component |
@Component (รองรับแต่ความหมายต่างกัน) |
6 |
| การเชื่อมโยงแบบเลือกได้ | obj?.property |
obj != null ? obj.property : null |
4 |
| การอนุมานประเภท | let x = 10; |
int x = 10; (ต้องการประเภทที่ชัดเจน) |
5 |
| อินเตอร์เฟซ vs คลาสนามธรรม | interface A { method(): void; } |
abstract class A { abstract void method(); } |
7 |
| เอนัม | enum Color { Red, Green, Blue } |
enum Color { RED, GREEN, BLUE } |
8 |
| เจนเนอริค | function identity<T>(arg: T): T { return arg; } |
public <T> T identity(T arg) { return arg; } |
9 |
| Async/Await | async function fetchData() { await fetch(url); } |
CompletableFuture<Data> fetchData() { ... } |
5 |
| การยืนยันประเภท | let value = someValue as string; |
(String) someValue; |
4 |
| ระบบโมดูล | import { A } from './module'; |
import A from './module'; |
6 |
TypeScript รองรับประเภทรวม ซึ่งช่วยให้ตัวแปรสามารถถือประเภทหลายประเภทได้ Java ไม่รองรับประเภทรวมโดยตรง
ตัวอย่าง TypeScript:
type A = string | number;
let value: A;
value = "Hello"; // ถูกต้อง
value = 42; // ถูกต้อง
เทียบเท่า Java:
Java ไม่มีเทียบเท่าที่ตรงสำหรับประเภทรวม คุณมักจะใช้ Object หรือสร้างลำดับชั้นของคลาส
อ้างอิง: คู่มือ TypeScript - ประเภทรวม
TypeScript รองรับตัวตกแต่ง ซึ่งเป็นการประกาศประเภทพิเศษที่สามารถแนบกับคลาสหรือวิธีการได้ Java มีการระบุ แต่การใช้งานและความหมายแตกต่างกัน
ตัวอย่าง TypeScript:
function Log(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
console.log(`${propertyKey} ถูกเรียก`);
}
class Example {
@Log
method() {}
}
เทียบเท่า Java: Java ใช้การระบุ แต่ไม่ให้พฤติกรรมในระหว่างการทำงานเหมือนกับตัวตกแต่งของ TypeScript
อ้างอิง: คู่มือ TypeScript - ตัวตกแต่ง
TypeScript มีการเชื่อมโยงแบบเลือกได้เพื่อเข้าถึงคุณสมบัติที่ซ้อนกันอย่างปลอดภัย Java ต้องการการตรวจสอบ null อย่างชัดเจน
ตัวอย่าง TypeScript:
let value = obj?.property;
เทียบเท่า Java:
String value = (obj != null) ? obj.getProperty() : null;
อ้างอิง: คู่มือ TypeScript - การเชื่อมโยงแบบเลือกได้
TypeScript มีการอนุมานประเภทที่ทรงพลัง ในขณะที่ Java ต้องการการประกาศประเภทที่ชัดเจน
ตัวอย่าง TypeScript:
let x = 10; // อนุมานเป็น number
เทียบเท่า Java:
int x = 10; // ต้องการประเภทที่ชัดเจน
อ้างอิง: คู่มือ TypeScript - การอนุมานประเภท
TypeScript ใช้อินเตอร์เฟซในการกำหนดสัญญา ในขณะที่ Java มีทั้งอินเตอร์เฟซและคลาสนามธรรมที่มีความสามารถแตกต่างกัน
ตัวอย่าง TypeScript:
interface A {
method(): void;
}
เทียบเท่า Java:
abstract class A {
abstract void method();
}
อ้างอิง: คู่มือ TypeScript - อินเตอร์เฟซ
เอนัมใน TypeScript มีความยืดหยุ่นมากกว่าเอนัมใน Java ซึ่งมีโครงสร้างที่เข้มงวดกว่า
ตัวอย่าง TypeScript:
enum Color { Red, Green, Blue }
เทียบเท่า Java:
enum Color { RED, GREEN, BLUE }
อ้างอิง: คู่มือ TypeScript - เอนัม
ทั้ง TypeScript และ Java รองรับเจนเนอริค แต่ไวยากรณ์และการใช้งานอาจแตกต่างกัน
ตัวอย่าง TypeScript:
function identity<T>(arg: T): T {
return arg;
}
เทียบเท่า Java:
public <T> T identity(T arg) {
return arg;
}
อ้างอิง: คู่มือ TypeScript - เจนเนอริค
TypeScript มีการสนับสนุนในตัวสำหรับ async/await ในขณะที่ Java ใช้ CompletableFuture
ตัวอย่าง TypeScript:
async function fetchData() {
const response = await fetch(url);
}
เทียบเท่า Java:
CompletableFuture<Data> fetchData() {
// การทำงาน
}
อ้างอิง: คู่มือ TypeScript - ฟังก์ชัน Async
TypeScript อนุญาตให้มีการยืนยันประเภท ในขณะที่ Java ใช้การแคสต์
ตัวอย่าง TypeScript:
let value = someValue as string;
เทียบเท่า Java:
String value = (String) someValue;
อ้างอิง: คู่มือ TypeScript - การยืนยันประเภท
TypeScript ใช้ไวยากรณ์โมดูล ES ในขณะที่ Java มีระบบโมดูลของตนเอง
ตัวอย่าง TypeScript:
import { A } from './module';
เทียบเท่า Java:
import A from './module';
อ้างอิง: คู่มือ TypeScript - โมดูล