JavaScript project එකක් පටන් ගන්නකොට හැම දෙයක්ම ගොඩක්ම simple.

Variable එකක් හදනවා, function ලියනවා, API එකක් connect කරනවා, features add කරනවා.

හැබැයි project එක ටික ටික ලොකු වෙද්දී situation එක වෙනස් වෙනවා.

Files වැඩි වෙනවා. Developers ලා වැඩි වෙනවා. API වලින් එන data complex වෙනවා. එක developer කෙනෙක් ලියපු function එක තව developer කෙනෙක් වෙනස් විදිහකට use කරනවා.

ඒ වගේ වෙලාවක පොඩි mistake එකක් නිසා application එකේ වෙන තැනක error එකක් එන්න පුළුවන්.

TypeScript මේ වගේ problems manage කරන්න help වෙන tool එකක්.

හැබැයි JavaScript සහ TypeScript අතර ඇත්තටම වෙනස මොකක්ද?

JavaScript කියන්නේ මොකක්ද?

JavaScript කියන්නේ web applications වල logic සහ interactivity හදන්න භාවිතා කරන programming language එකක්.

සාමාන්‍යයෙන් web development වල:

• HTML → Structure

• CSS → Styling

• JavaScript → Logic & Behavior

උදාහරණයක්:

let username = "Thish";
console.log("Hello " + username);

JavaScript browser එකේ විතරක් නෙවෙයි භාවිතා වෙන්නේ.

Node.js වගේ technologies එක්ක JavaScript භාවිතා කරලා backend applications සහ APIs පවා හදන්න පුළුවන්.

JavaScript වල Types කොහොමද වැඩ කරන්නේ?

JavaScript වල variable එක declare කරනකොට type එක explicitly කියන්න ඕන නැහැ.

let age = 21;
let name = "Thish";
let isStudent = true;

JavaScript value එක බලලා type එක handle කරනවා.

තවත් interesting දෙයක් තමයි:

let value = 100;

value = "Hello";

මෙතන value මුලින් number එකක්.

පස්සේ ඒකට string එකක් assign කළත් JavaScript ඒක allow කරනවා.

මේකට dynamic typing කියනවා.

පොඩි projects වලදී මේ flexibility එක useful.

හැබැයි ලොකු projects වලදී මේ flexibility නිසා සමහර mistakes හොයාගන්න අමාරු වෙන්න පුළුවන්.

TypeScript කියන්නේ මොකක්ද?

TypeScript කියන්නේ Microsoft විසින් develop කරපු programming language එකක්. ඒක JavaScript වලට static type checking වගේ features එකතු කරනවා.

උදාහරණයක්:

let age: number = 21;

මෙතන number කියලා type එකක් දීලා තියෙනවා.

ඒ නිසා:

age = "Hello";

කළොත් TypeScript මේක type error එකක් කියලා පෙන්වනවා.

ඒකේ main idea එක සරලයි:

Code එක run කරන්න කලින් type-related mistakes හඳුනාගන්න help කරන එක.

JavaScript vs TypeScript: Type Checking

මේ දෙකේ ලොකුම වෙනස්කම මෙතනින් තේරුම් ගන්න පුළුවන්.

JavaScript

let price = 500;

price = "Five Hundred";

JavaScript මේකට type error එකක් දාන්නේ නැහැ.

TypeScript

let price: number = 500;

price = "Five Hundred";

TypeScript මේක problem එකක් විදිහට හඳුනාගන්නවා.

ඒ කියන්නේ TypeScript code එකේ values සහ data structures ගැන කලින්ම rules define කරන්න පුළුවන්.

TypeScript කියන්නේ JavaScript වලට ආදේශකයක්ද?

නැහැ.

TypeScript JavaScript වලට ගොඩක් closely connected.

උදාහරණයක්:

const name = "Thish";

console.log(name);

මේක JavaScript code එකක් වගේම TypeScript file එකකත් ලියන්න පුළුවන්.

TypeScript-specific feature එකක් add කළොත්:

const name: string = "Thish";

මෙතන : string තමයි extra type information එක.

ඒ නිසා JavaScript දන්න කෙනෙක්ට TypeScript ඉගෙන ගන්න එක සාපේක්ෂව ලේසියි.

TypeScript Browser එකේ Run වෙනවද?

සාමාන්‍ය browser එකකට TypeScript syntax directly තේරෙන්නේ නැහැ.

ඒ නිසා development process එකේ TypeScript code එක JavaScript බවට transform කරනවා.

සරලව:

TypeScript → JavaScript → Browser

උදාහරණයක්:

const age: number = 21;

Browser එකට යන JavaScript code එක මේ වගේ:

const age = 21;

number කියන type information එක runtime එකේ browser එකට අවශ්‍ය නැහැ.

Student Application එකක්

හිතන්න අපි university studentsලා manage කරන application එකක් හදනවා කියලා.

JavaScript වල:

const student = {
name: "Thish",
age: 21,
course: "Computing"
};

Project එක ලොකු වෙද්දී developers ලාට student object එකේ expected structure එක මතක තියාගන්න අමාරු වෙන්න පුළුවන්.

TypeScript වලින් අපි ඒ structure එක define කරන්න පුළුවන්:

interface Student {
name: string;
age: number;
course: string;
}

ඊට පස්සේ:

const student: Student = {
name: "Thish",
age: 21,
course: "Computing"
};

දැන් TypeScript දන්නවා Student object එකක:

• name → string

