M

MLOG

ಕನ್ನಡ

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳಿ: ಟೈಪ್ ಪರಿವರ್ತನೆಗಾಗಿ ಶಕ್ತಿಯುತ ಪರಿಕರಗಳು, ಕೋಡ್ ಮರುಬಳಕೆ ಸುಧಾರಣೆ, ಮತ್ತು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಟೈಪ್ ಸುರಕ್ಷತೆ ಹೆಚ್ಚಳ.

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಯುಟಿಲಿಟಿ ಟೈಪ್ಸ್: ಅಂತರ್ನಿರ್ಮಿತ ಟೈಪ್ ಮ್ಯಾನಿಪುಲೇಷನ್ ಪರಿಕರಗಳು

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಒಂದು ಶಕ್ತಿಯುತ ಭಾಷೆಯಾಗಿದ್ದು, ಇದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಸ್ಟ್ಯಾಟಿಕ್ ಟೈಪಿಂಗ್ ಅನ್ನು ತರುತ್ತದೆ. ಇದರ ಪ್ರಮುಖ ವೈಶಿಷ್ಟ್ಯವೆಂದರೆ ಟೈಪ್‌ಗಳನ್ನು ಮ್ಯಾನಿಪುಲೇಟ್ ಮಾಡುವ ಸಾಮರ್ಥ್ಯ, ಇದು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಹೆಚ್ಚು ದೃಢವಾದ ಮತ್ತು ನಿರ್ವಹಿಸಬಲ್ಲ ಕೋಡ್ ರಚಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಸಾಮಾನ್ಯ ಟೈಪ್ ಪರಿವರ್ತನೆಗಳನ್ನು ಸರಳಗೊಳಿಸುವ ಅಂತರ್ನಿರ್ಮಿತ ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳ ಒಂದು ಗುಂಪನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳು ಟೈಪ್ ಸುರಕ್ಷತೆಯನ್ನು ಹೆಚ್ಚಿಸಲು, ಕೋಡ್ ಮರುಬಳಕೆಯನ್ನು ಸುಧಾರಿಸಲು ಮತ್ತು ನಿಮ್ಮ ಅಭಿವೃದ್ಧಿ ಕೆಲಸದ ಹರಿವನ್ನು ಸುಗಮಗೊಳಿಸಲು ಅಮೂಲ್ಯವಾದ ಸಾಧನಗಳಾಗಿವೆ. ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ ಅತ್ಯಂತ ಅಗತ್ಯವಾದ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳನ್ನು ಪರಿಶೋಧಿಸುತ್ತದೆ, ಅವುಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡಲು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು ಮತ್ತು ಕ್ರಿಯಾತ್ಮಕ ಒಳನೋಟಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಯುಟಿಲಿಟಿ ಟೈಪ್ಸ್ ಎಂದರೇನು?

ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳು ಪೂರ್ವನಿರ್ಧರಿತ ಟೈಪ್ ಆಪರೇಟರ್‌ಗಳಾಗಿವೆ, ಇವು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಟೈಪ್‌ಗಳನ್ನು ಹೊಸ ಟೈಪ್‌ಗಳಾಗಿ ಪರಿವರ್ತಿಸುತ್ತವೆ. ಇವುಗಳನ್ನು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಭಾಷೆಯಲ್ಲಿಯೇ ನಿರ್ಮಿಸಲಾಗಿದೆ ಮತ್ತು ಸಾಮಾನ್ಯ ಟೈಪ್ ಮ್ಯಾನಿಪುಲೇಷನ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಸಂಕ್ಷಿಪ್ತ ಮತ್ತು ಘೋಷಣಾತ್ಮಕ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತವೆ. ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳನ್ನು ಬಳಸುವುದರಿಂದ ಬಾಯ್ಲರ್‌ಪ್ಲೇಟ್ ಕೋಡ್ ಅನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಕಡಿಮೆ ಮಾಡಬಹುದು ಮತ್ತು ನಿಮ್ಮ ಟೈಪ್ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಹೆಚ್ಚು ಅಭಿವ್ಯಕ್ತ ಮತ್ತು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸುಲಭವಾಗಿಸಬಹುದು.

ಇವುಗಳನ್ನು ಮೌಲ್ಯಗಳ ಬದಲು ಟೈಪ್‌ಗಳ ಮೇಲೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಫಂಕ್ಷನ್‌ಗಳೆಂದು ಯೋಚಿಸಿ. ಅವು ಇನ್‌ಪುಟ್ ಆಗಿ ಒಂದು ಟೈಪ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತವೆ ಮತ್ತು ಔಟ್‌ಪುಟ್ ಆಗಿ ಮಾರ್ಪಡಿಸಿದ ಟೈಪ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತವೆ. ಇದು ಕನಿಷ್ಠ ಕೋಡ್‌ನೊಂದಿಗೆ ಸಂಕೀರ್ಣ ಟೈಪ್ ಸಂಬಂಧಗಳನ್ನು ಮತ್ತು ಪರಿವರ್ತನೆಗಳನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳನ್ನು ಏಕೆ ಬಳಸಬೇಕು?

