# TypeScript - Modul: Panduan untuk Pemula

Hai sana, calon pemrogrammer! Hari ini, kita akan memulai perjalanan menarik ke dunia modul TypeScript. Jangan khawatir jika Anda baru saja memulai dalam programming; saya akan menjadi panduan ramah Anda, menjelaskan segala sesuatu langkah demi langkah. mari kita masuk ke dalamnya!

## Apa Itu Modul?

Sebelum kita masuk ke detilnya, mari kita mengerti apa itu modul. Bayangkan Anda sedang membangun struktur Lego besar. Daripada menciptakan segalanya dalam satu langkah, Anda mungkin akan membangun bagian kecil secara terpisah dan kemudian menggabungkannya. Itu tepat apa yang dilakukan modul dalam programming!

Modul membantu kita mengatur kode menjadi bagian yang dapat dikelola dan digunakan kembali. Mereka memungkinkan kita 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 jarang digunakan saat ini, memahaminya bisa membantu.

### Membuat Modul Internal

 mari kita buat modul internal pertama kita:

```typescript
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. 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 tambahkan nama namespace sebelumnya:

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

Namespaces Tertanam

Kita bahkan dapat menanamkan namespaces di dalam yang 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 tertanam 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 buat 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 buat file lain untuk menggunakan fungsi-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 sesuatu utama 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 mengulangi kode di berbagai bagian aplikasi Anda.
4. Namespace: Mereka membantu menghindari konflik nama dalam kode Anda.

Strategi Resolusi Modul

TypeScript menggunakan berbagai strategi untuk menguraikan modul:

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

Kesimpulan

Selamat! Anda baru saja mengambil langkah pertama ke dunia modul TypeScript. Ingat, seperti belajar menunggang sepeda, mungkin Anda merasa agak berayun di awal, tapi dengan latihan, Anda akan mulai meluncur dengan cepat.

Modul adalah alat kuat dalam peralatan pemrogramming Anda. Mereka membantu Anda menulis kode yang bersih, teratur, dan dapat digunakan kembali. Dalam perjalanan TypeScript Anda, Anda akan menemukan bahwa Anda semakin sering menggunakan modul.

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

Credits: Image by storyset