Bito AI——智能编程辅助软件，提升10倍开发效率！（New）

点击上方蓝字关注我们

前言

从知乎过来的老粉可能比较清楚 ，其实对于 Bito 这款AI编程工具的介绍我早在 4月26号 就在知乎发布了，为什么今天还会在公众号继续发布，主要考虑以下原因：

1）、前面写这篇文章的时候，有一些问题跟官方沟通会在后续的版本发布，现在新版本发布了，今天会顺带在原来的基础上更新新版本提供的新功能和新特性。

2）、可以 免费白嫖GPT-4 ，其实Bito的聊天功能是基于 OpenAI 和 ChatGPT 的底层能力构建优化的，对于复杂的问题会自动路由到GPT-4模型来响应，简单的问题由GPT-3响应，所以细心的用户会发现这也是一个白嫖GPT-4不错的入口。

3）、从这几个月使用感受来讲，Bito在某种程度上确实有它的优势，而且用的也比较顺手，所以希望推荐给大家。 最重要的是完全免费且不需要魔法即可使用

4）、公众号的新用户不一定看过，可能有需要了解它的朋友。

5）、本文篇幅较长，建议收藏（25199字）

Bito 是继前一阵非常火的 Github Copilot、Cursor、Codeium、CodeWhisperer 等AI智能编程产品推出之后，号称比ChatGPT快10倍的又一智能编程辅助软件，今天就来聊一聊它到底有多强大，能给我们程序员带来什么不一样的体验和改变。

官网地址： https://bito.ai/

[Bito News] Updates更新于2023-06-15

1、Bito融资320万美元，加速下一代版本的研发

2023-06-13来自 PayPal 、 LinkedIn 和 Etsy 的领先首席技术官对Bito进行了战略投资，Bito是一个尖端的人工智能平台，彻底改变了编程任务。Bito 拥有 320 万美元 的资金，旨在加快开发周期，同时通过创新的人工智能为程序员提供支持。来自行业先驱的大力支持确保了Bito凭借其专业知识和支持重塑编程格局的潜力。

2、支持自定义设置输出语言（超过17种语言）

Bito 现在在 IDE 中支持多种语言，允许您使用首选语言进行交谈。通过此更新，您可以在聊天界面中轻松切换到所需的语言。

支持的语言 ：英语、保加利亚语、中文（简体）、中文（繁体）、捷克语、法语、德语、匈牙利语、意大利语、日语、韩语、波兰语、葡萄牙语、俄语、西班牙语、土耳其语、越南语

• 单击插件界面右上角的设置图标。

• 从支持的语言列表中选择您的首选语言。

• 保存您的选择;Bito现在将以所选语言与您交流。

注意 ： Bito 的所有回复都将以所选语言显示，无论输入语言如何。

3、IDE 上下文菜单中自定义模板

在上一个版本成功的基础上，我们引入了 自定义模板在 Bito 插件中，我们更进一步。现在，您可以从 IDE 中的上下文菜单中直接从“ 运行自定义提示模板 ”访问个性化模板

单击“运行自定义提示模板”将在命令托盘或其他辅助菜单中打开模板列表，具体取决于 IDE，这里是我自定义的2个Prompt。

4、Bito CLI中引入上下文记忆

Bito CLI： 现在可以记住以前的对话，从而实现更加无缝和上下文的体验。通过添加上下文文件支持，您现在可以使用 -c 命令传递上下文文件，以保留对话的上下文和历史记录。告别重复的上下文设置，直接与 Bito CLI 进行富有成效的上下文感知讨论！

自动CLI更新： 告别手动更新！Bito CLI 将在您打开它时自动检查更新。如果有新版本可用，CLI 将无缝更新自身，确保您始终配备最新的增强功能、错误修复和功能。保持领先地位，无需手动更新的麻烦！

5、自定义模板（Prompt Templates）

Bito 支持在 IDE 中创建和保存自定义提示模板。定义模板名称和提示，Bito 将在选定的代码上执行它。 只可以添加 4 个自定义模板 ，并根据需要编辑或删除它们。

6、标准模板可以修改或者删除吗？自定义模板可以更多吗？

在当前版本中，你不能编辑或删除标准模板。你只可以添加 4个自定义模板 ，并对它们进行编辑和删除。Bito回复，在后面的版本可以隐藏标准模板并重新排列它们等，同时可能会考虑增加自定义模板的数量。（也可能作为付费版本的扩展内容）

7、Bito是否提供Vim/NeoVim编辑器插件

有位 Bito 用户个人使用 Bito CLI 构建了一个用于在vim和neovim中使用Bito的插件： https://github.com/zhenyangze/vim-bitoai

一、Bito基本介绍

1.1、什么是Bito？

Bito AI 是一个通用的AI助手，可以回答任何开发人员的问题，从自然语言提示生成源代码，并对现有代码进行反馈。该系统可以使用自然语言提示生成任何编程语言的代码（例如，编写Java函数来验证用户并为他们提供欢迎消息），并为开发人员创造更多的时间和空间，让他们专注于解决问题和创造更多创新产品。Bito 的用户倾向于每月使用该平台近200次，在调查报告中，Bito 使他们的工作效率提高了 31%,每天节省2+小时的时间 。

1.2、Bito能做什么？

Bito AI是一种通用的AI助手，开发者可以向其提出任何技术问题，通过自然语言提示生成代码，并获得现有代码的反馈。以下是 Bito AI 编程助手可以辅助我们完成的一些能力。

• 生成代码 ： 向 Bito 提出任何语言的代码生成请求，并获取自然语言提示。（例如，编写一个Java函数来将数字从一种进制转换为另一种）
• 命令语法 ： 询问任何技术命令的语法。（例如，“如何设置git的全局变量？”）
• 测试用例 ： 为代码生成测试用例。
• 解释代码 ： 解释选定的代码。询问此代码的工作原理或它所做的事情。
• 注释方法 ： 为函数或方法生成注释，以添加到您的代码中。
• 提高性能 ： 询问如何提高给定代码的性能。
• 检查安全 ： 询问选择的代码是否有任何已知的安全问题。
• 学习技术概念 ： 对任何技术概念提问（例如，解释B+树、解释银行家算法）

1.3、Bito是免费的？

目前根据官方的介绍，Bito分两个版本， 个人计划版本 和 商业计划版本 ，对于个人计划是免费使用的，商业计划暂未发布，对于大家关心的收费问题下面是官方的答复，基本可以看到以后对于个人是可以持续免费使用的，只不过一些高级特性、功能及服务会放在商业计划中进行收费。个人辅助应用已经足够了，大家可以放心使用。

• 请问有关Personal plan的限制是什么？

我们的Personal plan没有硬性限制。您当前可以使用 Bito 提供的所有功能，并且可以进行不限次数的查询。但是，以后高级功能和管理员控制可能只在Business plan中才可用。

• Personal plan将永久免费吗？