ನಿಮ್ಮ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಲ್ಲಿ ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳನ್ನು ಸೇರಿಸಲು ಹಲವಾರು ಬಲವಾದ ಕಾರಣಗಳಿವೆ:

ಅಗತ್ಯವಾದ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಯುಟಿಲಿಟಿ ಟೈಪ್ಸ್

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸಲಾಗುವ ಮತ್ತು ಪ್ರಯೋಜನಕಾರಿಯಾದ ಕೆಲವು ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳನ್ನು ಅನ್ವೇಷಿಸೋಣ. ಅವುಗಳ ಉದ್ದೇಶ, ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ನಾವು ಚರ್ಚಿಸುತ್ತೇವೆ ಮತ್ತು ಅವುಗಳ ಬಳಕೆಯನ್ನು ವಿವರಿಸಲು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳನ್ನು ನೀಡುತ್ತೇವೆ.

1. Partial<T>

Partial<T> ಯುಟಿಲಿಟಿ ಟೈಪ್ T ಟೈಪ್‌ನ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಐಚ್ಛಿಕ (optional) ಮಾಡುತ್ತದೆ. ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಟೈಪ್‌ನ ಕೆಲವು ಅಥವಾ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊಂದಿರುವ ಹೊಸ ಟೈಪ್ ಅನ್ನು ರಚಿಸಲು ನೀವು ಬಯಸಿದಾಗ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ, ಆದರೆ ಅವೆಲ್ಲವೂ ಇರಬೇಕೆಂದು ನೀವು ಬಯಸುವುದಿಲ್ಲ.

ಸಿಂಟ್ಯಾಕ್ಸ್:

type Partial<T> = { [P in keyof T]?: T[P]; };

ಉದಾಹರಣೆ:

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

type OptionalUser = Partial<User>; // ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳು ಈಗ ಐಚ್ಛಿಕವಾಗಿವೆ

const partialUser: OptionalUser = {
 name: "Alice", // ಕೇವಲ name ಪ್ರಾಪರ್ಟಿಯನ್ನು ಒದಗಿಸಲಾಗಿದೆ
};

ಬಳಕೆಯ ಸನ್ನಿವೇಶ: ಕೇವಲ ಕೆಲವು ಪ್ರಾಪರ್ಟಿಗಳೊಂದಿಗೆ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಅಪ್‌ಡೇಟ್ ಮಾಡುವುದು. ಉದಾಹರಣೆಗೆ, ಬಳಕೆದಾರರ ಪ್ರೊಫೈಲ್ ಅಪ್‌ಡೇಟ್ ಫಾರ್ಮ್ ಅನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ಬಳಕೆದಾರರು ಒಂದೇ ಬಾರಿಗೆ ಪ್ರತಿಯೊಂದು ಫೀಲ್ಡ್ ಅನ್ನು ಅಪ್‌ಡೇಟ್ ಮಾಡಬೇಕೆಂದು ನೀವು ಬಯಸುವುದಿಲ್ಲ.

2. Required<T>

Required<T> ಯುಟಿಲಿಟಿ ಟೈಪ್ T ಟೈಪ್‌ನ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಅಗತ್ಯ (required) ಮಾಡುತ್ತದೆ. ಇದು Partial<T> ನ ವಿರುದ್ಧವಾಗಿದೆ. ಐಚ್ಛಿಕ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊಂದಿರುವ ಟೈಪ್ ನಿಮ್ಮಲ್ಲಿದ್ದಾಗ ಮತ್ತು ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳು ಇರುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನೀವು ಬಯಸಿದಾಗ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.

ಸಿಂಟ್ಯಾಕ್ಸ್:

type Required<T> = { [P in keyof T]-?: T[P]; };

ಉದಾಹರಣೆ:

interface Config {
 apiKey?: string;
 apiUrl?: string;
}

type CompleteConfig = Required<Config>; // ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳು ಈಗ ಅಗತ್ಯವಾಗಿವೆ

const config: CompleteConfig = {
 apiKey: "your-api-key",
 apiUrl: "https://example.com/api",
};

ಬಳಕೆಯ ಸನ್ನಿವೇಶ: ಅಪ್ಲಿಕೇಶನ್ ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು ಎಲ್ಲಾ ಕಾನ್ಫಿಗರೇಶನ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಒದಗಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುವುದು. ಇದು ಕಾಣೆಯಾದ ಅಥವಾ ಅನಿರ್ದಿಷ್ಟ ಸೆಟ್ಟಿಂಗ್‌ಗಳಿಂದ ಉಂಟಾಗುವ ರನ್‌ಟೈಮ್ ದೋಷಗಳನ್ನು ತಡೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

