TypeScript - Modul: Panduan untuk Pemula

Hai sana, pemrogram yang sedang mencari ilmu! Hari ini, kita akan memulai perjalanan menarik ke dunia modul TypeScript. Jangan khawatir jika Anda baru dalam pemrograman; saya akan menjadi panduan ramah Anda, menjelaskan segala sesuatu langkah demi langkah. Mari kita masuk ke dalamnya!

Apa Itu Modul?

Sebelum kita masuk ke hal yang teknis, mari kita mengerti apa itu modul. Bayangkan Anda sedang membangun struktur Lego yang besar. Daripada membuat segala sesuatu dalam satu kesempatan, Anda mungkin akan membangun bagian kecil secara terpisah dan kemudian menggabungkannya. Itu tepat apa yang dilakukan modul dalam pemrograman!

Modul membantu kita mengatur kode menjadi bagian yang dapat dikelola dan digunakan kembali. Mereka memungkinkan kita untuk membagi kode kita di beberapa file, membuatnya mudah untuk dipelihara dan dipahami. Dalam TypeScript, kita memiliki dua jenis modul: Internal dan Eksternal.

Modul Internal

Modul internal, juga dikenal sebagai namespace, adalah cara asli TypeScript mengatur kode. Meskipun mereka kurang umum saat ini, memahaminya bisa membantu.

Membuat Modul Internal

mari kita membuat modul internal pertama kita:

namespace MathOperations {
export function add(x: number, y: number): number {
return x + y;
}

export function subtract(x: number, y: number): number {
return x - y;
}
}

console.log(MathOperations.add(5, 3));      // Output: 8
console.log(MathOperations.subtract(10, 4)); // Output: 6

Dalam contoh ini, kita membuat namespace bernama MathOperations. Di dalamnya, kita memiliki dua fungsi: add dan subtract. Kata kunci export membuat fungsi ini dapat diakses di luar namespace.

Menggunakan Modul Internal

Untuk menggunakan fungsi dari namespace kita, kita awali mereka dengan nama namespace:

let sum = MathOperations.add(10, 20);
console.log(sum); // Output: 30

Namespaces Bersarang

Kita bahkan dapat menempatkan namespace di dalam namespace lain:

namespace Geometry {
export namespace Circle {
export function calculateArea(radius: number): number {
return Math.PI * radius * radius;
}
}
}

console.log(Geometry.Circle.calculateArea(5)); // Output: 78.53981633974483

Di sini, kita memiliki namespace Circle yang ditempatkan di dalam namespace Geometry.

Modul Eksternal

Modul eksternal adalah cara yang lebih modern dan disukai untuk mengatur kode TypeScript. Mereka sejalan dengan ECMAScript 2015 (ES6) modul.

Membuat Modul Eksternal

mari kita membuat file bernama mathOperations.ts:

// mathOperations.ts
export function add(x: number, y: number): number {
return x + y;
}

export function multiply(x: number, y: number): number {
return x * y;
}

Dalam file ini, kita mengekspor dua fungsi: add dan multiply.

Mengimpor dan Menggunakan Modul Eksternal

Sekarang, mari kita membuat file lain untuk menggunakan fungsi ini:

// app.ts
import { add, multiply } from './mathOperations';

console.log(add(5, 3));      // Output: 8
console.log(multiply(4, 2)); // Output: 8

Di sini, kita mengimpor fungsi tertentu dari modul mathOperations.

Ekspor Default

kadang-kadang, Anda mungkin ingin mengekspor hal utama saja dari modul. Itu adalah tempat ekspor default masuk:

// greet.ts
export default function greet(name: string): string {
return `Hello, ${name}!`;
}

Untuk mengimpor ekspor default:

// app.ts
import greet from './greet';

console.log(greet('Alice')); // Output: Hello, Alice!

Mengubah Nama Impor

Anda juga dapat mengubah nama impor jika Anda ingin menghindari konflik nama:

import { add as sum } from './mathOperations';

console.log(sum(5, 3)); // Output: 8

Mengapa Menggunakan Modul?

1. Organisasi: Modul membantu menjaga kode Anda teratur dan dapat dipelihara.
2. Enkapsulasi: Mereka menyediakan cara untuk menyembunyikan kompleksitas kode Anda.
3. Reusabilitas: Anda dapat mudah mengguna ulang kode di berbagai bagian aplikasi Anda.
4. Namespace: Mereka membantu menghindari konflik nama dalam kode Anda.

Strategi Resolusi Modul

TypeScript menggunakan berbagai strategi untuk meresolusi modul:

Strategi	Deskripsi
Classic	Menggunakan algoritma sederhana untuk mencari modul
Node	Meniru mekanisme resolusi modul Node.js
Path mapping	Memungkinkan Anda menentukan bagaimana TypeScript harus meresolusi impor

Kesimpulan

Selamat! Anda telah mengambil langkah pertama ke dalam dunia modul TypeScript. Ingat, seperti belajar menunggang sepeda, mungkin merasa agak wobble awalnya, tapi dengan latihan, Anda akan segera berpacu. Modul adalah alat yang kuat dalam peralatan pemrograman Anda. Mereka membantu Anda menulis kode yang bersih, teratur, dan dapat digunakan kembali. Dalam perjalanan TypeScript Anda, Anda akan menemukan bahwa Anda menggunakan modul lebih dan lebih.

Terus coding, terus belajar, dan terutama, bersenang-senang! Siapa tahu? Aplikasi besar berikutnya mungkin hanya satu modul jauh. Selamat coding!

Credits: Image by storyset