• age → number

• course → string

විය යුතු බව.

කෙනෙක් මෙහෙම ලිව්වොත්:

const student: Student = {
name: "Thish",
age: "Twenty One",
course: "Computing"
};

TypeScript එකෙන් ඒ mistake එක identify කරන්න පුළුවන්.

TypeScript වල තවත් වැදගත් දෙයක්

ලොකු project එකකදි developer කෙනෙක්ට function එකක් හම්බවුණා කියලා හිතන්න.

function createUser(
name: string,
age: number,
email: string
) {
// ...
}

Function එක use කරන developerට code එක බලපු ගමන් තේරෙනවා:

• name → string

• age → number

• email → string

ඒ නිසා වෙන developer කෙනෙක්ට documentation හොය හොයා ඉන්න අවශ්‍යතාව අඩු වෙනවා.

ඒ වගේම modern code editors වල:

• Autocomplete

• Error highlighting

• Parameter suggestions

• Code navigation

• Safer refactoring

වගේ features වලට හොඳින් වැඩ කරන්න TypeScript වල type information එක use කරන්න පුළුවන්.

API සමඟ වැඩ කරනකොට තියෙන වාසිය

Modern web applications වල APIs ගොඩක් use කරනවා.

හිතන්න API එකකින් මේ data එක එනවා:

{
"id": 101,
"name": "Thish",
"email": "student@example.com"
}

TypeScript වලින්:

interface User {
id: number;
name: string;
email: string;
}

වගේ structure එකක් define කරන්න පුළුවන්.

මේකෙන් application එක ඇතුළේ User data එක කොහොමද තියෙන්න ඕන කියන එක clear වෙනවා.

හැබැයි TypeScript type එකක් define කළා කියලා API එකෙන් ඇත්තටම ඒ data එකම එනවා කියලා guarantee වෙන්නේ නැහැ.

External data සඳහා අවශ්‍ය නම් runtime validation කරන්න වෙනවා.

JavaScript vs TypeScript

TypeScript Application එක Fast කරනවද?

නැහැ.

TypeScript use කළා කියලා application එක නිකන්ම වේගවත් වෙන්නේ නැහැ.

TypeScript වල main benefit එක performance නෙවෙයි.

එය වැඩිපුර help කරන්නේ developerට:

• Mistakes කලින් හඳුනාගන්න

• Code එක understand කරන්න

• ලොකු codebase එක manage කරන්න

• Refactoring safely කරන්න

• Team එකක් එක්ක වැඩ කරන්න

ඒ නිසා TypeScript එක runtime performance tool එකකට වඩා development tool එකක් කියලා හිතන එක හොඳයි.

TypeScript වල අවාසි මොනවද?

TypeScript වල benefits තියෙනවා වගේම trade-offs ටිකකුත් තියෙනවා.

වැඩිපුර concepts තියෙනවා

JavaScript වලට අමතරව:

• Interfaces

• Type aliases

• Union types

• Generics

• Type narrowing

• Utility types

වගේ concepts ඉගෙන ගන්න වෙනවා.

Setup එක ටිකක් වැඩියි

Simple JavaScript file එකක් run කරන එක ලේසියි.

TypeScript project එකකට compiler එකක් හෝ TypeScript support කරන build tool එකක් අවශ්‍ය වෙනවා.

සමහර වෙලාවට වැඩිපුර code ලියන්න වෙනවා

JavaScript:

function add(a, b) {
return a + b;
}

TypeScript:

function add(a: number, b: number): number {
return a + b;
}

TypeScript version එකේ information වැඩියි.

JavaScript භාවිතා කරන්න හොඳ මොන වගේ තැන් වලද?

JavaScript හොඳ choice එකක් වෙන්න පුළුවන්:

• Small projects

• Simple websites

• Quick scripts

• Prototypes

• Learning projects

උදාහරණයක් විදිහට simple webpage එකකට buttons කිහිපයක් සහ small interactions ටිකක් විතරක් තියෙනවා නම් JavaScript හොඳටම ප්‍රමාණවත්.

TypeScript භාවිතා කරන්න හොඳ මොන වගේ තැන් වලද?

TypeScript වැඩිපුර useful වෙන්නේ project එක:

• ලොකු නම්

• Developers ලා ගොඩක් ඉන්නවා නම්

• Complex data structures තියෙනවා නම්

• APIs ගොඩක් use කරනවා නම්

• Long-term maintain කරන්න වෙනවා නම්

• Code එක නිතර refactor කරනවා නම්

වගේ situations වලදී.

Project එක ලොකු වෙනකොට code එකේ expected structure එක clearව තිබීම developer කෙනාට ලොකු help එකක්.

Beginner කෙනෙක් මුලින් මොකක් ඉගෙන ගන්න ඕනෙද?

Web development අලුතින් පටන් ගන්නවා නම් JavaScript මුලින් ඉගෙන ගන්න එක හොඳයි.

Simple learning path එක:

HTML → CSS → JavaScript → TypeScript

මුලින් JavaScript වල:

• Variables

• Functions

• Arrays

• Objects

• DOM

• Events

• Modules

• Promises

• Async/Await

• APIs

වගේ fundamentals හොඳින් තේරුම් ගන්න.

ඊට පස්සේ TypeScript වල types, interfaces සහ අනෙකුත් features ඉගෙන ගන්න.

එතකොට TypeScript කියන්නේ completely අලුත් programming language එකක් වගේ දැනෙන්නේ නැහැ.