3. Readonly<T>

Readonly<T> ಯುಟಿಲಿಟಿ ಟೈಪ್ T ಟೈಪ್‌ನ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ರೀಡ್-ಓನ್ಲಿ (readonly) ಮಾಡುತ್ತದೆ. ಇದು ಆಬ್ಜೆಕ್ಟ್ ರಚಿಸಿದ ನಂತರ ಅದರ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಆಕಸ್ಮಿಕವಾಗಿ ಮಾರ್ಪಡಿಸುವುದನ್ನು ತಡೆಯುತ್ತದೆ. ಇದು ಬದಲಾಗದಿರುವುದನ್ನು (immutability) ಉತ್ತೇಜಿಸುತ್ತದೆ ಮತ್ತು ನಿಮ್ಮ ಕೋಡ್‌ನ ಊಹೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.

ಸಿಂಟ್ಯಾಕ್ಸ್:

type Readonly<T> = { readonly [P in keyof T]: T[P]; };

ಉದಾಹರಣೆ:

interface Product {
 id: number;
 name: string;
 price: number;
}

type ImmutableProduct = Readonly<Product>; // ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳು ಈಗ ರೀಡ್-ಓನ್ಲಿ ಆಗಿವೆ

const product: ImmutableProduct = {
 id: 123,
 name: "Example Product",
 price: 25.99,
};

// product.price = 29.99; // ದೋಷ: 'price'ಗೆ ನಿಯೋಜಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಏಕೆಂದರೆ ಇದು ರೀಡ್-ಓನ್ಲಿ ಪ್ರಾಪರ್ಟಿಯಾಗಿದೆ.

ಬಳಕೆಯ ಸನ್ನಿವೇಶ: ಕಾನ್ಫಿಗರೇಶನ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಅಥವಾ ಡೇಟಾ ಟ್ರಾನ್ಸ್‌ಫರ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ (DTOs)ಂತಹ ಬದಲಾಗದ ಡೇಟಾ ರಚನೆಗಳನ್ನು ರಚಿಸುವುದು, ಇವುಗಳನ್ನು ರಚನೆಯ ನಂತರ ಮಾರ್ಪಡಿಸಬಾರದು. ಇದು ಫಂಕ್ಷನಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮಾದರಿಗಳಲ್ಲಿ ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ.

4. Pick<T, K extends keyof T>

Pick<T, K extends keyof T> ಯುಟಿಲಿಟಿ ಟೈಪ್ T ಟೈಪ್‌ನಿಂದ K ಪ್ರಾಪರ್ಟಿಗಳ ಗುಂಪನ್ನು ಆರಿಸುವ ಮೂಲಕ ಹೊಸ ಟೈಪ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ. ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಟೈಪ್‌ನ ಪ್ರಾಪರ್ಟಿಗಳ ಉಪವಿಭಾಗ ಮಾತ್ರ ನಿಮಗೆ ಬೇಕಾದಾಗ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.

ಸಿಂಟ್ಯಾಕ್ಸ್:

type Pick<T, K extends keyof T> = { [P in K]: T[P]; };

ಉದಾಹರಣೆ:

interface Employee {
 id: number;
 name: string;
 department: string;
salary: number;
}

type EmployeeNameAndDepartment = Pick<Employee, "name" | "department">; // ಕೇವಲ name ಮತ್ತು department ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಿ

const employeeInfo: EmployeeNameAndDepartment = {
 name: "Bob",
 department: "Engineering",
};

ಬಳಕೆಯ ಸನ್ನಿವೇಶ: ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಾಚರಣೆಗೆ ಅಗತ್ಯವಾದ ಡೇಟಾವನ್ನು ಮಾತ್ರ ಒಳಗೊಂಡಿರುವ ವಿಶೇಷ ಡೇಟಾ ಟ್ರಾನ್ಸ್‌ಫರ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು (DTOs) ರಚಿಸುವುದು. ಇದು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಬಹುದು ಮತ್ತು ನೆಟ್‌ವರ್ಕ್ ಮೂಲಕ ರವಾನೆಯಾಗುವ ಡೇಟಾದ ಪ್ರಮಾಣವನ್ನು ಕಡಿಮೆ ಮಾಡಬಹುದು. ಕ್ಲೈಂಟ್‌ಗೆ ಬಳಕೆದಾರರ ವಿವರಗಳನ್ನು ಕಳುಹಿಸುವುದನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ ಆದರೆ ಸಂಬಳದಂತಹ ಸೂಕ್ಷ್ಮ ಮಾಹಿತಿಯನ್ನು ಹೊರತುಪಡಿಸಿ. ನೀವು ಕೇವಲ `id` ಮತ್ತು `name` ಕಳುಹಿಸಲು Pick ಅನ್ನು ಬಳಸಬಹುದು.

