ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಡಿಕ್ಲರೇಶನ್ ಮರ್ಜಿಂಗ್: ಇಂಟರ್ಫೇಸ್ ವಿಸ್ತರಣಾ ಪಾಂಡಿತ್ಯ

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

ಡಿಕ್ಲರೇಶನ್ ಮರ್ಜಿಂಗ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಡಿಕ್ಲರೇಶನ್ ಮರ್ಜಿಂಗ್, ಕಂಪೈಲರ್ ಒಂದೇ ಸ್ಕೋಪ್‌ನಲ್ಲಿ ಒಂದೇ ಹೆಸರಿನೊಂದಿಗೆ ಅನೇಕ ಡಿಕ್ಲರೇಶನ್‌ಗಳನ್ನು ಎದುರಿಸಿದಾಗ ಸಂಭವಿಸುತ್ತದೆ. ನಂತರ ಕಂಪೈಲರ್ ಈ ಡಿಕ್ಲರೇಶನ್‌ಗಳನ್ನು ಒಂದೇ ವ್ಯಾಖ್ಯಾನಕ್ಕೆ ವಿಲೀನಗೊಳಿಸುತ್ತದೆ. ಈ ನಡವಳಿಕೆಯು ಇಂಟರ್ಫೇಸ್‌ಗಳು, ನೇಮ್‌ಸ್ಪೇಸ್‌ಗಳು, ಕ್ಲಾಸ್‌ಗಳು, ಮತ್ತು ಎನಮ್‌ಗಳಿಗೆ ಅನ್ವಯಿಸುತ್ತದೆ. ಇಂಟರ್ಫೇಸ್‌ಗಳನ್ನು ವಿಲೀನಗೊಳಿಸುವಾಗ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರತಿಯೊಂದು ಇಂಟರ್ಫೇಸ್ ಡಿಕ್ಲರೇಶನ್‌ನ ಸದಸ್ಯರನ್ನು ಒಂದೇ ಇಂಟರ್ಫೇಸ್ ಆಗಿ ಸಂಯೋಜಿಸುತ್ತದೆ.

ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳು

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

ಡಿಕ್ಲರೇಶನ್ ಮರ್ಜಿಂಗ್‌ನೊಂದಿಗೆ ಇಂಟರ್ಫೇಸ್ ವಿಸ್ತರಣೆ

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

ಮೂಲಭೂತ ಉದಾಹರಣೆ

ಒಂದು ಸರಳ ಉದಾಹರಣೆಯೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸೋಣ. ನಿಮ್ಮಲ್ಲಿ Person ಎಂಬ ಇಂಟರ್ಫೇಸ್ ಇದೆ ಎಂದು ಭಾವಿಸೋಣ:

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

ಈಗ, ನೀವು ಮೂಲ ಡಿಕ್ಲರೇಶನ್ ಅನ್ನು ಬದಲಾಯಿಸದೆ Person ಇಂಟರ್ಫೇಸ್‌ಗೆ ಐಚ್ಛಿಕ email ಪ್ರಾಪರ್ಟಿಯನ್ನು ಸೇರಿಸಲು ಬಯಸುತ್ತೀರಿ. ಡಿಕ್ಲರೇಶನ್ ಮರ್ಜಿಂಗ್ ಬಳಸಿ ಇದನ್ನು ಸಾಧಿಸಬಹುದು:

interface Person {
  email?: string;
}

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಈ ಎರಡು ಡಿಕ್ಲರೇಶನ್‌ಗಳನ್ನು ಒಂದೇ Person ಇಂಟರ್ಫೇಸ್ ಆಗಿ ವಿಲೀನಗೊಳಿಸುತ್ತದೆ:

interface Person {
  name: string;
  age: number;
  email?: string;
}

ಈಗ, ನೀವು ಹೊಸ email ಪ್ರಾಪರ್ಟಿಯೊಂದಿಗೆ ವಿಸ್ತರಿಸಿದ Person ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಬಳಸಬಹುದು:

const person: Person = {
  name: "Alice",
  age: 30,
  email: "alice@example.com",
};

const anotherPerson: Person = {
  name: "Bob",
  age: 25,
};

console.log(person.email); // Output: alice@example.com
console.log(anotherPerson.email); // Output: undefined

ಬಾಹ್ಯ ಲೈಬ್ರರಿಗಳಿಂದ ಇಂಟರ್ಫೇಸ್‌ಗಳನ್ನು ವಿಸ್ತರಿಸುವುದು

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