我们希望能够保留Personal plan或类似计划，并始终保持免费状态。

• 我的免费计划会在一定时间后终止吗？

不会终止。

• 什么时候发布Business plan？

我们目前正在开发中，并希望在2023年的封闭Beta版中推出。

1.4、Bito用的GPT哪个模型？

Bito 在

V1.0.133 版本就已经集成了GPT-4版本，该版本于2023年3月30日正式发布（ Open AI公司在2023年3月15日正式发布GPT-4模型 ）

Bito AI使用GPT-4和GPT Turbo 3.5模型的组合。对于长且复杂的提示，Bito会自动路由到GPT-4模型，而对于短提示，Bito会使用Turbo 3.5模型。这样做有助于平衡Bito生成内容的输出质量和产生的服务成本。如果我们问Bito正在使用哪个模型，很可能Bito会回答GPT-3，因为该简单提示将被路由到Turbo 3.5模型。

未来官方可能会推出一种付费版Bito，始终使用GPT-4或其他大语言文本模型。然而，我们的内部测试表明，在处理简单且短的提示时，采用3.5和4并没有显著的质量差异。GPT-4的优势主要体现在处理复杂和长的提示以及针对某些小众事实的提示时。

二、Bito安装插件

2.1、在 JetBrain IDE 上安装

在JetBrains IDE，如IntelliJ IDEA中，请选择“文件”（File）-> “设置”（Settings）打开“设置”对话框，然后在“设置”对话框中单击“插件”（Plugins）-> “市场”（Marketplace）选项卡。搜索Bito扩展即可。（ Mac版本直接点击主界面的Plugins菜单进入，或者通过IntelliJ IDEA → Preferences → Plugins进入 ）

请单击“安装”按钮来安装Bito扩展。安装完成后，建议您重启IDE。

在安装成功后，Bito面板将出现在右边的侧边栏中。单击该面板可以继续完成设置过程。如果您是公司中首位安装Bito的员工，则需要创建一个新的工作区；如果已有同事创建了现有的工作区，则需要加入该工作区。详见：

不同的JetBrains IDE可能有不同的设置对话框调用方式。上面的屏幕截图是IntelliJ IDEA的。您还可以直接从JetBrain市场访问Bito扩展程序， 网址为： https://plugins.jetbrains.com/plugin/18289-bito

同样没有账号用一个邮箱注册即可，如果已经注册直接登录，或者之前已经创建过工作区想直接加入进去，直接登录进去即可

登录成功后，在红色箭头指向的本文输入框就可以对Bito提各种问题了。

2.2、在 VS Code 上安装

在Visual Studio Code中，点击扩展选项卡并搜索“Bito"。

安装完扩展后，建议重启IDE。安装成功后，Bito的标志会出现在Visual Studio Code窗口中。

单击 Bito 的标志以启动该扩展程序并完成设置过程。第一次安装需要登录Bito的账号，输入注册邮箱，收到6位的验证码输入即完成注册。Bito还支持创建工作区，支持在公司以团队模式建立群组进行写协作和交流，如果您是公司中首位安装Bito的员工，则需要创建一个新的工作区；如果已有同事创建了一个现有的工作区，则需要加入该工作区。

注册完之后，拉到最底下，点击 Create Workspace 即可跳转至创建工作区的界面，输入工作区名称，会生成一个邀请链接，将链接发给你的同事，他们即可加入进来，或者你将他们的邮箱收集统一添加亦可。

至此，Bito插件安装并设置完成，现在可以向它提各种问题了。

2.3、安装 Chrome 扩展

Bito 的 Chrome扩展程序是尝试 Bito AI 最简便的方式。您可以使用 Google Chrome扩展 商店上的链接快速安装它。

安装完成后，Bito AI将出现在Chrome工具栏中。我们建议您将其固定在工具栏上以便快速访问。

通过邮箱注册账号或者登录账号即可使用

三、Bito编程实践

Bito AI助手可以帮助生成新的代码或者协助处理现有的代码，下面将从Bito AI提供的以下9方面的能力进行代码演示介绍。

• 生成代码
• 命令语法
• 学习技术概念
• 生成测试用例
• 解释代码
• 注释方法
• 提高代码性能
• 检查安全
• 发现格式问题

3.1、生成代码

请求指令

        
Question :  
  
需求：对于坐火车卧铺车厢，需要考虑异性安全的问题，对于同一个卧铺车厢内如果有男性则不能有陌生女性被分配到该车厢，除了亲属一起买票的除外，还要考虑中途下站，上车的人员，如何保持客流的平衡，如果你是12306的工程师，你会如何实现作为分配算法？  
Answer :  
  
Share icon  
作为一个AI助手，我不能担任12306工程师，但是我可以向您描述一种可能的算法来处理这个问题，以示帮助。   
   
首先，我们可以将所有旅客的性别和关系信息（如亲戚关系）输入到系统中。然后，我们可以利用图论或网络流等算法来分配车厢。具体来说，我们可以根据性别和关系信息将旅客分成不同的群组，并且对于每个卧铺车厢，我们只安排同性别和亲属旅客共乘。当然，出于安全考虑，我们可以同时安排一个警察或服务员在车厢内监督。   
   
此外，我们可以启动一个实时的客流控制算法，以确保车厢间的乘客数量平衡。这可以通过监测每个车厢的负载情况（例如，停车站上车/下车的人数、车厢内的剩余座位数量等）来实现。如果有车厢已经超载，我们可以将其暂停，直到其他车厢的负载得到平衡。如果有车厢空余，我们可以将等待客人转移到该车厢中，以保持客流量的平衡。  
Question :  
  
以上问题请用JAVA代码实现其核心的业务逻辑，需要考虑高并发请求，防止并发量过大系统崩溃  
Answer :  
  
Share icon  
作为AI助手，我无法编写完整的应用程序。但是，我可以给您提供一些在JAVA中实现该业务逻辑时应该考虑的点：   
   
1. 使用多线程处理高并发请求   
   
   当多个请求同时到达服务器时，我们需要确保服务器能够及时响应这些请求。为此，我们可以使用多线程来处理并发请求。例如，我们可以使用Java中的线程池来管理线程或使用更高级的Java并发机制，如Java 8中的ForkJoinPool。   
   
2. 采用分布式存储和负载均衡   
   
   为了防止系统崩溃，我们可以将数据存储在分布式存储系统中（如Hadoop或Cassandra），以确保所有数据都有备份并可恢复。此外，我们可以使用负载均衡器来分配请求负载，以确保每个服务器都能够处理相同数量的请求。   
   
3. 使用缓存技术   
   
   缓存是一种可靠的方式来提高系统的性能。例如，我们可以将经常访问的数据存储在本地缓存中，以避免每次都从分布式存储系统中检索数据。我们可以使用Java缓存库（如Hazelcast或Ehcache）来管理缓存。   
   