5. Omit<T, K extends keyof any>

Omit<T, K extends keyof any> ಯುಟಿಲಿಟಿ ಟೈಪ್ T ಟೈಪ್‌ನಿಂದ K ಪ್ರಾಪರ್ಟಿಗಳ ಗುಂಪನ್ನು ಬಿಟ್ಟುಬಿಡುವ ಮೂಲಕ ಹೊಸ ಟೈಪ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ. ಇದು Pick<T, K extends keyof T> ನ ವಿರುದ್ಧವಾಗಿದೆ ಮತ್ತು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಟೈಪ್‌ನಿಂದ ಕೆಲವು ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊರಗಿಡಲು ನೀವು ಬಯಸಿದಾಗ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.

ಸಿಂಟ್ಯಾಕ್ಸ್:

type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

ಉದಾಹರಣೆ:

interface Event {
 id: number;
 title: string;
description: string;
 date: Date;
 location: string;
}

type EventSummary = Omit<Event, "description" | "location">; // description ಮತ್ತು location ಅನ್ನು ಬಿಟ್ಟುಬಿಡಿ

const eventPreview: EventSummary = {
 id: 1,
 title: "Conference",
 date: new Date(),
};

ಬಳಕೆಯ ಸನ್ನಿವೇಶ: ನಿರ್ದಿಷ್ಟ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಡೇಟಾ ಮಾದರಿಗಳ ಸರಳೀಕೃತ ಆವೃತ್ತಿಗಳನ್ನು ರಚಿಸುವುದು, ಉದಾಹರಣೆಗೆ ಪೂರ್ಣ ವಿವರಣೆ ಮತ್ತು ಸ್ಥಳವನ್ನು ಸೇರಿಸದೆ ಈವೆಂಟ್‌ನ ಸಾರಾಂಶವನ್ನು ಪ್ರದರ್ಶಿಸುವುದು. ಕ್ಲೈಂಟ್‌ಗೆ ಡೇಟಾವನ್ನು ಕಳುಹಿಸುವ ಮೊದಲು ಸೂಕ್ಷ್ಮ ಕ್ಷೇತ್ರಗಳನ್ನು ತೆಗೆದುಹಾಕಲು ಇದನ್ನು ಬಳಸಬಹುದು.

6. Exclude<T, U>

Exclude<T, U> ಯುಟಿಲಿಟಿ ಟೈಪ್ T ಯಿಂದ U ಗೆ ನಿಯೋಜಿಸಬಹುದಾದ ಎಲ್ಲಾ ಟೈಪ್‌ಗಳನ್ನು ಹೊರತುಪಡಿಸಿ ಹೊಸ ಟೈಪ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ. ಯೂನಿಯನ್ ಟೈಪ್‌ನಿಂದ ಕೆಲವು ಟೈಪ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕಲು ನೀವು ಬಯಸಿದಾಗ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.

ಸಿಂಟ್ಯಾಕ್ಸ್:

type Exclude<T, U> = T extends U ? never : T;

ಉದಾಹರಣೆ:

type AllowedFileTypes = "image" | "video" | "audio" | "document";
type MediaFileTypes = "image" | "video" | "audio";

type DocumentFileTypes = Exclude<AllowedFileTypes, MediaFileTypes>; // "document"

const fileType: DocumentFileTypes = "document";

ಬಳಕೆಯ ಸನ್ನಿವೇಶ: ನಿರ್ದಿಷ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ಸಂಬಂಧಿಸದ ನಿರ್ದಿಷ್ಟ ಟೈಪ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕಲು ಯೂನಿಯನ್ ಟೈಪ್ ಅನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುವುದು. ಉದಾಹರಣೆಗೆ, ಅನುಮತಿಸಲಾದ ಫೈಲ್ ಪ್ರಕಾರಗಳ ಪಟ್ಟಿಯಿಂದ ನೀವು ಕೆಲವು ಫೈಲ್ ಪ್ರಕಾರಗಳನ್ನು ಹೊರಗಿಡಲು ಬಯಸಬಹುದು.

7. Extract<T, U>

Extract<T, U> ಯುಟಿಲಿಟಿ ಟೈಪ್ T ಯಿಂದ U ಗೆ ನಿಯೋಜಿಸಬಹುದಾದ ಎಲ್ಲಾ ಟೈಪ್‌ಗಳನ್ನು ಹೊರತೆಗೆದು ಹೊಸ ಟೈಪ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ. ಇದು Exclude<T, U> ನ ವಿರುದ್ಧವಾಗಿದೆ ಮತ್ತು ಯೂನಿಯನ್ ಟೈಪ್‌ನಿಂದ ನಿರ್ದಿಷ್ಟ ಟೈಪ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ನೀವು ಬಯಸಿದಾಗ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.