// ಬಾಹ್ಯ ಲೈಬ್ರರಿಯಿಂದ
interface Product {
  id: number;
  name: string;
  price: number;
}

ನೀವು Product ಇಂಟರ್ಫೇಸ್‌ಗೆ description ಪ್ರಾಪರ್ಟಿಯನ್ನು ಸೇರಿಸಲು ಬಯಸುತ್ತೀರಿ. ಅದೇ ಹೆಸರಿನೊಂದಿಗೆ ಹೊಸ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಡಿಕ್ಲೇರ್ ಮಾಡುವ ಮೂಲಕ ನೀವು ಇದನ್ನು ಮಾಡಬಹುದು:

// ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿ
interface Product {
  description?: string;
}

ಈಗ, ನೀವು ಹೊಸ description ಪ್ರಾಪರ್ಟಿಯೊಂದಿಗೆ ವಿಸ್ತರಿಸಿದ Product ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಬಳಸಬಹುದು:

const product: Product = {
  id: 123,
  name: "Laptop",
  price: 1200,
  description: "A powerful laptop for professionals",
};

console.log(product.description); // Output: A powerful laptop for professionals

ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು ಮತ್ತು ಬಳಕೆಯ ಪ್ರಕರಣಗಳು

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

1. ರಿಕ್ವೆಸ್ಟ್ ಮತ್ತು ರೆಸ್ಪಾನ್ಸ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗೆ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಸೇರಿಸುವುದು

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

ಉದಾಹರಣೆ:

// Express.js
import express from 'express';

// Request ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ವಿಸ್ತರಿಸಿ
declare global {
  namespace Express {
    interface Request {
      userId?: string;
    }
  }
}

const app = express();

app.use((req, res, next) => {
  // ದೃಢೀಕರಣವನ್ನು ಅನುಕರಿಸಿ
  req.userId = "user123";
  next();
});

app.get('/', (req, res) => {
  const userId = req.userId;
  res.send(`Hello, user ${userId}!`);
});

app.listen(3000, () => {
  console.log('Server listening on port 3000');
});

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು userId ಪ್ರಾಪರ್ಟಿಯನ್ನು ಸೇರಿಸಲು Express.Request ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ವಿಸ್ತರಿಸುತ್ತಿದ್ದೇವೆ. ಇದು ದೃಢೀಕರಣದ ಸಮಯದಲ್ಲಿ ರಿಕ್ವೆಸ್ಟ್ ಆಬ್ಜೆಕ್ಟ್‌ನಲ್ಲಿ ಬಳಕೆದಾರರ ಐಡಿಯನ್ನು ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ನಂತರದ ಮಿಡಲ್‌ವೇರ್ ಮತ್ತು ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳಲ್ಲಿ ಅದನ್ನು ಪ್ರವೇಶಿಸಲು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

2. ಕಾನ್ಫಿಗರೇಶನ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ವಿಸ್ತರಿಸುವುದು

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

ಉದಾಹರಣೆ:

// ಲೈಬ್ರರಿ ಕಾನ್ಫಿಗರೇಶನ್ ಇಂಟರ್ಫೇಸ್
interface Config {
  apiUrl: string;
  timeout: number;
}

// ಕಾನ್ಫಿಗರೇಶನ್ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ವಿಸ್ತರಿಸಿ
interface Config {
  debugMode?: boolean;
}

const defaultConfig: Config = {
  apiUrl: "https://api.example.com",
  timeout: 5000,
  debugMode: true,
};

// ಕಾನ್ಫಿಗರೇಶನ್ ಬಳಸುವ ಫಂಕ್ಷನ್
function fetchData(config: Config) {
  console.log(`Fetching data from ${config.apiUrl}`);
  console.log(`Timeout: ${config.timeout}ms`);
  if (config.debugMode) {
    console.log("Debug mode enabled");
  }
}

fetchData(defaultConfig);

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

3. ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕ್ಲಾಸ್‌ಗಳಿಗೆ ಕಸ್ಟಮ್ ಮೆಥಡ್‌ಗಳನ್ನು ಸೇರಿಸುವುದು (ಮಿಕ್ಸಿನ್‌ಗಳು)

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

ಉದಾಹರಣೆ:

// ಬೇಸ್ ಕ್ಲಾಸ್
class Logger {
  log(message: string) {
    console.log(`[LOG]: ${message}`);
  }
}

// ಮಿಕ್ಸಿನ್‌ಗಾಗಿ ಇಂಟರ್ಫೇಸ್
interface Timestamped {
  timestamp: Date;
  getTimestamp(): string;
}

