---
createdAt: 2024-12-02
updatedAt: 2025-06-29
title: t फ़ंक्शन दस्तावेज़ीकरण | hono-intlayer
description: देखें कि hono-intlayer पैकेज के लिए t फ़ंक्शन का उपयोग कैसे करें
keywords:
  - t
  - अनुवाद
  - Intlayer
  - अंतर्राष्ट्रीयकरण
  - दस्तावेज़ीकरण
  - Hono
  - JavaScript
slugs:
  - doc
  - packages
  - hono-intlayer
  - t
history:
  - version: 5.5.10
    date: 2025-06-29
    changes: इतिहास प्रारंभ करें
---

# दस्तावेज़ीकरण: `hono-intlayer` में `t` फ़ंक्शन

`hono-intlayer` पैकेज में `t` फ़ंक्शन आपके Hono एप्लिकेशन में स्थानीयकृत प्रतिक्रियाएँ प्रदान करने के लिए मुख्य उपयोगिता है। यह उपयोगकर्ता की पसंदीदा भाषा के आधार पर गतिशील रूप से सामग्री का चयन करके अंतर्राष्ट्रीयकरण (i18n) को सरल बनाता है।

---

## अवलोकन

`t` फ़ंक्शन का उपयोग भाषाओं के दिए गए सेट के लिए अनुवादों को परिभाषित करने और प्राप्त करने के लिए किया जाता है। यह क्लाइंट की अनुरोध सेटिंग्स, जैसे कि `Accept-Language` हेडर के आधार पर वापस करने के लिए उपयुक्त भाषा स्वचालित रूप से निर्धारित करता है। यदि पसंदीदा भाषा अनुपलब्ध है, तो यह आपके कॉन्फ़िगरेशन में निर्दिष्ट डिफ़ॉल्ट लोकेल पर वापस आ जाता है।

---

## मुख्य विशेषताएं

- **गतिशील स्थानीयकरण**: क्लाइंट के लिए स्वचालित रूप से सबसे उपयुक्त अनुवाद का चयन करता है।
- **डिफ़ॉल्ट लोकेल पर वापस जाना**: यदि क्लाइंट की पसंदीदा भाषा उपलब्ध नहीं है, तो डिफ़ॉल्ट लोकेल पर वापस आ जाता है, जिससे उपयोगकर्ता अनुभव में निरंतरता बनी रहती है।
- **हल्का और तेज़**: उच्च-प्रदर्शन अनुप्रयोगों के लिए डिज़ाइन किया गया है, जो न्यूनतम ओवरहेड सुनिश्चित करता है।
- **सख्त मोड समर्थन**: विश्वसनीय व्यवहार के लिए घोषित लोकेल के सख्त पालन को लागू करता है।

---

## फ़ंक्शन सिग्नेचर

```typescript
t(translations: Record<string, string>): string;
```

### पैरामीटर

- `translations`: एक ऑब्जेक्ट जहाँ कुंजियाँ लोकेल कोड (जैसे, `en`, `fr`, `hi`) हैं और मान संबंधित अनुवादित स्ट्रिंग हैं।

### रिटर्न

- क्लाइंट की पसंदीदा भाषा में सामग्री का प्रतिनिधित्व करने वाली एक स्ट्रिंग।

---

## अंतर्राष्ट्रीयकरण अनुरोध हैंडलर लोड करना

यह सुनिश्चित करने के लिए कि `hono-intlayer` द्वारा प्रदान की गई अंतर्राष्ट्रीयकरण कार्यक्षमता सही ढंग से काम करती है, आपको अपने Hono एप्लिकेशन की शुरुआत में अंतर्राष्ट्रीयकरण मिडलवेयर लोड करना **चाहिए**। यह `t` फ़ंक्शन को सक्षम करता है और लोकेल डिटेक्शन और अनुवाद की उचित हैंडलिंग सुनिश्चित करता है।