ಸಿಂಟ್ಯಾಕ್ಸ್:

type Extract<T, U> = T extends U ? T : never;

ಉದಾಹರಣೆ:

type InputTypes = string | number | boolean | null | undefined;
type PrimitiveTypes = string | number | boolean;

type NonNullablePrimitives = Extract<InputTypes, PrimitiveTypes>; // string | number | boolean

const value: NonNullablePrimitives = "hello";

ಬಳಕೆಯ ಸನ್ನಿವೇಶ: ಕೆಲವು ಮಾನದಂಡಗಳ ಆಧಾರದ ಮೇಲೆ ಯೂನಿಯನ್ ಟೈಪ್‌ನಿಂದ ನಿರ್ದಿಷ್ಟ ಟೈಪ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು. ಉದಾಹರಣೆಗೆ, ಪ್ರಿಮಿಟಿವ್ ಟೈಪ್ಸ್ ಮತ್ತು ಆಬ್ಜೆಕ್ಟ್ ಟೈಪ್ಸ್ ಎರಡನ್ನೂ ಒಳಗೊಂಡಿರುವ ಯೂನಿಯನ್ ಟೈಪ್‌ನಿಂದ ಎಲ್ಲಾ ಪ್ರಿಮಿಟಿವ್ ಟೈಪ್ಸ್ ಅನ್ನು ಹೊರತೆಗೆಯಲು ನೀವು ಬಯಸಬಹುದು.

8. NonNullable<T>

NonNullable<T> ಯುಟಿಲಿಟಿ ಟೈಪ್ T ಟೈಪ್‌ನಿಂದ null ಮತ್ತು undefined ಅನ್ನು ಹೊರತುಪಡಿಸಿ ಹೊಸ ಟೈಪ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ. ಒಂದು ಟೈಪ್ null ಅಥವಾ undefined ಆಗಿರಬಾರದು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನೀವು ಬಯಸಿದಾಗ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.

ಸಿಂಟ್ಯಾಕ್ಸ್:

type NonNullable<T> = T extends null | undefined ? never : T;

ಉದಾಹರಣೆ:

type MaybeString = string | null | undefined;

type DefinitelyString = NonNullable<MaybeString>; // string

const message: DefinitelyString = "Hello, world!";

ಬಳಕೆಯ ಸನ್ನಿವೇಶ: ಒಂದು ಮೌಲ್ಯದ ಮೇಲೆ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ನಿರ್ವಹಿಸುವ ಮೊದಲು ಅದು null ಅಥವಾ undefined ಅಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸುವುದು. ಇದು ಅನಿರೀಕ್ಷಿತ null ಅಥವಾ undefined ಮೌಲ್ಯಗಳಿಂದ ಉಂಟಾಗುವ ರನ್‌ಟೈಮ್ ದೋಷಗಳನ್ನು ತಡೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಬಳಕೆದಾರರ ವಿಳಾಸವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬೇಕಾದ ಸನ್ನಿವೇಶವನ್ನು ಪರಿಗಣಿಸಿ, ಮತ್ತು ಯಾವುದೇ ಕಾರ್ಯಾಚರಣೆಯ ಮೊದಲು ವಿಳಾಸವು null ಆಗಿರಬಾರದು ಎಂಬುದು ನಿರ್ಣಾಯಕವಾಗಿದೆ.

9. ReturnType<T extends (...args: any) => any>

ReturnType<T extends (...args: any) => any> ಯುಟಿಲಿಟಿ ಟೈಪ್ ಒಂದು ಫಂಕ್ಷನ್ ಟೈಪ್ T ನ ರಿಟರ್ನ್ ಟೈಪ್ ಅನ್ನು ಹೊರತೆಗೆಯುತ್ತದೆ. ಒಂದು ಫಂಕ್ಷನ್ ಹಿಂತಿರುಗಿಸುವ ಮೌಲ್ಯದ ಟೈಪ್ ಅನ್ನು ನೀವು ತಿಳಿಯಬೇಕಾದಾಗ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.

ಸಿಂಟ್ಯಾಕ್ಸ್:

type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;

ಉದಾಹರಣೆ:

function fetchData(url: string): Promise<{ data: any }> {
 return fetch(url).then(response => response.json());
}

type FetchDataReturnType = ReturnType<typeof fetchData>; // Promise<{ data: any }>

async function processData(data: FetchDataReturnType) {
 // ...
}