// ಮಿಕ್ಸಿನ್ ಫಂಕ್ಷನ್
function Timestamped<T extends Constructor>(Base: T) {
  return class extends Base implements Timestamped {
    timestamp: Date = new Date();

    getTimestamp(): string {
      return this.timestamp.toISOString();
    }
  };
}

type Constructor = new (...args: any[]) => {};

// ಮಿಕ್ಸಿನ್ ಅನ್ವಯಿಸಿ
const TimestampedLogger = Timestamped(Logger);

// ಬಳಕೆ
const logger = new TimestampedLogger();
logger.log("Hello, world!");
console.log(logger.getTimestamp());

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು Timestamped ಎಂಬ ಮಿಕ್ಸಿನ್ ಅನ್ನು ರಚಿಸುತ್ತಿದ್ದೇವೆ, ಅದು timestamp ಪ್ರಾಪರ್ಟಿ ಮತ್ತು getTimestamp ಮೆಥಡ್ ಅನ್ನು ಯಾವುದೇ ಕ್ಲಾಸ್‌ಗೆ ಅನ್ವಯಿಸಿದಾಗ ಸೇರಿಸುತ್ತದೆ. ಇದು ಸರಳವಾದ ರೀತಿಯಲ್ಲಿ ಇಂಟರ್ಫೇಸ್ ಮರ್ಜಿಂಗ್ ಅನ್ನು ನೇರವಾಗಿ ಬಳಸದಿದ್ದರೂ, ವೃದ್ಧಿಗೊಂಡ ಕ್ಲಾಸ್‌ಗಳಿಗೆ ಇಂಟರ್ಫೇಸ್‌ಗಳು ಹೇಗೆ ಒಪ್ಪಂದವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ಇದು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

ಸಂಘರ್ಷ ಪರಿಹಾರ

ಇಂಟರ್ಫೇಸ್‌ಗಳನ್ನು ವಿಲೀನಗೊಳಿಸುವಾಗ, ಒಂದೇ ಹೆಸರಿನ ಸದಸ್ಯರ ನಡುವಿನ ಸಂಭಾವ್ಯ ಸಂಘರ್ಷಗಳ ಬಗ್ಗೆ ತಿಳಿದಿರುವುದು ಮುಖ್ಯ. ಈ ಸಂಘರ್ಷಗಳನ್ನು ಪರಿಹರಿಸಲು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ನಿರ್ದಿಷ್ಟ ನಿಯಮಗಳನ್ನು ಹೊಂದಿದೆ.

ಸಂಘರ್ಷದ ಟೈಪ್‌ಗಳು

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

ಉದಾಹರಣೆ:

interface A {
  x: number;
}

interface A {
  x: string; // ದೋಷ: ನಂತರದ ಪ್ರಾಪರ್ಟಿ ಡಿಕ್ಲರೇಶನ್‌ಗಳು ಒಂದೇ ಟೈಪ್ ಅನ್ನು ಹೊಂದಿರಬೇಕು.
}

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

interface A {
  x: number | string;
}

interface A {
  x: string | number;
}

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಎರಡೂ ಡಿಕ್ಲರೇಶನ್‌ಗಳು ಹೊಂದಾಣಿಕೆಯಾಗುತ್ತವೆ ಏಕೆಂದರೆ x ನ ಟೈಪ್ ಎರಡೂ ಇಂಟರ್ಫೇಸ್‌ಗಳಲ್ಲಿ number | string ಆಗಿದೆ.

ಫಂಕ್ಷನ್ ಓವರ್‌ಲೋಡ್‌ಗಳು

ಫಂಕ್ಷನ್ ಡಿಕ್ಲರೇಶನ್‌ಗಳೊಂದಿಗೆ ಇಂಟರ್ಫೇಸ್‌ಗಳನ್ನು ವಿಲೀನಗೊಳಿಸುವಾಗ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಫಂಕ್ಷನ್ ಓವರ್‌ಲೋಡ್‌ಗಳನ್ನು ಒಂದೇ ಓವರ್‌ಲೋಡ್‌ಗಳ ಸೆಟ್ ಆಗಿ ವಿಲೀನಗೊಳಿಸುತ್ತದೆ. ಕಂಪೈಲ್ ಸಮಯದಲ್ಲಿ ಸರಿಯಾದ ಓವರ್‌ಲೋಡ್ ಅನ್ನು ಬಳಸಲು ಕಂಪೈಲರ್ ಓವರ್‌ಲೋಡ್‌ಗಳ ಕ್ರಮವನ್ನು ಬಳಸುತ್ತದೆ.

