---
stage: AI-powered
group: AI Framework
info: 本页面由开发者关系团队维护，作者@dnsmichi，详见 https://handbook.gitlab.com/handbook/marketing/developer-relations/developer-advocacy/content/#maintained-documentation
description: 原生AI功能和特性。
title: GitLab Duo用例
---

以下用例提供了使用GitLab Duo的实用示例、练习和工作流程。学习如何：

- 重构现有源代码。
- 使用GitLab Duo根因分析排查失败作业。
- 解决安全漏洞。


  

  

    
如果您使用GitLab自托管版：GitLab Duo需要GitLab 17.2及以上版本以获得最佳用户体验和结果。早期版本可能仍能运行，但体验可能会下降。




## 使用GitLab Duo解决开发挑战

### 从C#应用开始

在这些示例中，打开您的C# IDE，确保[已启用GitLab Duo](turn_on_off.md)，并探索如何使用GitLab Duo的原生AI功能来提高效率。

#### 查询GitLab REST API的CLI工具

<i class="fa fa-youtube-play youtube" aria-hidden="true"></i>
观看 [GitLab Duo咖啡聊天：开始使用C#](https://www.youtube.com/watch?v=AdRtX9L--Po) <!-- 视频发布于2024-01-30 -->

挑战是创建一个用于查询GitLab REST API的CLI工具。

- 向GitLab Duo Chat询问如何启动新的C#项目以及如何使用dotNET CLI：

  ```markdown
  如何在VS Code中开始创建一个空的C#控制台应用程序？

package org.example

// 创建文字冒险游戏
// 寻找金色乐高砖块
// 添加视觉辅助功能
// 使用随机计时器陷阱触发游戏结束
// 创建文字冒险游戏
fun createTextAdventure() {
    println("欢迎来到金色乐高砖块冒险！")
    println("你发现自己身处一间光线昏暗的房间。你会怎么做？")

    var gameOver = false
    while (!gameOver) {
        println("1. 寻找金色乐高砖块")
        println("2. 检查房间")
        println("3. 退出")

        val choice = readLine()?.toIntOrNull() ?: 0
        when (choice) {
            1 -> searchForBrick()
            2 -> examineRoom()
            3 -> {
                println("再见！")
                gameOver = true
            }
            else -> println("无效选择。请重试。")
        }
    }
}

fun searchForBrick() {
    println("你仔细搜索房间，寻找金色乐高砖块的踪迹。")
    if (Math.random() < 0.2) {
        println("恭喜！你找到了金色乐高砖块！")
    } else {
        println("你的搜索一无所获。你必须再试一次。")
    }
}

fun examineRoom() {
    println("你环顾房间，观察细节。")
    println("房间光线昏暗，角落有阴影。")
    println("北面有一扇门，房间中央有一张桌子。")
}

fun main() {
    createTextAdventure()
}

/refactor fix bugs, improve UX

...

改进建议：

- 将菜单打印逻辑提取到独立的 printMenu 函数中，以提高代码组织和可读性
- 使用 Random.nextDouble() 替代 Math.random()，以更好地兼容 Kotlin 标准库
- 打印菜单后添加用户输入选择的提示
- 移除了不必要的 gameOver 变量初始化（已在 createTextAdventure 函数中赋值）
- 在 searchForBrick 函数中添加注释，提醒你可能需要添加额外逻辑或游戏结束条件

这些更改应能提高代码的可读性、可维护性和用户体验。

package org.example

import kotlin.random.Random

// 创建文字冒险游戏
// 寻找金色乐高砖块
// 添加视觉辅助功能
// 使用随机计时器陷阱触发游戏结束
// 创建文字冒险游戏
fun createTextAdventure() {
    println("欢迎来到金色乐高砖块冒险！")
    println("你发现自己身处一间光线昏暗的房间。你会怎么做？")

    var gameOver = false
    while (!gameOver) {
        printMenu()
        val choice = readLine()?.toIntOrNull()

when (选择) {
    1 -> 搜索乐高积木()
    2 -> 检查房间()
    3 -> {
        println("再见！")
        游戏结束 = true
    }
    否则 -> println("无效的选择。请重试。")
}
}

fun 打印菜单() {
    println("1. 搜索金色的乐高积木")
    println("2. 检查房间")
    println("3. 退出")
    print("输入你的选择：")
}

fun 搜索乐高积木() {
    println("你仔细地搜查房间，寻找任何金色彩色积木的迹象。")
    if (Random.nextDouble() < 0.2) {
        println("恭喜！你找到了金色的乐高积木！")
        // 在此处添加额外的逻辑或游戏结束条件
    } else {
        println("你的搜索一无所获。你必须再试一次。")
    }
}

fun 检查房间() {
    println("你环顾房间四周，留意细节。")
    println("房间光线昏暗，角落有阴影。")
    println("北面有一扇门，房间中央有一张桌子。")
}

fun 主函数() {
    创建文字冒险()
}

# 收集目录中的文件并打印其大小

$directory = Read-Host -Prompt "输入获取文件大小的目录路径"
$files = Get-ChildItem -Path $directory -File
foreach ($file in $files) {
    $fileSize = [Math]::Round(($file.Length / 1KB), 2)
    Write-Host "$($file.Name) - $fileSize KB"
}

# 重复上述代码，但将结果存储到 CSV 文件中
$csvFile = "$directory\file-sizes.csv"
$fileData = foreach ($file in $files) {
    [PSCustomObject]@{
        FileName = $file.Name
        FileSize = [Math]::Round(($file.Length / 1KB), 2)
    }
}
$fileData | Export-Csv -Path $csvFile -NoTypeInformation
Write-Host "文件大小已保存到 $csvFile"

# 重复上述代码，但将结果存储到 JSON 文件中
$jsonFile = "$directory\file-sizes.json"
$fileData | ConvertTo-Json | Out-File -FilePath $jsonFile
Write-Host "文件大小已保存到 $jsonFile"

# 重复上述代码，但将结果存储到 XML 文件中
$xmlFile = "$directory\file-sizes.xml"
$fileData | ConvertTo-Xml -NoTypeInformation | Out-File -FilePath $xmlFile
Write-Host "文件大小已保存到 $xmlFile"

# 重复上述代码，但将结果存储到 HTML 文件中
$htmlFile = "$directory\file-sizes.html"
$fileData | ConvertTo-Html -Property FileName, FileSize | Out-File -FilePath $htmlFile
Write-Host "文件大小已保存到 $htmlFile"

# 重复上述代码，但将结果存储到 TXT 文件中
$txtFile = "$directory\file-sizes.txt"
$fileData | Out-File -FilePath $txtFile
Write-Host "文件大小已保存到 $txtFile"

    strcpy(region, "Hello GitLab Duo Vulnerability Resolution challenge");

    printf("Contents of region: %s\n", region);

如何在haml中填充select

解释此错误：undefined method `icon' for

// 创建Linux统计工具
// 收集IO、性能、磁盘使用、TCP延迟
// 打印摘要

// 导入所需头文件
#include <sys/stat.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <math.h>
#include <sys/statfs.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/time.h>

int main() {
    struct stat statbuf;

    if (stat("/etc", &statbuf) != 0) {
        perror("stat");
        return 1;
    }

    printf("IO块大小: %ld\n", statbuf.st_blksize);

    // TODO: 添加CPU使用率、磁盘使用、网络延迟测量

// 创建一个作为HTTP客户端的CLI应用
// 创建主函数
// 包含所有头文件
// 读取程序选项：URL、API端点、基本认证

#include <iostream>
#include <curl/curl.h>
#include <string>

int main(int argc, char** argv) {
  std::string url;
  std::string endpoint;
  std::string username;
  std::string password;

  // 解析命令行选项
  // ...

  CURL* curl = curl_easy_init();
  if(curl) {
    curl_easy_setopt(curl, CURLOPT_URL, url.c_str());

    // 设置基本认证
    curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
    curl_easy_setopt(curl, CURLOPT_USERPWD, (username + ":" + password).c_str());

    CURLcode res = curl_easy_perform(curl);

    if(res != CURLE_OK) {
      std::cerr << "请求失败：" << curl_easy_strerror(res) << std::endl;
    }

    curl_easy_cleanup(curl);
  }

  return 0;
}

// 创建一个用于管理分布式文件节点的应用程序
// 提供节点健康状态的概览
// 使用面向对象模式定义基础文件节点
// 添加继承自基础文件的特定文件系统

class FileNode {
public:
    std::string name;
    std::string ipAddress;
    int port;
    HealthState healthState;

    FileNode(std::string name, std::string ipAddress, int port)
        : name(name), ipAddress(ipAddress), port(port), healthState(HealthState::Healthy) {}

    void setHealthState(HealthState state) {
        healthState = state;
    }
};

class LocalFileNode : public FileNode {
public:
    std::string mountPoint;

    LocalFileNode(std::string name, std::string mountPoint)
        : FileNode(name, "127.0.0.1", 0), mountPoint(mountPoint) {}
};

class NetworkFileNode : public FileNode {
public:
    std::string user;
    std::string password;

    NetworkFileNode(std::string name, std::string ipAddress, int port, std::string user, std::string password)
        : FileNode(name, ipAddress, port), user(user), password(password) {}
};

int main(){

}

// 创建一个附加到XDP内核事件的eBPF程序
// 按IP地址统计所有数据包
// 打印摘要
// 包含必要的头文件

#include <bpf/bpf.h>

struct data {
    __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
    __type(key, uint32_t);
    __type(value, uint64_t);
};

BPF_TABLE("array", int, long, counts, 1024);

int xdp_prog(struct xdp_md *ctx) {
    void* data_end = (void*)(long)ctx->data_end;
    void* data = (void*)(long)ctx->data;
    struct ethhdr *eth = data;

    if ((void*)eth + sizeof(*eth) <= data_end) {
        struct iphdr *ip = data + sizeof(*eth);
        if ((void*)ip + sizeof(*ip) <= data_end) {
            counts.increment(ip->saddr);
        }
    }

    return XDP_PASS;
}

// 创建一个医疗分析器应用
// 从不同传感器收集数据
// 将数据存储在MSSQL中
// 提供访问传感器数据的方法

using System.Data.SqlClient;

namespace MedicalAnalyzer
{
    public class SensorDataStore
    {
        private SqlConnection connection;

        public SensorDataStore()
        {
            // 创建SQL Server连接
            connection = new SqlConnection("connection string here");
        }

        public void StoreSensorData(SensorData data)
        {
            // 打开连接
            connection.Open();

            // 向数据库插入传感器数据
            var command = connection.CreateCommand();
            command.CommandText = "INSERT INTO SensorData (Timestamp, DeviceId, Value) " +
                                  "VALUES (@timestamp, @deviceId, @value)";
            command.Parameters.AddWithValue("@timestamp", data.Timestamp);
            command.Parameters.AddWithValue("@deviceId", data.DeviceId);
            command.Parameters.AddWithValue("@value", data.Value);
            command.ExecuteNonQuery();

            // 关闭连接
            connection.Close();
        }

        public SensorData[] GetSensorData(DateTime startTime, DateTime endTime)
        {
            // 查询数据库并返回结果
        }
    }
}

/* 创建用于彩虹动画的CSS类 */

@keyframes rainbow {
    0% {
        background-position: 0% 50%;
    }
    50% {
        background-position: 100% 50%;
    }
    100% {
        background-position: 0% 50%;
    }
}

.rainbow {
    background: linear-gradient(to right, #ff0000, #ff7700, #ffff00, #00ff00, #0000ff, #8b00ff);
    background-size: 600% 600%;
    animation: rainbow 30s ease infinite;
}

// 为Kubernetes可观测性创建客户端
// 创建一个函数
// 从KUBECONFIG环境变量读取Kubernetes配置文件
// 创建Kubernetes上下文，默认命名空间
// 检查容器、Pod、服务状态并打印概览
// 导入必要的包
// 创建主程序包

package main

import (
  "context"
  "fmt"
  "os"

  "k8s.io/client-go/kubernetes"
  "k8s.io/client-go/tools/clientcmd"

  metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

func main() {

  clientset := getClientset()
  namespace := "default"

  printPods(clientset, namespace)
  printServices(clientset, namespace)
  printContainers(clientset, namespace)

}

func getClientset() *kubernetes.Clientset {

  kubeconfig := os.Getenv("KUBECONFIG")

  config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
  if err != nil {
    panic(err)
  }

  clientset, err := kubernetes.NewForConfig(config)
  if err != nil {
    panic(err)
  }

  return clientset
}

func printPods(clientset *kubernetes.Clientset, namespace string) {

  pods, err := clientset.CoreV1().Pods(namespace).List(context.TODO(), metav1.ListOptions{})
  if err != nil {
    panic(err)
  }

  fmt.Printf("在%s命名空间中有%d个Pod\n", namespace, len(pods.Items))

}

func printServices(clientset *kubernetes.Clientset, namespace string) {

  services, err := clientset.CoreV1().Services(namespace).List(context.TODO(), metav1.ListOptions{})
  if err != nil {
    panic(err)
  }

  fmt.Printf("在%s命名空间中有%d个服务\n", namespace, len(services.Items))

}

// 创建一个打印容器的函数
// 收集并打印数量

func printContainers(clientset *kubernetes.Clientset, namespace string) {

    pods, err := clientset.CoreV1().Pods(namespace).List(context.TODO(), metav1.ListOptions{})
    if err != nil {
        panic(err)
    }

    var totalContainers int
    for _, pod := range pods.Items {
        totalContainers += len(pod.Spec.Containers)
    }

    fmt.Printf("在%s命名空间中有%d个容器\n", namespace, totalContainers)

}

// 创建一个内存中的键值存储，类似于Redis
// 提供方法来
// 设置/删除键
// 更新值
// 列出/打印（带过滤条件）
// 使用BoltDB作为外部库

// 创建一个数据分析应用
// 解析不同的输入源及其值
// 将指标以列式格式存储
// 提供API进行数据查询和聚合

// 为用户创建带薪休假应用
// 在ReactJS中创建日期时间选择器
// 提供开始和结束选项
// 根据所选国家显示公共假期
// 将请求发送到服务器API

<!-- 创建一个AI知识库。
描述AI如何在高效的DevSecOps工作流程中提供帮助。
添加一个包含一个Dev、一个Ops和一个Sec示例的表格。
-->

<table>
  <tr>
    <th>Dev</th>
    <th>Ops</th>
    <th>Sec</th>
  </tr>
  <tr>
    <td>自动化测试和持续集成</td>
    <td>基础设施即代码与自动化配置</td>
    <td>静态代码分析与漏洞扫描</td>
  </tr>
</table>

package org.example

// 创建文字冒险游戏
// 寻找金色乐高积木
// 添加视觉辅助工具
// 使用随机计时陷阱结束游戏
// 创建文字冒险游戏
fun createTextAdventure() {
    println("欢迎来到金色乐高积木冒险！")
    println("你身处在一个光线昏暗的房间。你会怎么做？")

    var gameOver = false
    while (!gameOver) {
        println("1. 寻找金色乐高积木")
        println("2. 检查房间")
        println("3. 退出")

        val choice = readLine()?.toIntOrNull() ?: 0
        when (choice) {
            1 -> searchForBrick()
            2 -> examineRoom()
            3 -> {
                println("再见！")
                gameOver = true
            }
            else -> println("无效选择。请重试。")
        }
    }
}

fun searchForBrick() {
    println("你仔细搜索房间，寻找金色乐高积木的踪迹。")
    if (Math.random() < 0.2) {
        println("恭喜！你找到了金色乐高积木！")
    } else {
        println("你的搜索一无所获。你得再试试。")
    }
}

fun examineRoom() {
    println("你环顾房间，观察细节。")
    println("房间光线昏暗，角落有阴影。")
    println("北边有一扇门，中央有一张桌子。")
}

fun main() {
    createTextAdventure()
}

// 创建一个网页表单展示GitLab发布信息
// 从https://about.gitlab.com/atom.xml获取RSS feed
// 提供标题过滤选项

$feedUrl = 'https://about.gitlab.com/atom.xml';

$xml = simplexml_load_file($feedUrl);

$titleFilter = $_GET['titleFilter'];

echo '<h1>GitLab发布</h1>';
echo '<ul>';
foreach ($xml->entry as $entry) {
    $title = $entry->title;
    if (empty($titleFilter) || strpos($title, $titleFilter) !== false) {
        echo '<li>' . $title . '</li>';
    }
}
echo '</ul>';

# 收集目录中的文件并打印其大小

$directory = Read-Host -Prompt "输入要获取文件大小的目录路径"
$files = Get-ChildItem -Path $directory -File
foreach ($file in $files) {
    $fileSize = [Math]::Round(($file.Length / 1KB), 2)
    Write-Host "$($file.Name) - $fileSize KB"
}

# 重复上述代码，但将结果存储在CSV文件中

$csvFile = "$directory\file-sizes.csv"
$fileData = foreach ($file in $files) {
    [PSCustomObject]@{
        FileName = $file.Name
        FileSize = [Math]::Round(($file.Length / 1KB), 2)
    }
}
$fileData | Export-Csv -Path $csvFile -NoTypeInformation
Write-Host "文件大小已保存至 $csvFile"

$jsonFile = "$directory\file-sizes.json"
$fileData | ConvertTo-Json | Out-File -FilePath $jsonFile
Write-Host "File sizes saved to $jsonFile"

# Create a Flask webserver

# Add REST API entrypoints to manage users by ID

# Implement create, update, delete functions

# User data needs to be stored in SQlite, create table if not exists

# Run the server on port 8080, support TLS

# Print required packages for requirements.txt in a comment.

# Use Python 3.10 as default

# Potential AI-generated code below
import flask
from flask import request
import sqlite3

app = flask.Flask(__name__)

# Create SQLite database and users table if not exists
conn = sqlite3.connect('users.db')
conn.execute('''CREATE TABLE IF NOT EXISTS users
         (id INTEGER PRIMARY KEY, name TEXT, email TEXT)''')

@app.route('/users', methods=['POST'])
def create_user():
  # Get user data from request
  name = request.form['name']
  email = request.form['email']

  # Insert user into database
  conn.execute('INSERT INTO users (name, email) VALUES (?, ?)', (name, email))

  return 'User created successfully'

@app.route('/users/<int:id>', methods=['PUT'])
def update_user(id):
  # Get user data from request
  name = request.form['name']
  email = request.form['email']

  # Update user in database
  conn.execute('UPDATE users SET name = ?, email = ? WHERE id = ?', (name, email, id))

  return 'User updated successfully'

@app.route('/users/<int:id>', methods=['DELETE'])
def delete_user(id):
  # Delete user from database
  conn.execute('DELETE FROM users WHERE id = ?', (id,))

  return 'User deleted successfully'

if __name__ == '__main__':
  # Required packages - flask, sqlite3
  app.run(host='0.0.0.0', port=8080, ssl_context='adhoc')

# Create a Ruby app as log parser

# Provide hooks to replace sensitive strings in log lines

# Format the logs and store them in Elasticsearch

# Potential AI-generated code below
require 'logger'
require 'elasticsearch'

class LogParser
  attr_reader :logger

  def initialize
    @logger = Logger.new(STDOUT)
    @elasticsearch = Elasticsearch::Client.new
  end

  def parse_and_store(logs)
    sanitized_logs = sanitize_logs(logs)
    formatted_logs = format_logs(sanitized_logs)
    store_in_elasticsearch(formatted_logs)
  end

  private

  def sanitize_logs(logs)
    logs.map { |line| sanitize_line(line) }
  end

  def sanitize_line(line)
    # replace sensitive data
    line.gsub(/\d{16}/, '[REDACTED]')
  end

  def format_logs(logs)
    logs.map { |line| "#{Time.now}: #{line}" }
  end

  def store_in_elasticsearch(logs)
    logs.each { |log| @elasticsearch.index(index: 'app-logs', document: log) }
  end
end

# Create Logging utility class

# Define default log level as attribute

# Add method for logging, inputs: level, app, message

# Print the data with formatted date and time in syslog format

# Potential AI-generated code below
class Logging
  attr_accessor :log_level

  def log(level, app, message)
    time = Time.now.strftime("%b %d %H:%M:%S")
    puts "#{time} #{app}[#{Process.pid}]: #{level} - #{message}"
  end
end

# Instantiate class and test the log method

# Potential AI-generated code below
logger = Logging.new
logger.log_level = :debug

logger.log(:info, 'MyApp', 'Application started - info')
logger.log(:debug, 'MyApp', 'Application started - debug')
logger.log(:error, 'MyApp', 'Application started - error')
logger.log(:fatal, 'MyApp', 'Application started - fatal')
logger.log(:warn, 'MyApp', 'Application started - warn')

// 查询GitLab REST API
// 获取gitlab-org/gitlab的所有开放合并请求

use serde_json::Value;

fn main() {

    let client = reqwest::blocking::Client::new();
    let url = "https://gitlab.com/api/v4/projects/278964/merge_requests?state=opened";
    let response = client.get(url).send().unwrap().text().unwrap();
    let json: Value = serde_json::from_str(&response).unwrap();

    // 待办事项：分页，默认获取结果数：20
    // 读取响应头以访问下一页

    println!("{}", json.to_string());

    for mr in json.as_array().unwrap() {
        println!("{} - URL: {}", mr["title"], mr["web_url"]);
    }
}

    // 创建一个函数，遍历源数组
    // 并使用HTTP从RSS源项中获取数据。
    // 将结果存储在新的哈希映射中。
    // 在终端打印哈希映射。

// 实现牛顿法
// 创建一个带有main函数的对象
// 添加实现牛顿法的函数用于求解方程
// 添加驱动函数来测试已实现的函数
object NewtonsMethod {
  def solveEquation(f: Double => Double, df: Double => Double, x0: Double, tolerance: Double): Double = {
    var x = x0
    var error = Double.PositiveInfinity
    while (math.abs(error) > tolerance) {
      error = f(x) / df(x)
      x -= error
    }
    x
  }

  def main(args: Array[String]): Unit = {
    val f: Double => Double = x => x * x - 4
    val df: Double => Double = x => 2 * x
    val x0 = 3.0
    val tolerance = 1e-6
    val root = solveEquation(f, df, x0, tolerance)
    println(s"The root is: $root")
  }
}

#!/bin/bash

# 获取按CPU使用率排序的前10个进程
top -b -n 1 | head -n 11 | awk '{print $1, $2, $3, $9}' | column -t

# 获取按内存使用率排序的前10个进程
top -b -n 1 | head -n 11 | awk '{print $1, $2, $4, $6}' | column -t

# 获取按磁盘I/O使用率排序的前10个进程
top -b -n 1 | head -n 11 | awk '{print $1, $2, $7, $8}' | column -t

# 获取按网络I/O使用率排序的前10个进程
top -b -n 1 | head -n 11 | awk '{print $1, $2, $10, $11}' | column -t

"use strict";
// 生成一个解析IPv6和IPv4地址格式的TypeScript函数
// 使用正则表达式
function parseAddress(address) {
    const ipv6Regex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/;
    const ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
    if (ipv6Regex.test(address)) {
        return {
            ipVersion: 6,
            address
        };
    }
    else if (ipv4Regex.test(address)) {
        return {
            ipVersion: 4,
            address
        };
    }
    else {
        throw new Error('Invalid IP address');
    }
}
// 用随机输入测试该函数
const testInputs = [
    '2001:0db8:85a3:0000:0000:8a2e:0370:7334',
    '192.168.0.1',
    'not-an-ip'
];
for (const input of testInputs) {
    try {
        const result = parseAddress(input);
        console.log(result);
    }
    catch (error) {
        console.error(`Invalid address: ${input}`);
    }
}