ಬಳಕೆಯ ಸನ್ನಿವೇಶ: ಫಂಕ್ಷನ್‌ನಿಂದ ಹಿಂತಿರುಗಿದ ಮೌಲ್ಯದ ಟೈಪ್ ಅನ್ನು ನಿರ್ಧರಿಸುವುದು, ವಿಶೇಷವಾಗಿ ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಾಚರಣೆಗಳು ಅಥವಾ ಸಂಕೀರ್ಣ ಫಂಕ್ಷನ್ ಸಿಗ್ನೇಚರ್‌ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ. ಹಿಂತಿರುಗಿದ ಮೌಲ್ಯವನ್ನು ನೀವು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಇದು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

10. Parameters<T extends (...args: any) => any>

Parameters<T extends (...args: any) => any> ಯುಟಿಲಿಟಿ ಟೈಪ್ ಒಂದು ಫಂಕ್ಷನ್ ಟೈಪ್ T ನ ಪ್ಯಾರಾಮೀಟರ್ ಟೈಪ್‌ಗಳನ್ನು ಟಪಲ್ (tuple) ಆಗಿ ಹೊರತೆಗೆಯುತ್ತದೆ. ಒಂದು ಫಂಕ್ಷನ್ ಸ್ವೀಕರಿಸುವ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳ ಟೈಪ್‌ಗಳನ್ನು ನೀವು ತಿಳಿಯಬೇಕಾದಾಗ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.

ಸಿಂಟ್ಯಾಕ್ಸ್:

type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;

ಉದಾಹರಣೆ:

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

type CreateUserParams = Parameters<typeof createUser>; // [string, number, string]

function logUser(...args: CreateUserParams) {
 console.log("Creating user with:", args);
}

ಬಳಕೆಯ ಸನ್ನಿವೇಶ: ಫಂಕ್ಷನ್ ಸ್ವೀಕರಿಸುವ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳ ಟೈಪ್‌ಗಳನ್ನು ನಿರ್ಧರಿಸುವುದು, ಇದು ವಿವಿಧ ಸಿಗ್ನೇಚರ್‌ಗಳ ಫಂಕ್ಷನ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಬೇಕಾದ ಜೆನೆರಿಕ್ ಫಂಕ್ಷನ್‌ಗಳು ಅಥವಾ ಡೆಕೋರೇಟರ್‌ಗಳನ್ನು ರಚಿಸಲು ಉಪಯುಕ್ತವಾಗಬಹುದು. ಡೈನಾಮಿಕ್ ಆಗಿ ಫಂಕ್ಷನ್‌ಗೆ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ರವಾನಿಸುವಾಗ ಟೈಪ್ ಸುರಕ್ಷತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಇದು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

11. ConstructorParameters<T extends abstract new (...args: any) => any>

ConstructorParameters<T extends abstract new (...args: any) => any> ಯುಟಿಲಿಟಿ ಟೈಪ್ ಒಂದು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಫಂಕ್ಷನ್ ಟೈಪ್ T ನ ಪ್ಯಾರಾಮೀಟರ್ ಟೈಪ್‌ಗಳನ್ನು ಟಪಲ್ ಆಗಿ ಹೊರತೆಗೆಯುತ್ತದೆ. ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಸ್ವೀಕರಿಸುವ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳ ಟೈಪ್‌ಗಳನ್ನು ನೀವು ತಿಳಿಯಬೇಕಾದಾಗ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.

ಸಿಂಟ್ಯಾಕ್ಸ್:

type ConstructorParameters<T extends abstract new (...args: any) => any> = T extends abstract new (...args: infer P) => any ? P : never;

ಉದಾಹರಣೆ:

class Logger {
 constructor(public prefix: string, public enabled: boolean) {}
 log(message: string) {
 if (this.enabled) {
 console.log(`${this.prefix}: ${message}`);
 }
 }
}

type LoggerConstructorParams = ConstructorParameters<typeof Logger>; // [string, boolean]

function createLogger(...args: LoggerConstructorParams) {
 return new Logger(...args);
}

ಬಳಕೆಯ ಸನ್ನಿವೇಶ: Parameters ಗೆ ಹೋಲುತ್ತದೆ, ಆದರೆ ನಿರ್ದಿಷ್ಟವಾಗಿ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಫಂಕ್ಷನ್‌ಗಳಿಗಾಗಿ. ವಿವಿಧ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಸಿಗ್ನೇಚರ್‌ಗಳೊಂದಿಗೆ ಕ್ಲಾಸ್‌ಗಳನ್ನು ಡೈನಾಮಿಕ್ ಆಗಿ ಇನ್‌ಸ್ಟಾಂಟಿಯೇಟ್ ಮಾಡಬೇಕಾದ ಫ್ಯಾಕ್ಟರಿಗಳು ಅಥವಾ ಡಿಪೆಂಡೆನ್ಸಿ ಇಂಜೆಕ್ಷನ್ ಸಿಸ್ಟಮ್‌ಗಳನ್ನು ರಚಿಸುವಾಗ ಇದು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