ಉದಾಹರಣೆ:

interface Calculator {
  add(x: number, y: number): number;
}

interface Calculator {
  add(x: string, y: string): string;
}

const calculator: Calculator = {
  add(x: number | string, y: number | string): number | string {
    if (typeof x === 'number' && typeof y === 'number') {
      return x + y;
    } else if (typeof x === 'string' && typeof y === 'string') {
      return x + y;
    } else {
      throw new Error('Invalid arguments');
    }
  },
};

console.log(calculator.add(1, 2)); // Output: 3
console.log(calculator.add("hello", "world")); // Output: hello world

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು add ಮೆಥಡ್‌ಗಾಗಿ ವಿಭಿನ್ನ ಫಂಕ್ಷನ್ ಓವರ್‌ಲೋಡ್‌ಗಳೊಂದಿಗೆ ಎರಡು Calculator ಇಂಟರ್ಫೇಸ್‌ಗಳನ್ನು ವಿಲೀನಗೊಳಿಸುತ್ತಿದ್ದೇವೆ. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಈ ಓವರ್‌ಲೋಡ್‌ಗಳನ್ನು ಒಂದೇ ಓವರ್‌ಲೋಡ್‌ಗಳ ಸೆಟ್ ಆಗಿ ವಿಲೀನಗೊಳಿಸುತ್ತದೆ, ಇದು ನಮಗೆ ಸಂಖ್ಯೆಗಳು ಅಥವಾ ಸ್ಟ್ರಿಂಗ್‌ಗಳೊಂದಿಗೆ add ಮೆಥಡ್ ಅನ್ನು ಕರೆಯಲು ಅನುಮತಿಸುತ್ತದೆ.

ಇಂಟರ್ಫೇಸ್ ವಿಸ್ತರಣೆಗಾಗಿ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ನೀವು ಇಂಟರ್ಫೇಸ್ ವಿಸ್ತರಣೆಯನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸುತ್ತಿರುವಿರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು, ಈ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನುಸರಿಸಿ:

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

ಮುಂದುವರಿದ ಸನ್ನಿವೇಶಗಳು

ಮೂಲಭೂತ ಉದಾಹರಣೆಗಳ ಹೊರತಾಗಿ, ಡಿಕ್ಲರೇಶನ್ ಮರ್ಜಿಂಗ್ ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಶಕ್ತಿಯುತ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ನೀಡುತ್ತದೆ.

ಜೆನೆರಿಕ್ ಇಂಟರ್ಫೇಸ್‌ಗಳನ್ನು ವಿಸ್ತರಿಸುವುದು

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

interface DataStore<T> {
  data: T[];
  add(item: T): void;
}

interface DataStore<T> {
  find(predicate: (item: T) => boolean): T | undefined;
}

class MyDataStore<T> implements DataStore<T> {
  data: T[] = [];

  add(item: T): void {
    this.data.push(item);
  }

  find(predicate: (item: T) => boolean): T | undefined {
    return this.data.find(predicate);
  }
}

const numberStore = new MyDataStore<number>();
numberStore.add(1);
numberStore.add(2);
const foundNumber = numberStore.find(n => n > 1);
console.log(foundNumber); // Output: 2

ಷರತ್ತುಬದ್ಧ ಇಂಟರ್ಫೇಸ್ ಮರ್ಜಿಂಗ್

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

interface BaseConfig {
  apiUrl: string;
}

type FeatureFlags = {
  enableNewFeature: boolean;
};

// ಷರತ್ತುಬದ್ಧ ಇಂಟರ್ಫೇಸ್ ಮರ್ಜಿಂಗ್
interface BaseConfig {
  featureFlags?: FeatureFlags;
}

interface EnhancedConfig extends BaseConfig {
  featureFlags: FeatureFlags;
}

function processConfig(config: BaseConfig) {
  console.log(config.apiUrl);
  if (config.featureFlags?.enableNewFeature) {
    console.log("New feature is enabled");
  }
}

const configWithFlags: EnhancedConfig = {
  apiUrl: "https://example.com",
  featureFlags: {
    enableNewFeature: true,
  },
};

processConfig(configWithFlags);

ಡಿಕ್ಲರೇಶನ್ ಮರ್ಜಿಂಗ್ ಬಳಸುವ ಪ್ರಯೋಜನಗಳು

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

ಡಿಕ್ಲರೇಶನ್ ಮರ್ಜಿಂಗ್‌ನ ಮಿತಿಗಳು

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

ತೀರ್ಮಾನ

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