怎么實現自動生成typescript類型聲明工具

本篇內容主要講解“怎么實現自動生成typescript類型聲明工具”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“怎么實現自動生成typescript類型聲明工具”吧!

在TypeScript 項目中，我們經常需要使用聲明一系列的ts類型。然而，手動寫的效率實在太低，編寫一個自動生成ts類型的工具可以解放生產力。 實現一個工具將 JSON 數據轉換為 TypeScript 類型定義，從而讓 TypeScript 項目更高效的開發。

一、實現的功能

• 將 JSON 數據轉換為 TypeScript 類型定義。

• 支持嵌套的復雜類型，如數組和對象。

• 支持自定義類型名稱和命名空間。

• 支持將轉換后的 TypeScript 類型定義保存為文件。

二、工具使用方法

1.在線playground使用：在線json轉ts類型聲明

2.已經發布到npm：my-json-to-ts - npm (npmjs.com)

運行效果如下動圖：

安裝工具：

npm install -g my-json-to-ts

運行工具：

my-json-to-ts input.json output.ts

其中 input.json 是要轉換的 JSON 文件路徑，output.ts 是轉換后的 TypeScript 文件路徑。

--name 類型名稱    # 指定轉換后的類型名稱，默認為 JsonType
--namespace 命名空間 # 指定轉換后的命名空間，默認為無
--no-file          # 不將轉換后的 TypeScript 類型定義保存為文件

三、實現思路

• 讀取輸入的 JSON 文件，解析成 JSON 對象。

• 遍歷 JSON 對象，根據不同的類型生成對應的 TypeScript 類型定義字符串。

• 如果指定了類型名稱和命名空間，則在生成的 TypeScript 類型定義字符串前面添加對應的聲明。

• 如果指定了保存文件，則將生成的 TypeScript 類型定義字符串寫入文件。

四、使用示例

以下是將JSON 數據和轉換后的 TypeScript 類型定義示例：

簡單的JSON 數據

{
  "name": "John",
  "age": 30,
  "address": {
    "city": "New York",
    "state": "NY"
  },
  "hobbies": [
    "reading",
    "traveling"
  ]
}

輸出對應簡單的類型定義

interface JsonType {
  name: string;
  age: number;
  address: {
    city: string;
    state: string;
  };
  hobbies: string[];
}

復雜的JSON 數據

{
  "name": "John",
  "age": 30,
  "address": {
    "city": "New York",
    "state": "NY",
    "postalCode": 10001
  },
  "friends": [
    {
      "name": "Jane",
      "age": 28,
      "address": {
        "city": "Los Angeles",
        "state": "CA"
      }
    },
    {
      "name": "Bob",
      "age": 35,
      "address": {
        "city": "Chicago",
        "state": "IL"
      }
    }
  ],
  "hobbies": [
    "reading",
    "traveling",
    {
      "name": "swimming",
      "location": "pool"
    }
  ]
}

輸出對應復雜類型定義

interface JsonType {
  name: string;
  age: number;
  address: {
    city: string;
    state: string;
    postalCode: number;
  };
  friends: {
    name: string;
    age: number;
    address: {
      city: string;
      state: string;
    };
  }[];
  hobbies: (string | {
    name: string;
    location: string;
  })[];
}

五、具體實現代碼

首先引入兩個 Node.js 模塊：fs-extra 和 commander。fs-extra 是一個簡化了 Node.js 文件系統模塊的封裝，而 commander 是一個命令行工具的庫，可以方便地解析命令行參數。

接下來定義一個函數 jsonToTs，用于將 JSON 數據轉換為 TypeScript 類型定義字符串。該函數采用遞歸的方式遍歷 JSON 數據，生成對應的 TypeScript 類型定義。如果 JSON 數據是數組，則遞歸處理其中的每個元素；如果是對象，則遞歸處理其中的每個屬性。最終，該函數返回一個 TypeScript 類型定義字符串。

然后定義了兩個異步函數，readJson 和 writeTs，分別用于讀取 JSON 文件和將 TypeScript 類型定義字符串寫入文件。

最后定義一個名為 jsonToTsFile 的函數，該函數接收命令行參數并將其傳遞給 jsonToTs 函數，然后將生成的 TypeScript 類型定義字符串保存到文件中。如果命令行參數中指定了不保存文件，則該函數將直接將 TypeScript 類型定義字符串輸出到控制臺。

  const fs = require('fs-extra');
  const commander = require('commander');
  /**
   * 將 JSON 數據轉換為 TypeScript 類型定義
   * @param {Object} object - 要轉換的 JSON 對象
   * @param {string} [name=JsonType] - 轉換后的類型名稱
   * @param {string} [namespace] - 轉換后的命名空間
   * @returns {string} - 轉換后的 TypeScript 類型定義字符串
   */
  function jsonToTs(object, name = 'JsonType', namespace) {
      const getType = value => {
          let typeRes = ``;
          if (Array.isArray(value)) {
              value.forEach(item => {
                  let subType = getType(item);
                  if (typeRes.split('|').indexOf(subType) < 0) {
                      typeRes += subType
                      typeRes += "|"
                  }
              })
              typeRes = typeRes.substring(0, typeRes.length - 1)
               if (typeRes.split('|').length > 1) {
                  return `(${typeRes})[]`;
                } else {
                  return `${typeRes}[]`;
                }
          }
          if (typeof value === 'object' && value !== null) {
              const props = Object.entries(value)
                  .map(([key, val]) => `${key}: ${getType(val)}`)
                  .join('; ');
              return `{ ${props} }`;
          }
          return typeof value;
      };
      const type = getType(object);
      const declaration = `interface ${name} ${type}`;
      return namespace ? `namespace ${namespace} { \r\n ${declaration} \r\n}` : declaration;
  }
  /**
   * 讀取文件并解析成 JSON 對象
   * @param {string} path - 文件路徑
   * @returns {Promise<Object>} - JSON 對象
   */
  async function readJson(path) {
      const content = await fs.readFile(path, 'utf8');
      return JSON.parse(content);
  }
  /**
   * 將 TypeScript 類型定義字符串寫入文件
   * @param {string} content - TypeScript 類型定義字符串
   * @param {string} path - 文件路徑
   * @returns {Promise<void>}
   */
  async function writeTs(content, path) {
      await fs.writeFile(path, content, 'utf8');
  }
  /**
   * 將 JSON 數據轉換為 TypeScript 類型定義
   * @param {string} inputPath - 輸入 JSON 文件路徑
   * @param {string} outputPath - 輸出 TypeScript 文件路徑
   * @param {string} [options.name=JsonType] - 轉換后的類型名稱
   * @param {string} [options.namespace] - 轉換后的命名空間
   * @param {boolean} [options.noFile] - 不將 TypeScript 類型定義保存為文件
   * @returns {Promise<void>}
   */
  async function jsonToTsFile(inputPath, outputPath, options) {
      const { name, namespace, noFile } = options
      try {
          const object = await readJson(inputPath);
          const type = jsonToTs(object, name, namespace);
          if (noFile) {
              console.log(type);
          } else {
              await writeTs(type, outputPath);
              console.log(`Type definition saved to ${outputPath}`);
          }
      } catch (err) {
          console.error(err.message);
      }
  }
  const program = new commander.Command();
  program
      .arguments('<input> <output>')
      .option('--no-file', 'do not save to file')
      .option('-s, --namespace <namespace>', 'type namespace')
      .option('-n, --name <name>', 'type name', 'JsonType')
      .action(jsonToTsFile);
  program.parse(process.argv);

到此，相信大家對“怎么實現自動生成typescript類型聲明工具”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！