12. InstanceType<T extends abstract new (...args: any) => any>

InstanceType<T extends abstract new (...args: any) => any> ಯುಟಿಲಿಟಿ ಟೈಪ್ ಒಂದು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಫಂಕ್ಷನ್ ಟೈಪ್ T ನ ಇನ್‌ಸ್ಟೆನ್ಸ್ ಟೈಪ್ ಅನ್ನು ಹೊರತೆಗೆಯುತ್ತದೆ. ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ರಚಿಸುವ ಆಬ್ಜೆಕ್ಟ್‌ನ ಟೈಪ್ ಅನ್ನು ನೀವು ತಿಳಿಯಬೇಕಾದಾಗ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.

ಸಿಂಟ್ಯಾಕ್ಸ್:

type InstanceType<T extends abstract new (...args: any) => any> = T extends abstract new (...args: any) => infer R ? R : any;

ಉದಾಹರಣೆ:

class Greeter {
 greeting: string;
 constructor(message: string) {
 this.greeting = message;
 }
 greet() {
 return "Hello, " + this.greeting;
 }
}

type GreeterInstance = InstanceType<typeof Greeter>; // Greeter

const myGreeter: GreeterInstance = new Greeter("World");
console.log(myGreeter.greet());

ಬಳಕೆಯ ಸನ್ನಿವೇಶ: ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನಿಂದ ರಚಿಸಲಾದ ಆಬ್ಜೆಕ್ಟ್‌ನ ಟೈಪ್ ಅನ್ನು ನಿರ್ಧರಿಸುವುದು, ಇದು ಇನ್ಹೆರಿಟೆನ್ಸ್ ಅಥವಾ ಪಾಲಿಮಾರ್ಫಿಸಂನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಉಪಯುಕ್ತವಾಗಿದೆ. ಇದು ಕ್ಲಾಸ್‌ನ ಇನ್‌ಸ್ಟೆನ್ಸ್‌ಗೆ ಉಲ್ಲೇಖಿಸಲು ಟೈಪ್-ಸುರಕ್ಷಿತ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ.

13. Record<K extends keyof any, T>

Record<K extends keyof any, T> ಯುಟಿಲಿಟಿ ಟೈಪ್ ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಟೈಪ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತದೆ, ಅದರ ಪ್ರಾಪರ್ಟಿ ಕೀಗಳು K ಆಗಿರುತ್ತವೆ ಮತ್ತು ಅದರ ಪ್ರಾಪರ್ಟಿ ಮೌಲ್ಯಗಳು T ಆಗಿರುತ್ತವೆ. ಕೀಗಳನ್ನು ಮುಂಚಿತವಾಗಿ ತಿಳಿದಿರುವ ನಿಘಂಟಿನಂತಹ (dictionary-like) ಟೈಪ್‌ಗಳನ್ನು ರಚಿಸಲು ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.

ಸಿಂಟ್ಯಾಕ್ಸ್:

type Record<K extends keyof any, T> = { [P in K]: T; };

ಉದಾಹರಣೆ:

type CountryCode = "US" | "CA" | "GB" | "DE";

type CurrencyMap = Record<CountryCode, string>; // { US: string; CA: string; GB: string; DE: string; }

const currencies: CurrencyMap = {
 US: "USD",
 CA: "CAD",
 GB: "GBP",
 DE: "EUR",
};

ಬಳಕೆಯ ಸನ್ನಿವೇಶ: ನಿಘಂಟಿನಂತಹ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸುವುದು, ಅಲ್ಲಿ ನೀವು ನಿಗದಿತ ಕೀಗಳ ಗುಂಪನ್ನು ಹೊಂದಿರುತ್ತೀರಿ ಮತ್ತು ಎಲ್ಲಾ ಕೀಗಳು ನಿರ್ದಿಷ್ಟ ಟೈಪ್‌ನ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಬಯಸುತ್ತೀರಿ. ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ಗಳು, ಡೇಟಾ ಮ್ಯಾಪಿಂಗ್‌ಗಳು, ಅಥವಾ ಲುಕಪ್ ಟೇಬಲ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಇದು ಸಾಮಾನ್ಯವಾಗಿದೆ.