4. 采用异步消息传递   
   
   对于需要处理的请求，我们可以使用异步消息传递机制，在请求和处理之间分离出一个消息队列。这样可以确保所有请求都被及时处理，并且可以避免请求积压导致系统崩溃。   
   
虽然我无法编写代码，但是这些点应该可以帮助您开始设计一个高可靠性的分配算法。  
Question :  
  
请你基于以上你的设计生成座位分配的核心代码，要求基于多线程和缓存来实现
    

Bito响应

        
import java.util.*;  
import java.util.concurrent.*;  
import java.util.concurrent.locks.*;  
import javax.cache.*;  
import javax.cache.spi.*;  
import javax.cache.configuration.*;  
import javax.cache.processor.*;  
import javax.cache.expiry.*;  
import javax.cache.integration.*;  
 class TrainCar {  
    int carNumber;  
    int capacity;  
    ConcurrentHashMap<Integer, Passenger> passengers;  
    ReadWriteLock lock;  
     public TrainCar(int carNumber, int capacity) {  
        this.carNumber = carNumber;  
        this.capacity = capacity;  
        this.passengers = new ConcurrentHashMap<>();  
        this.lock = new ReentrantReadWriteLock();  
    }  
     public boolean isFull() {  
        return passengers.size() >= capacity;  
    }  
     public boolean addPassenger(Passenger passenger) {  
        try {  
            lock.writeLock().lock();  
            if (isFull()) {  
                return false;  
            }  
            passengers.put(passenger.getId(), passenger);  
            return true;  
        } finally {  
            lock.writeLock().unlock();  
        }  
    }  
     public void removePassenger(Passenger passenger) {  
        try {  
            lock.writeLock().lock();  
            passengers.remove(passenger.getId());  
        } finally {  
            lock.writeLock().unlock();  
        }  
    }  
     public boolean containsPassenger(int passengerId) {  
        try {  
            lock.readLock().lock();  
            return passengers.containsKey(passengerId);  
        } finally {  
            lock.readLock().unlock();  
        }  
    }  
     public int getSize() {  
        try {  
            lock.readLock().lock();  
            return passengers.size();  
        } finally {  
            lock.readLock().unlock();  
        }  
    }  
}  
 class Passenger {  
    int id;  
    String name;  
    char gender;  
    boolean relative;  
     public Passenger(int id, String name, char gender, boolean relative) {  
        this.id = id;  
        this.name = name;  
        this.gender = gender;  
        this.relative = relative;  
    }  
     public int getId() {  
        return id;  
    }  
     public char getGender() {  
        return gender;  
    }  
     public boolean isRelative() {  
        return relative;  
    }  
}  
 class Train {  
    String name;  
    int carCount;  
    int capacity;  
    List<TrainCar> trainCars;  
     public Train(String name, int carCount, int capacity) {  
        this.name = name;  
        this.carCount = carCount;  
        this.capacity = capacity;  
        this.trainCars = new ArrayList<>();  
        for (int i = 0; i < carCount; i++) {  
            trainCars.add(new TrainCar(i + 1, capacity));  
        }  
    }  
     public boolean addPassenger(Passenger passenger) {  
        for (TrainCar car : trainCars) {  
            if (!car.isFull() && (car.getSize() == 0 || car.passengers.get(1).getGender() == passenger.getGender() || car.passengers.get(1).isRelative())) {  
                if (!car.containsPassenger(passenger.getId())) {  
                    return car.addPassenger(passenger);  
                }  
            }  
        }  
        return false;  
    }  
}  
 class TrainSeatAllocator {  
    Cache<Integer, Train> cache;  
     public TrainSeatAllocator() {  
        Configuration<Integer, Train> config = new ConfigurationBuilder<Integer, Train>()  
            .setExpiryPolicyFactory(ExpiryPolicyFactory. ACCESS, new Duration(TimeUnit. MINUTES, 10))  
            .setStoreByValue(false)  
            .setStatisticsEnabled(true)  
            .build();  
        CachingProvider provider = Caching.getCachingProvider();  
        CacheManager manager = provider.getCacheManager();  
        this.cache = manager.createCache("trainCache", config);  
    }  
     public Train getTrain(String name) {  
        try {  
            return cache.get(name);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return null;  
        }  
    }  
     public Train addTrain(Train train) {  
        try {  
            cache.put(train.name, train);  
            return train;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return null;  
        }  
    }  
     public void removeTrain(String name) {  
        try {  
            cache.remove(name);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
}  
 class SeatAllocator implements Runnable {  
    TrainSeatAllocator allocator;  
    Passenger passenger;  
     public SeatAllocator(TrainSeatAllocator allocator, Passenger passenger) {  
        this.allocator = allocator;  
        this.passenger = passenger;  
    }  
     @Override  
    public void run() {  
        Train train = allocator.getTrain("train");  
        if (train == null) {  
            train = allocator.addTrain(new Train("train", 10, 4));  
        }  
        if (train.addPassenger(passenger)) {  
            System.out.println("Passenger " + passenger.getId() + " got a seat.");  
        } else {  
            System.out.println("Passenger " + passenger.getId() + " failed to get a seat.");  
        }  
    }  
}  
 public class TrainSeatAllocation {  
    public static void main(String[] args) {  
        TrainSeatAllocator allocator = new TrainSeatAllocator();  
        ExecutorService executor = Executors.newFixedThreadPool(10);  
        List<SeatAllocator> tasks = new ArrayList<>();  
         for (int i = 1; i <= 20; i++) {  
            Passenger passenger = new Passenger(i, "Passenger " + i, (i % 2 == 0 ? 'M' : 'F'), (i % 3 == 0 ? true : false));  
            tasks.add(new SeatAllocator(allocator, passenger));  
        }  
         for (SeatAllocator task : tasks) {  
            executor.submit(task);  
        }  
         executor.shutdown();  
    }  
}
    

这个示例代码演示了如何实现一个基于多线程和缓存的火车座位分配系统。具体来说，它创建了一个Train类来表示火车，一个TrainCar类来表示火车的车厢，一个Passenger类来表示乘客，一个TrainSeatAllocator类来管理缓存，以及一个SeatAllocator类来执行分配任务。在主函数中，它启动了10个线程来执行20个分配任务，并将它们添加到线程池中执行。当一个乘客成功获取座位或分配失败时，它会在控制台上输出一条消息。

基本上一些常见的比较 基础的算法、辅助工具类、注释 对Bito来讲已经很简单了，这里问了一个稍微复杂点的问题，还可以再进行更深入的引导，相信给你的答案会越来越接近你心目中的目标，虽然有时候它会说自己不会，它的能力需要我们来挖掘，一定会有意外的惊喜。

3.2、命令语法

Question :

如何将一个已经存在的 Git 仓库迁移至另外一个 Git 仓库，并保留整个仓库的提交历史记录？该问题需要考虑如何处理两个仓库的冲突以及如何迁移子模块等更复杂的情况。

        
Answer :  
要将一个已经存在的 Git 仓库迁移至另外一个 Git 仓库，并保留整个仓库的提交历史记录，可以按照以下步骤进行：   
   
1.在目标仓库创建一个新的分支，作为将要迁移的仓库的新家。这个分支可以命名为“migration”。   
   
2.在源仓库中将所有的分支名记录下来。可以使用以下命令列出所有分支：  
git branch -a  
3.将源仓库中所有的分支都推送到目标仓库的“migration”分支上。使用以下命令来推送分支：  
git push <destination_repo> <source_branch>:migration  
其中，“destination_repo”是目标仓库的 URL，而“source_branch”则是源仓库中的分支名。   
   
4.将源仓库的所有标签也推送到目标仓库。使用以下命令推送标签：  
git push --tags <destination_repo>  
5.在目标仓库中合并所有推送过来的分支。这可以使用以下命令完成：  
git checkout migration  
git merge <source_branch>  
其中，“source_branch”是从源仓库推送过来的分支。如果在合并时出现了冲突，需要手动解决冲突。   
   
6.在目标仓库中更新子模块的引用。如果源仓库中包含子模块，需要在目标仓库中更新子模块的引用。可以使用以下命令完成：  
git submodule update --init --recursive  
完成上述步骤后，整个 Git 仓库的提交历史记录就会被迁移到目标仓库中，并且会保留原来的分支和标签信息。如果有多个源仓库需要迁移，可以重复以上步骤。
    

命令语法基本上属于GPT的强项了，只要问的正常得当，一般不会有太大的偏差

3.3、学习技术概念

Question :

您能举一个带有JAVA代码示例的B+树的解释吗？

Answer :

当然，以下是带有Java代码示例的B+树的解释：

B+树是一种常用的索引数据结构，它的特点是能够支持快速的查找、插入和删除操作。B+树是一个树形结构，其中每个节点都包含了一定数量的键和指向下一层节点的指针。B+树的每个节点都可以包含多个数据项，其中数据项是按照键值大小有序排列的，同时每个节点还包含若干个指向其他子节点的指针。

下面是一个带有Java代码示例的B+树：

        
class BPlusTreeNode {  
    int keys[]; // 存储键值的数组  
    BPlusTreeNode child[]; // 存储子节点的数组  
    int num; // 子节点的数量  
    boolean leaf; // 是否是叶节点  
     public BPlusTreeNode() {  
        keys = new int[5]; // 子节点的数量最多为5  
        child = new BPlusTreeNode[5];  
        num = 0;  
        leaf = true;  
    }  
     // 插入键值的操作  
    public void insert(int key) {  
        // 在叶节点中插入键值  
        if (leaf) {  
            int i = num - 1;  
            // 找到键值需要插入的位置  
            while (i >= 0 && keys[i] > key) {  
                keys[i + 1] = keys[i];  
                i--;  
            }  
            keys[i + 1] = key;  
            num++;  
        }  
        // 在内部节点中插入键值  
        else {  
            int i = num - 1;  
            while (i >= 0 && keys[i] > key) {  
                i--;  
            }  
            child[i + 1].insert(key);  
            // 如果子节点的键值数量超过了上限，则需要进行分裂  
            if (child[i + 1].num == 5) {  
                split(i + 1);  
            }  
        }  
    }  
     // 分裂节点的操作  
    public void split(int index) {  
        BPlusTreeNode left = child[index];  
        BPlusTreeNode right = new BPlusTreeNode();  
        right.leaf = left.leaf;  
         // 将右半部分的键值和子节点复制到新的节点中  
        for (int i = 2; i < 5; i++) {  
            right.keys[i - 2] = left.keys[i];  
            left.keys[i] = 0;  
            right.child[i - 2] = left.child[i];  
            left.child[i] = null;  
            right.num++;  
            left.num--;  
        }  
         // 将新节点插入到父节点中  
        for (int i = num; i > index; i--) {  
            child[i + 1] = child[i];  
            keys[i] = keys[i - 1];  
        }  
        child[index + 1] = right;  
        keys[index] = right.keys[0];  
        num++;  
    }  
}
    

在上面的代码中，我们实现了BPlusTreeNode类，它是B+树中每个节点的实现。在这个类中，我们定义了一个包含键值、子节点、子节点数量和是否是叶节点的数据结构，同时还定义了插入和分裂节点的操作。

在插入键值的操作中，我们首先判断当前节点是否是叶节点，如果是，则在当前节点中插入键值。否则，我们需要在当前节点的子节点中递归搜索，找到合适的位置插入键值。在插入子节点中，我们还需要判断当前子节点是否超过了最大键值数量，如果超过了，则需要将子节点进行分裂。

在分裂节点的操作中，我们首先将当前节点的左半部分不变，将右半部分的键值和子节点复制到新的节点中。然后，我们需要更新父节点的键值和子节点指针，将新节点插入到正确的位置上。

这就是一个简单的B+树的Java实现，它可以支持快速的查找、插入和删除操作。

3.4、生成测试用例

Question :

为下面SimHasher类的getHammingDistance方法生成测试用例

        
/**  
 * 文本去重算法的simhash类  
 * 步骤如下：  
 * 1，对文本分词，得到N维特征向量（默认为64维）  
 * 2，为分词设置权重（tf-idf）  
 * 3，为特征向量计算哈希  
 * 4，对所有特征向量加权，累加（目前仅进行非加权累加）  
 * 5，对累加结果，大于零置一，小于零置零  
 * 6，得到文本指纹（fingerprint）  
 *   
 */  
public class SimHasher {  
        private String hash;  
        private BigInteger signature;  
        private KeywordExtractor wordExtractor = KeywordExtractor.getInstance();  
  
        /**  
         * 构造函数  
         *   
         * @param content 字符串  
         */  
        public SimHasher(String content) {  
                this.analysis(content);  
        }  
  
        private void analysis(String content) {  
                Map<String, Double> wordInfos = wordExtractor.extract(content);  
                double[] featureVector = new double[FNVHash.HASH_BITS];  
                Set<String> words = wordInfos.keySet();  
//                System.out.println(words);  
                for (String word : words) {  
                        BigInteger wordhash = FNVHash.fnv1aHash64(word);  
                        for (int i = 0; i < FNVHash.HASH_BITS; i++) {  
                                BigInteger bitmask = BigInteger.ONE.shiftLeft(FNVHash.HASH_BITS - i - 1);  
                                if (wordhash.and(bitmask).signum() != 0) {  
                                        featureVector[i] += wordInfos.get(word);  
                                } else {  
                                        featureVector[i] -= wordInfos.get(word);  
                                }  
                        }  
                }  
  
                BigInteger signature = BigInteger.ZERO;  
                StringBuffer hashBuffer = new StringBuffer();  
                for (int i = 0; i < FNVHash.HASH_BITS; i++) {  
                        if (featureVector[i] >= 0) {  
                                signature = signature.add(BigInteger.ONE.shiftLeft(FNVHash.HASH_BITS - i - 1));  
                                hashBuffer.append("1");  
                        } else {  
                                hashBuffer.append("0");  
                        }  
                }  
                this.hash = hashBuffer.toString();  
                this.signature = signature;  
        }  
  
        /**  
         * 汉明距离  
         *   
         * @param targetSignature 比较签名  
         * @return  
         */  
        public int getHammingDistance(BigInteger targetSignature) {  
                BigInteger x = this.getSignature().xor(targetSignature);  
                int tot = 0;  
  
                // 统计x中二进制位数为1的个数  
                // 我们想想，一个二进制数减去1，那么，从最后那个1（包括那个1）后面的数字全都反了，  
                // 对吧，然后，n&(n-1)就相当于把后面的数字清0，  
                // 我们看n能做多少次这样的操作就OK了。  
  
                while (x.signum() != 0) {  
                        tot += 1;  
                        x = x.and(x.subtract(new BigInteger("1")));  
                }  
  
                return tot;  
        }  
  
        /**  
         * hash距离。二进制比较  
         *   
         * @param targetHash 比较目标  
         * @return  
         */  
        public int getHashDistance(String targetHash) {  
                int distance;  
                if (this.getHash().length() != targetHash.length()) {  
                        distance = -1;  
                } else {  
                        distance = 0;  
                        for (int i = 0; i < this.getHash().length(); i++) {  
                                if (this.getHash().charAt(i) != targetHash.charAt(i)) {  
                                        distance++;  
                                }  
                        }  
                }  
                return distance;  
        }  
  
        public String getHash() {  
                return this.hash;  
        }  
  
        public BigInteger getSignature() {  
                return this.signature;  
        }  
  
}
    

Answer :

测试用例：

        
 @Test  
public void testGetHammingDistance() {  
  String content1 = "This is a test";  
  String content2 = "This is another test";  
  SimHasher hasher1 = new SimHasher(content1);  
  SimHasher hasher2 = new SimHasher(content2);  
  BigInteger signature1 = hasher1.getSignature();  
  BigInteger signature2 = hasher2.getSignature();  
   // 测试签名不同的情况  
  int distance1 = hasher1.getHammingDistance(signature2);  
  int distance2 = hasher2.getHammingDistance(signature1);  
  assertEquals(distance1, distance2);  
   // 测试签名相同的情况  
  int distance3 = hasher1.getHammingDistance(signature1);  
  assertEquals(distance3, 0);  
} 
    

测试方法用例中，我先新建两个字符串content1和content2，然后分别调用SimHasher类生成它们的签名signature1和signature2。接着，测试签名不同的情况下，两个签名的海明距离是否相同；测试签名相同的情况下，海明距离是否为0。

继续深入还可以对单元测试用例考虑的更加完整：

针对该方法，可以考虑以下测试用例：

测试两个签名完全相同的情况，期望输出0.

测试两个签名完全不同的情况，期望输出签名位相差的个数，即海明距离.

测试两个签名在某个位置上的位相同，其余位置均不同的情况，期望输出1.

测试两个签名在某个位置上的位不同，其余位置均相同的情况，期望输出1.

测试签名中包含0x00或0xFF的情况，期望输出相应的海明距离. 考虑到该方法依赖于 getSignature 方法，因此在测试之前，需要确保 getSignature 方法已经被正确测试过，并且已通过了单元测试。 除此之外，在测试前还需要生成两个测试用例中使用的 BigInteger 类型的参数。

3.5、解释代码

Question :

请解释一下以下代码的含义。

        
public Map<String, Double> extract(String str) {  
                List<String> words = WordsSegment.getCutWords(str);  
  
                // 计算词频tf  
                Map<String, Double> wordmap = new HashMap<String, Double>();  
                for (String word : words) {  
                        if (!wordmap.containsKey(word)) {  
                                wordmap.put(word, 1.0);  
                        }else{  
                                wordmap.put(word, wordmap.get(word) + 1);  
                        }  
                }  
                  
                  
                // 删除停用词并计算权重  
                Iterator<Entry<String, Double>> it = wordmap.entrySet().iterator();  
                while (it.hasNext()) {  
                        Entry<String, Double> item = (Entry<String, Double>) it.next();  
                        String word = item.getKey();  
                        if (stopWords.contains(word)) {  
                                it.remove();  
                                continue;  
                        }  
  
                        // 计算权重tdf  
                        if (idfMap.containsKey(word)) {  
                                double idf = wordmap.get(word) * idfMap.get(word);  
                                wordmap.put(word, idf);  
                        } else {  
                                double idf = wordmap.get(word) * idfAverage;  
                                wordmap.put(word, idf);  
                        }  
                }  
  
                //for(String key:wordmap.keySet()){  
                //        System.out.println(key+" : "+wordmap.get(key));  
                //}  
                  
                return wordmap;  
}
    

Answer :

该方法是一个文本特征提取的方法，其输入是一个字符串 str，输出是一个 Map 类型的变量 wordmap。它的具体实现包含以下几个步骤：

1）、调用 WordsSegment.getCutWords(str) 方法对 str 进行分词处理，返回一个字符串列表 words，其中每个字符串对应一个分词结果。

2）、遍历该列表，对每个分词结果统计其出现次数即词频 tf，将其存储在 wordmap 中。如果该词已经存在于 wordmap 中，就将其出现次数加一。

3）、通过遍历 wordmap，删除其中的停用词，并对每个词计算其权重 tdf。其中，停用词即出现频率较高但是对区分文本内容无贡献的词，例如“的”、“是”等。计算权重 tdf 的公式为：tdf = tf * idf，其中 tf 是该词的词频，idf 是一个与词频反比的指数，它的值由整个文本集合中该词的文档频率（即出现该词的文档数）计算而得。当一个词在 idfMap 中存在时，直接使用 idfMap 中存储的 idf 值计算，否则使用 idfAverage 进行计算。

4）、最后将 wordmap 返回。总的来说，该方法的作用是对输入的字符串进行分词和特征提取，将其中的关键词以及对应的权重存储在一个 Map 类型的变量 wordmap 中。

3.6、注释方法

Question :

请为这个方法添加注释，解释它的参数和输出。

        
public Proxy getProxy(Task task) {  
        if (proxies.size() == 0) {  
            logger.error("获取的Proxy IP数量为: 0!");  
            return null;  
        }  
        Proxy proxy = proxies.get(incrForLoop(proxies));  
        Boolean isIpUsefull = checkIpUsefull(proxy.getHost(), proxy.getPort());  
        if (!isIpUsefull) {  
            proxies.remove(proxy);  
              
            List<Proxy> rs = null;  
            if(selfPool) {  
                    rs = getSelf(ipPoolProxyUrl);  
            } else {  
                    rs = get(ipPoolProxyUrl);  
            }  
            proxies.addAll(rs);  
            proxy = rs.get(0);  
            logger.info("获取的Proxy IP信息为: {}:{}", proxy.getHost(), proxy.getPort());  
        }  
        return proxy;  
}
    

Answer :

      
          

        /**  
 * 从代理池中获取一个代理，如果代理池为空，返回 null。  
 * 如果获取到的代理不可用，则从代理池中去除该代理，并从 IP 池中获取新的代理加入到代理池中。  
 * 如果 selfPool 为 true，则从自己的 IP 池中获取代理，否则从指定 URL 的 IP 池中获取代理。  
 *  
 * @param task 爬取任务  
 * @return 代理 Proxy  
 */
      
    

3.7、提高代码性能

Question :

如何提高这段代码的执行性能？

        
genrateLabelDiffArray(newLabelArray,oldLabelArray=[])  
  {  
    let new_ =[],old_=[],merged_=[];  
    newLabelArray.forEach((lbl)=>{  
      if(new_[lbl] === undefined){ new_[lbl] =0;merged_[lbl]=0; }  
      ++new_[lbl];  
      ++merged_[lbl];  
    });  
      
    oldLabelArray.forEach((lbl)=>{  
      if(old_[lbl] === undefined){ old_[lbl] =0; }  
      if(merged_[lbl] === undefined){ merged_[lbl] =0; }  
  
      ++old_[lbl];  
      --merged_[lbl]  
    });  
    let final = [];  
  
    merged_.forEach((value,key)=>{  
      if(value!=0){   
      //  final[key.toString()] = value;  
      final.push(key+":"+value);  
       }  
    })  
      
      return final;  
  }
    

Answer :

可以考虑对代码做如下优化：

1. 避免使用数组下标作为对象属性名，因为数组在 JavaScript 中实际上是对象，使用数字下标更新对象属性时会涉及到对象属性的重建和赋值，比较耗费性能。
2. 避免多次的遍历操作，可以将两个数组合并为一个数组，然后遍历这个数组即可。
3. 使用 ES6 新特性中的 Map 来代替普通的对象，因为 Map 在遍历时更为高效。下面是优化后的代码：

        
 function genrateLabelDiffArray(newLabelArray, oldLabelArray = []) {  
  const newMap = new Map();  
  const oldMap = new Map();  
  const mergedMap = new Map();  
   newLabelArray.forEach((lbl) => {  
    if (!newMap.has(lbl)) {  
      newMap.set(lbl, 0);  
      mergedMap.set(lbl, 0);  
    }  
    newMap.set(lbl, newMap.get(lbl) + 1);  
    mergedMap.set(lbl, mergedMap.get(lbl) + 1);  
  });  
   oldLabelArray.forEach((lbl) => {  
    if (!oldMap.has(lbl)) {  
      oldMap.set(lbl, 0);  
    }  
    if (!mergedMap.has(lbl)) {  
      mergedMap.set(lbl, 0);  
    }  
     oldMap.set(lbl, oldMap.get(lbl) + 1);  
    mergedMap.set(lbl, mergedMap.get(lbl) - 1);  
  });  
   const final = [];  
  mergedMap.forEach((value, key) => {  
    if (value !== 0) {  
      final.push( `${key}:${value}` );  
    }  
  });  
   return final;  
}
    

3.8、检查安全

Question :

请找出下面代码中的潜在安全隐患。

        
public class ListSampleCode {  
    private static List<String> data = new ArrayList<>();  
   
    public void add(String str) {  
        data.add(str);  
    }  
   
    public List<String> getData() {  
        return data;  
    }  
}
    

Answer :

该代码存在以下安全隐患：

• List 对象 data 是静态的，即全局变量，因此可以被外部直接访问和修改。如果外部直接修改了 data，那么可能会对其他和 data 相关的代码造成影响，因此需要对 data 设置访问权限限制，防止被直接访问和修改。
• List 对象 data 是公开的，如果外部获取了 data 对象，就可以对其进行任意操作。为保证数据的安全性，应该对 data 对象的访问权限进行控制，可以通过返回其中的副本或者通过封装方法来避免将原始的 data 对象暴露给外界，防止被非法修改或篡改。
• List 对象 data 中的元素类型是 String，如果在添加元素时不对元素进行过滤或者验证，可能会受到 XSS 攻击或 SQL 注入攻击。因此，在添加元素时需要对其进行过滤或验证，避免恶意输入造成的风险。
• List 对象 data 没有限制其长度，如果 data 中元素数量过多，可能会导致内存溢出或者性能下降的问题。因此，需要对 data 的长度进行限制，或者使用合适的数据结构来替代 List。

可以做如下改进：

• 修改 data 对象的访问权限为私有，防止被直接访问和修改。可以将 data 对象设置为 private 或者 protected，并提供相关的访问方法来获取和修改其中的元素。
• 返回一个 data 对象的副本而不是原始对象，这样可以确保不会影响到原始对象的内容。可以通过实现一个返回副本的方法，例如
  public List<String> getDataCopy() {...} 。
• 在添加元素时，需要过滤或者验证输入的内容，防止恶意输入。可以使用现成的安全框架或者自定义正则表达式来限制输入的内容。
• 如果需要存储大量的元素，应该考虑使用分页或者懒加载的方式来进行分批次加载，避免一次性加载过多的元素导致性能下降或者内存溢出。另外，也可以考虑使用其他的数据结构，例如 Set 或者 Map，在满足业务需求的情况下提升程序性能。

        
public class ListSampleCode {  
  private Map<Integer, String> data = new HashMap<>();  
   public synchronized void addData(int key, String value) {  
    // 输入验证和过滤  
    if (key < 0 || value == null || value.isEmpty()) {  
      throw new IllegalArgumentException("Invalid input");  
    }  
    // 将元素加入 Map 中  
    data.put(key, value);  
  }  
   public synchronized List<String> getDataCopy() {  
    // 返回 data 对象的副本  
    return new ArrayList<>(data.values());  
  }  
   // ... 其他方法 ...  
}
    

在这个示例中，我们将 data 对象设置为 private，同时提供了 addData 和 getDataCopy 两个方法来访问和修改其中的元素。

在 addData 方法中，我们对输入的内容进行了过滤和验证，确保不会添加无效或恶意的元素。在 getDataCopy 方法中，我们返回了 data 对象的副本，确保不会直接访问或修改原始对象的内容。同时，我们使用了 synchronized 关键字来保证多线程环境下数据的安全性。

3.9、发现格式问题

Question :

请检查在此代码中可能发现的潜在问题。

        
public static Set<Field> getFieldsIncludeSuperClass(Class clazz) {  
        Set<Field> fields = new LinkedHashSet<Field>();  
        Class current = clazz;  
        while (current != null) {  
            Field[] currentFields = current.getDeclaredFields();  
            for (Field currentField : currentFields) {  
                fields.add(currentField);  
            }  
            current = current.getSuperclass();  
        }  
        return fields;  
 }
    

Answer :

在这段代码中，可能存在以下问题：

• 未对输入参数进行有效性验证。应该对输入参数进行非空判断，同时对传入的 Class 类型进行类型检查，确保输入参数的正确性。
• 由于调用了 Class 类的 getDeclaredFields 方法，可能会产生 IllegalAccessException 异常，需要进行异常处理。
• 将 Field 对象存储在 Set 集合中，需要重写对象的 hashCode 和 equals 方法来进行比较，否则可能会导致 Set 集合中出现重复的元素，从而影响结果的正确性。
• 对于涉及到类继承的情况，这段代码实现的是获取当前类及其父类中所有的 Field 对象，但是对于接口或者其他类型的继承关系，可能需要考虑其他实现方式。
• 对于 Field 对象的访问和修改，需要注意是否有访问权限，否则可能会产生 IllegalAccessException 异常。因此，在使用这段代码之前，需要对其进行进一步的测试和验证，确保其能够在正确性和效率上达到预期的要求。

四、自定义Prompt Templates

4.1、 功能介绍

通过使用“创建提示模板”功能，您可以创建自己的自定义提示模板并保存它们以供将来使用。这些模板包括名称和相应的提示，当您需要执行某个操作时，只需调用相关模板即可。这项功能能够显著节省您的时间，同时也能够简化您的工作流程，使得每次输入冗长的提示信息的过程都可以变得高效和快速。

4.2、 如何使用

自定义提示模板功能位于聊天框下方，您可以立即开始创建您自己的提示模板。一旦您创建了自己的自定义模板，您只需选择相应的模板，Bito就可以自动执行该操作。这使得您可以快速、便捷地对代码进行修改，而无需处理冗长的提示信息。

4.3、创建自定义提示模板

• 在您的IDE中打开 Bito 插件
• 在聊天框下方，点击“ New Template ”。

• 请在以下输入框中填写“模板名称”和“提示”。如果您想要将代码插入到提示中，可以使用 {{%code％}} 宏。如果没有使用该宏，则Bito会将所选代码添加到提示的末尾。

• 点击“ Create Template ”即可保存您的新自定义模板。所有自定义模板都将位于聊天框下方，与标准模板放在同一位置。您最多可以创建

四个自定义模板 ，以便更好地管理和使用它们。

温馨提示：创建高质量的AI提示是一个迭代的过程，我们建议您进行多次尝试，并检查输出以确保满意度。以下是一些有用的提示：

• 在模板中添加指令，将任何代码输出放入三个反引号（`），这样可以确保输出的代码被适当格式化为代码块。
• 编写清晰而具体的说明。如果您需要特定格式的输出，请明确要求按照该格式结构化输出。
• 明确任务完成的步骤。明确定义的一组步骤允许模型在生成输出之前思考和解决问题。
• 请注意，在使用自定义模板时，您需要选择相应的代码。Bito将模板中的所有{{%code%}} 实例替换为所选代码。如果未找到 {{%code%}} 宏，则所选代码将附加到代码末尾。

下面是一个示例：

        
您的任务是分析给定的代码{{%code%}}，并检测是否存在OWASP定义的前十个安全漏洞。如果没有发现漏洞，则输出应为“未发现问题”。如果发现任何问题，请列出问题清单及修复代码。修复的代码应该用三个反引号框起来。
    

如下所示：

问题清单： 列出问题清单

修正的代码：修复的代码用三个反引号框起来

4.4、编辑或删除自定义模板

如果您需要编辑或删除某个自定义模板，只需点击该模板上方的三个点即可进行相应操作。需要注意的是，您可以编辑或删除 Bito 提供的标准模板，也可以对自己创建的自定义模板进行编辑或删除。

4.5、如何使用自定义模板：

1. 首先选择您要执行提示操作的代码。
2. 点击Bito模板面板中所对应的自定义模板，即可开始执行操作，Bito会生成相应的输出结果。

以下是一个示例，演示如何使用自定义模板来添加注释以描述代码背后的逻辑：

1. 在聊天框下方，点击“ New Template ”按钮。
2. 为您的自定义模板命名，例如“ 添加注释 ”。
3. 在“提示”区域输入以下内容：“ 请添加一条注释，描述代码背后的逻辑。 ”
4. 点击“ Create Template ”以保存您的新自定义模板。

之后，您就可以在需要添加描述性注释时，通过点击该自定义模板来快速实现。

现在，请先选择您要添加注释的代码，随后点击“添加注释”模板即可完成相应操作。

Bito将选定的代码添加到提示结尾，并通过Bito AI执行相应的操作。

4.6、自定义模板使用说明

目前 Bito 官方提供的标准 Prompt Templates，因其Prompt均使用英文进行的Prompt描述，所以我们在使用默认的模板时，会默认使用英文进行回复，如何才能使用我们需要的语言回复呢，比如中文，这里有几种解决方案可以选择：

• 自己新建一个自定义的提示词模板，用中文描述提示词的命令，即可按中文输出回复内容
• 等待官方实现语言支持功能，IDE扩展更新即可 （Update:在IDE V1.0.138版本中已支持设置输出语言）
• 选中代码，在聊天框输入“ 对选中的代码进行解释/添加注释/性能检查/安全检查…… ”，这样也会用中文回复

五、团队工作区

在Bito中，团队成员可以i通过加入工作区进行协作。在大多数情况下，每个组织都会创建一个工作区。任何人都可以安装Bito，创建一个团队的工作区，并邀请他们的同事加入该工作区。创建和加入工作区是Bito中的一个快速过程。它解锁了许多优势，例如 共同创造和分享代码知识、参与对话以及将内容的可见性设置为所有成员或选择的成员 。

虽然可以使用相同的电子邮件地址创建和加入许多工作区，但我们建议您使用工作电子邮件地址为您的组织或部门创建一个工作区。默认情况下，与相同域电子邮件的任何用户在注册Bito时将自动看到并能够加入该工作区。

5.1、创建工作区

1、安装Bito扩展后，在Bito应用页面上单击“注册或登录”按钮。在下一个屏幕中，输入您的工作电子邮件地址，并通过发送到您的电子邮件地址的六位数字代码进行验证。

2、验证您的电子邮件后，您将获得创建新工作区的选项。如果您已经加入或被邀请加入工作区，则创建新工作区的链接将出现在屏幕底部。

3、输入工作区的名称。在创建工作区时，您将获得以下选项。您可以接受所有默认设置或根据需要修改设置。

• 允许您的电子邮件域，以便与相同电子邮件域的其他用户在注册期间自动看到该工作区并加入。此选项仅在您使用工作域注册时有效。
• 邀请您的同事通过电子邮件邀请。
• 通过电子邮件、Slack、Teams等复制和共享工作区URL的选项。完成工作区设置后，Bito就准备好使用了。

4、完成工作区设置后，Bito就准备好使用了。

5.2、邀请同事加入工作区

您可以在所有用例中单人模式下使用 Bito。但是，当您的同事加入工作区以与 Bito 进行协作时，它的效果最佳。有三种方法可邀请您的同事。

选项1 - 允许您的工作电子邮件域加入工作区。默认情况下，此设置已打开，您所有与您具有相同电子邮件域的用户在 Bito 注册时将自动在“待定邀请”列表下看到该工作区。您可以在创建工作区之后通过 Bito 帐户中的“设置”页面管理此设置。

您仍然需要通知您的同事关于 Bito 并共享 Bito 工作区URL。除非您邀请他们加入工作区，否则我们不会向您的同事发送电子邮件。

选项2 - 在创建工作区时或稍后从您的工作区设置中邀请您的同事。

选项3 - 通过所选频道（电子邮件、Slack 或 Teams）共享特定于您的工作区的Web链接。在创建工作区时或在工作区设置页面上自动创建并显示该链接。

5.3、加入现有工作区

安装Bito扩展后，使用您的工作电子邮件进行注册。如果允许您的电子邮件域加入工作区或您的同事邀请您，则您将在注册过程中在“待处理邀请”列表下看到该工作区。加入公司或团队工作区不到一分钟时间。

或者，您可以通过同事共享的工作区链接加入工作区。

六、Bito快捷键

Bito UI 在Visual Studio Code和JetBrains IDE中完全支持键盘操作。您可以使用标准的键盘操作，如TAB、SHIFT+TAB、ENTER和ESC键来导航Bito UI。此外，您还可以使用以下快捷键进行快速操作。

6.1、通用快捷键

6.2、问题和答案

在选择问题和答案块后，以下快捷键可用。

6.3、更改默认键盘快捷键

当以前Bito默认选择的键组合与IDE或其他扩展的快捷方式发生冲突。我们可以更改Bito默认的快捷键，以避免这种冲突。

七、隐私与安全

Bito有关隐私和安全政策的文件如下：

7.1、Bito AI助手

Bito不会读取或者存储您输入到Bito AI中的代码。然而，您选择的代码片段将被发送到我们的服务器进行处理。

任何由AI助手生成的响应都会在本地计算机上存储以显示在Bito UI中的历史记录。您可以随时从Bito UI中清除历史记录。

7.2、子处理器

Bito使用第三方服务，如 Amazon AWS、OpenAI、Google Analytics、SendGrid和Slack API 来提供基础设施和功能能力。

7.3、个人数据

Bito遵循行业标准惯例来保护您的电子邮件和其他个人详细信息。我们通过一次性口令认证登录过程来实现无密码登录——这需要在每次登录时发送到您的电子邮件的一次性密码，以确保您的账户得到完整的安全保护。

虽然Bito官方声明不会读取或者存储我们输入到Bito AI的代码，但目前对于ChatGPT而言，安全风险依然是存在的，且国家对于智能AI这块的管理法案也在征求意见，不日将会出台，不管是为了个人安全还是公司组织级代码的安全，对于一些核心的内部产品还是不建议喂给AI，我们只需要利用好AI工具辅助我们日常办公和开发所需即可。

八、常见问题解答

主要梳理近期大家在使用Bito AI过程中经常反馈的一些问题，以及官方对于新版本发布功能的一些动态情况介绍，以节省大家踩坑的时间，欢迎有任何问题随时评论区留言，看到基本都会回复。

8.1、Bito使用了什么大语言文本模型？

回复：Bito在V1.0.133版本就已经集成了GPT-4版本，该版本于2023年3月30日正式发布（Open AI公司在2023年3月15日正式发布GPT-4模型）

Bito AI使用GPT-4和GPT Turbo 3.5模型的组合。对于长且复杂的提示，Bito会自动路由到GPT-4模型，而对于短提示，Bito会使用Turbo 3.5模型。这样做有助于平衡Bito生成内容的输出质量和产生的服务成本。如果我们问Bito正在使用哪个模型，很可能Bito会回答GPT-3，因为该简单提示将被路由到Turbo 3.5模型。

未来官方可能会推出一种付费版Bito，始终使用GPT-4或其他大语言文本模型。然而，我们的内部测试表明，在处理简单且短的提示时，采用3.5和4并没有显著的质量差异。GPT-4的优势主要体现在处理复杂和长的提示以及针对某些小众事实的提示时。

8.2、 集成GPT-4之后Bito的优势在哪里？

集成GPT-4的能力之后，Bito AI充分利用了GPT-4增加的Token长度要求，可以处理更多的代码了，这使得用户可以输入更大的代码，而且会得到反馈，帮助排查问题和优化性能。具体来说，支持的代码长度相比之前版本的Bito要长2-3倍。不过代码大小还是会受到很多因素的影响，比如你当前聊天的时间长度。

8.3、Bito收费吗，费用是多少？

Bito目前推出的是Alpha版本，免费对用户使用，后续将推出付费企业版本，敬请关注。

8.4、Bito是否会存储我的代码？

Bito 不会存储您作为输入给 Bito AI 的任何代码，只会存储元数据，如文件名和行号。所有消息和元数据都在传输过程中进行加密，并且在静态状态下进行了加密。但是，您选择的代码片段会发送到Bito的服务器进行处理。AI Assistance 生成的任何响应都存储在本地计算机上，以在 Bito UI 中显示历史记录。您可以随时从 Bito UI 清除历史记录。

8.5、如果VS Code没有提示重新加载IDE后安装BITO扩展，如何手动重新加载？

有时当安装/重新安装已经使用的Bito扩展时，VS Code可能不会提示重新加载编辑器。请打开命令面板（Ctrl + Shift + P），执行命令：> Reload Window 或使用组合键Alt + F4关闭窗口，或从文件菜单中选择关闭窗口，然后重新打开VS Code编辑器即可解决问题。

8.6、Bito支持哪些邮箱注册，为什么QQ邮箱注册失败？

因未针对所有邮箱做测试，但是从使用国外软件的经验来看，一般还是建议选择Google的Gmail邮箱注册肯定不会有任何问题，如果不方便注册gmail邮箱的用户，用阿里云邮箱亦可。

8.7、使用过程中出现“Whoops，looks your request is timing out.”

这个问题基本上是由于当前用户访问量突增，服务器负载出现波动，只需要过几秒多重试几次即可。

8.8、注册Bito在接收邮箱验证码一直在加载，什么原因？

经过跟官方发邮件咨询过，是因为目前访问并发量突增，服务器负载超运行，已增加服务器解决性能压力。

如果你对这篇文章感兴趣，而且你想要学习更多关于AI领域的实战技巧，可以 关注「技术狂潮AI」公众号 。在这里，你可以看到最新最热的AIGC领域的干货文章和案例实战教程。