`app.use("*", intlayer())` मिडलवेयर को अपने एप्लिकेशन में **किसी भी रूट से पहले** रखें ताकि यह सुनिश्चित हो सके कि सभी रूट अंतर्राष्ट्रीयकरण से लाभान्वित हों:

```typescript {6} fileName="src/index.ts" codeFormat="typescript"
import { Hono } from "hono";
import { intlayer } from "hono-intlayer";

const app = new Hono();

// अंतर्राष्ट्रीयकरण अनुरोध हैंडलर लोड करें
app.use("*", intlayer());

// मिडलवेयर लोड करने के बाद अपने रूट परिभाषित करें
app.get("/", (c) => {
  return c.text(
    t({
      en: "Hello, World!",
      fr: "Bonjour le monde!",
      es: "¡Hola, Mundo!",
      hi: "नमस्ते दुनिया!",
    })
  );
});
```

```javascript {6} fileName="src/index.mjs" codeFormat="esm"
import { Hono } from "hono";
import { intlayer } from "hono-intlayer";

const app = new Hono();

// अंतर्राष्ट्रीयकरण अनुरोध हैंडलर लोड करें
app.use("*", intlayer());

// मिडलवेयर लोड करने के बाद अपने रूट परिभाषित करें
app.get("/", (c) => {
  return c.text(
    t({
      en: "Hello, World!",
      fr: "Bonjour le monde!",
      es: "¡Hola, Mundo!",
      hi: "नमस्ते दुनिया!",
    })
  );
});
```

```javascript {6} fileName="src/index.cjs" codeFormat="commonjs"
const { Hono } = require("hono");
const { intlayer, t } = require("hono-intlayer");

const app = new Hono();

// अंतर्राष्ट्रीयकरण अनुरोध हैंडलर लोड करें
app.use("*", intlayer());

// मिडलवेयर लोड करने के बाद अपने रूट परिभाषित करें
app.get("/", (c) => {
  return c.text(
    t({
      en: "Hello, World!",
      fr: "Bonjour le monde!",
      es: "¡Hola, Mundo!",
      hi: "नमस्ते दुनिया!",
    })
  );
});
```

### यह आवश्यक क्यों है

- **लोकेल डिटेक्शन**: `intlayer` मिडलवेयर हेडर, कुकीज़ या अन्य कॉन्फ़िगर किए गए तरीकों के आधार पर उपयोगकर्ता के पसंदीदा लोकेल का पता लगाने के लिए आने वाले अनुरोधों को संसाधित करता है।
- **अनुवाद संदर्भ**: `t` फ़ंक्शन को सही ढंग से संचालित करने के लिए आवश्यक संदर्भ सेट करता है, यह सुनिश्चित करता है कि अनुवाद सही भाषा में लौटाए जाएं।
- **त्रुटि निवारण**: इस मिडलवेयर के बिना, `t` फ़ंक्शन का उपयोग करने से रनटाइम त्रुटियां होंगी क्योंकि आवश्यक लोकेल जानकारी उपलब्ध नहीं होगी।

---

## उपयोग के उदाहरण

### बुनियादी उदाहरण

विभिन्न भाषाओं में स्थानीयकृत सामग्री परोसें:

```typescript fileName="src/index.ts" codeFormat="typescript"
app.get("/", (c) => {
  return c.text(
    t({
      en: "Welcome!",
      fr: "Bienvenue!",
      hi: "आपका स्वागत है!",
    })
  );
});
```

**क्लाइंट अनुरोध:**

- `Accept-Language: fr` वाला क्लाइंट `Bienvenue!` प्राप्त करेगा।
- `Accept-Language: hi` वाला क्लाइंट `आपका स्वागत है!` प्राप्त करेगा।
- `Accept-Language: de` वाला क्लाइंट `Welcome!` (डिफ़ॉल्ट लोकेल) प्राप्त करेगा।

### त्रुटियों को संभालना

कई भाषाओं में त्रुटि संदेश प्रदान करें:

```typescript fileName="src/index.ts" codeFormat="typescript"
app.get("/error", (c) => {
  return c.text(
    t({
      en: "An unexpected error occurred.",
      fr: "Une erreur inattendue s'est produite.",
      hi: "एक अप्रत्याशित त्रुटि हुई।",
    }),
    500
  );
});
```

---

### लोकेल वेरिएंट का उपयोग करना

लोकेल-विशिष्ट वेरिएंट के लिए अनुवाद निर्दिष्ट करें:

```typescript fileName="src/index.ts" codeFormat="typescript"
app.get("/greet", (c) => {
  return c.text(
    t({
      en: "Hello!",
      "en-GB": "Hello, mate!",
      fr: "Bonjour!",
      hi: "नमस्ते!",
    })
  );
});
```

---

## उन्नत विषय

### फ़ालबैक तंत्र

यदि कोई पसंदीदा लोकेल अनुपलब्ध है, तो `t` फ़ंक्शन कॉन्फ़िगरेशन में परिभाषित डिफ़ॉल्ट लोकेल पर वापस आ जाएगा:

```typescript {5-6} fileName="intlayer.config.ts" codeFormat="typescript"
import { Locales, type IntlayerConfig } from "intlayer";

const config = {
  internationalization: {
    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.HINDI],
    defaultLocale: Locales.ENGLISH,
  },
} satisfies IntlayerConfig;

export default config;
```

---

### सख्त मोड प्रवर्तन

घोषित लोकेल के सख्त पालन को लागू करने के लिए `t` फ़ंक्शन को कॉन्फ़िगर करें:

| मोड         | व्यवहार                                                                                           |
| ----------- | ------------------------------------------------------------------------------------------------- |
| `strict`    | सभी घोषित लोकेल के लिए अनुवाद प्रदान किए जाने चाहिए। अनुपलब्ध लोकेल त्रुटि उत्पन्न करेंगे।        |
| `inclusive` | घोषित लोकेल में अनुवाद होना चाहिए। अनुपलब्ध होने पर चेतावनी दी जाएगी लेकिन स्वीकार कर लिया जाएगा। |
| `loose`     | कोई भी मौजूदा लोकेल स्वीकार किया जाता है, भले ही वह घोषित न हो।                                   |

---

### TypeScript एकीकरण

TypeScript के साथ उपयोग किए जाने पर `t` फ़ंक्शन टाइप-सेफ होता है। टाइप-सेफ अनुवाद ऑब्जेक्ट परिभाषित करें:

```typescript fileName="src/index.ts" codeFormat="typescript"
import { type LanguageContent } from "hono-intlayer";

const translations: LanguageContent<string> = {
  en: "Good morning!",
  fr: "Bonjour!",
  hi: "शुभ प्रभात!",
};

app.get("/morning", (c) => {
  return c.text(t(translations));
});
```

---

### सामान्य त्रुटियाँ और समस्या निवारण

| समस्या                         | कारण                                | समाधान                                                                 |
| ------------------------------ | ----------------------------------- | ---------------------------------------------------------------------- |
| `t` फ़ंक्शन काम नहीं कर रहा है | मिडलवेयर लोड नहीं हुआ है            | सुनिश्चित करें कि रूट से पहले `app.use("*", intlayer())` जोड़ा गया है। |
| अनुवाद गायब होने की त्रुटि     | सभी लोकेल के बिना सख्त मोड सक्षम है | सभी आवश्यक अनुवाद प्रदान करें।                                         |

---

## निष्कर्ष

`t` फ़ंक्शन बैकएंड अंतर्राष्ट्रीयकरण के लिए एक शक्तिशाली उपकरण है। इसका प्रभावी ढंग से उपयोग करके, आप वैश्विक दर्शकों के लिए अधिक समावेशी और उपयोगकर्ता के अनुकूल एप्लिकेशन बना सकते हैं। उन्नत उपयोग और विस्तृत कॉन्फ़िगरेशन विकल्पों के लिए, [दस्तावेज़ीकरण](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/configuration.md) देखें।