ಕಸ್ಟಮ್ ಯುಟಿಲಿಟಿ ಟೈಪ್ಸ್

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಅಂತರ್ನಿರ್ಮಿತ ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳು ಶಕ್ತಿಯುತವಾಗಿದ್ದರೂ, ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಲ್ಲಿನ ನಿರ್ದಿಷ್ಟ ಅಗತ್ಯಗಳನ್ನು ಪರಿಹರಿಸಲು ನೀವು ನಿಮ್ಮದೇ ಆದ ಕಸ್ಟಮ್ ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳನ್ನು ಸಹ ರಚಿಸಬಹುದು. ಇದು ಸಂಕೀರ್ಣ ಟೈಪ್ ಪರಿವರ್ತನೆಗಳನ್ನು ಎನ್‌ಕ್ಯಾಪ್ಸುಲೇಟ್ ಮಾಡಲು ಮತ್ತು ನಿಮ್ಮ ಕೋಡ್‌ಬೇಸ್‌ನಾದ್ಯಂತ ಅವುಗಳನ್ನು ಮರುಬಳಕೆ ಮಾಡಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಉದಾಹರಣೆ:

// ನಿರ್ದಿಷ್ಟ ಟೈಪ್ ಹೊಂದಿರುವ ಆಬ್ಜೆಕ್ಟ್‌ನ ಕೀಗಳನ್ನು ಪಡೆಯಲು ಯುಟಿಲಿಟಿ ಟೈಪ್
type KeysOfType<T, U> = { [K in keyof T]: T[K] extends U ? K : never }[keyof T];

interface Person {
 name: string;
 age: number;
 address: string;
 phoneNumber: number;
}

type StringKeys = KeysOfType<Person, string>; // "name" | "address"

ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳನ್ನು ಬಳಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ತೀರ್ಮಾನ

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳು ಶಕ್ತಿಯುತ ಸಾಧನಗಳಾಗಿದ್ದು, ಇವು ನಿಮ್ಮ ಕೋಡ್‌ನ ಟೈಪ್ ಸುರಕ್ಷತೆ, ಮರುಬಳಕೆ, ಮತ್ತು ನಿರ್ವಹಣೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಸುಧಾರಿಸಬಹುದು. ಈ ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ಹೆಚ್ಚು ದೃಢವಾದ ಮತ್ತು ಅಭಿವ್ಯಕ್ತ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಬರೆಯಬಹುದು. ಈ ಮಾರ್ಗದರ್ಶಿ ಅತ್ಯಂತ ಅಗತ್ಯವಾದ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿದೆ, ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಲ್ಲಿ ಅವುಗಳನ್ನು ಸೇರಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡಲು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು ಮತ್ತು ಕ್ರಿಯಾತ್ಮಕ ಒಳನೋಟಗಳನ್ನು ಒದಗಿಸಿದೆ.

ಈ ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳೊಂದಿಗೆ ಪ್ರಯೋಗ ಮಾಡಲು ಮತ್ತು ನಿಮ್ಮ ಸ್ವಂತ ಕೋಡ್‌ನಲ್ಲಿನ ನಿರ್ದಿಷ್ಟ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ಅವುಗಳನ್ನು ಹೇಗೆ ಬಳಸಬಹುದು ಎಂಬುದನ್ನು ಅನ್ವೇಷಿಸಲು ಮರೆಯದಿರಿ. ನೀವು ಅವುಗಳೊಂದಿಗೆ ಹೆಚ್ಚು ಪರಿಚಿತರಾದಂತೆ, ನೀವು ಕ್ಲೀನರ್, ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಲ್ಲ, ಮತ್ತು ಹೆಚ್ಚು ಟೈಪ್-ಸುರಕ್ಷಿತ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ರಚಿಸಲು ಅವುಗಳನ್ನು ಹೆಚ್ಚು ಹೆಚ್ಚು ಬಳಸುತ್ತೀರಿ. ನೀವು ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು, ಸರ್ವರ್-ಸೈಡ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು, ಅಥವಾ ಇವೆರಡರ ನಡುವೆ ಏನನ್ನಾದರೂ ನಿರ್ಮಿಸುತ್ತಿದ್ದರೂ, ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳು ನಿಮ್ಮ ಅಭಿವೃದ್ಧಿ ಕೆಲಸದ ಹರಿವು ಮತ್ತು ನಿಮ್ಮ ಕೋಡ್‌ನ ಗುಣಮಟ್ಟವನ್ನು ಸುಧಾರಿಸಲು ಮೌಲ್ಯಯುತವಾದ ಸಾಧನಗಳ ಗುಂಪನ್ನು ಒದಗಿಸುತ್ತವೆ. ಈ ಅಂತರ್ನಿರ್ಮಿತ ಟೈಪ್ ಮ್ಯಾನಿಪುಲೇಷನ್ ಪರಿಕರಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಸಂಪೂರ್ಣ ಸಾಮರ್ಥ್ಯವನ್ನು ಅನ್ಲಾಕ್ ಮಾಡಬಹುದು ಮತ್ತು ಅಭಿವ್ಯಕ್ತ ಮತ್ತು ದೃಢವಾದ ಕೋಡ್ ಅನ್ನು ಬರೆಯಬಹುದು.