标签 golang 下的文章

JS合并2个远程pdf_js pdf合并，2024最新Golang笔经

2024-08-14

在JavaScript中，使用pdf.js库来合并两个PDF文件是一项复杂的任务，因为pdf.js主要用于阅读PDF文件，而不是创建或修改PDF文件。不过，你可以使用pdf-lib库，这是一个专门用于处理PDF文档的第三方库。

首先，你需要安装pdf-lib库：




npm install --save pdf-lib

然后，你可以使用以下代码来合并两个PDF文件：




const { PDFDocument } = require('pdf-lib');
 
async function mergePdfs(pdfFile1, pdfFile2, outputPdf) {
  // 读取两个PDF文件
  const pdfDoc1 = await PDFDocument.load(await fetch(pdfFile1).then(res => res.arrayBuffer()));
  const pdfDoc2 = await PDFDocument.load(await fetch(pdfFile2).then(res => res.arrayBuffer()));
 
  // 获取第一个PDF文档的一个页面，并添加到第二个PDF文档中
  const pages = await pdfDoc2.copyPages(pdfDoc1, pdfDoc1.getPageIndices());
  pages.forEach((page) => {
    pdfDoc2.addPage(page);
  });
 
  // 写入合并后的PDF文件
  await pdfDoc2.save({ path: outputPdf, useCrossOrigin: false });
}
 
// 使用示例
mergePdfs('pdf1.pdf', 'pdf2.pdf', 'merged.pdf');

确保你有足够的权限来读取和写入文件，并且服务器配置允许跨源资源共享（CORS）。

注意：以上代码示例假设pdf1.pdf和pdf2.pdf是在同一个域下可以访问的资源。如果PDF文件位于不同的域中，你可能需要配置服务器以允许CORS，或者将文件下载到本地进行处理。

- 阅读更多 -

Golang 自定义时间结构体支持Json&Gorm

System

2024-08-14

所有,golang




package main
 
import (
    "encoding/json"
    "fmt"
    "gorm.io/gorm"
    "time"
)
 
// 定义自定义时间类型
type CustomTime struct {
    time.Time
}
 
// 实现json.Marshaler接口以支持JSON序列化
func (ct CustomTime) MarshalJSON() ([]byte, error) {
    return json.Marshal(ct.Format("2006-01-02 15:04:05"))
}
 
// 实现json.Unmarshaler接口以支持JSON反序列化
func (ct *CustomTime) UnmarshalJSON(data []byte) error {
    t, err := time.Parse("2006-01-02 15:04:05", string(data))
    if err != nil {
        return err
    }
    ct.Time = t
    return nil
}
 
// 实现GormValuer接口以支持Gorm存储
func (ct CustomTime) GormValue(ctx context.Context, db *gorm.DB) (interface{}, error) {
    return ct.Time, nil
}
 
// 实现GormScanner接口以支持Gorm读取数据库
func (ct *CustomTime) Scan(value interface{}) error {
    switch v := value.(type) {
    case time.Time:
        ct.Time = v
        return nil
    case nil:
        ct.Time = time.Time{}
        return nil
    default:
        return fmt.Errorf("unsupported scan type for CustomTime: %T", value)
    }
}
 
func main() {
    // 示例：序列化和反序列化
    now := CustomTime{time.Now()}
    serialized, _ := json.Marshal(now)
    fmt.Println(string(serialized)) // 输出类似 "2023-04-05 12:34:56"
 
    var deserialized CustomTime
    json.Unmarshal(serialized, &deserialized)
    fmt.Println(deserialized.Format("2006-01-02 15:04:05")) // 输出 "2023-04-05 12:34:56"
 
    // 示例：Gorm存储和读取
    // 假设有一个Gorm模型使用CustomTime
    type Model struct {
        ID        uint
        CreatedAt CustomTime
    }
 
    // 使用Gorm时，CustomTime会自动被识别和处理
}

这段代码定义了一个CustomTime结构体，它包含了time.Time作为嵌入字段。它实现了json.Marshaler和json.Unmarshaler接口以支持JSON序列化和反序列化，同时实现了gorm.io/gorm包中的GormValuer和GormScanner接口以支持Gorm ORM的存储和读取。这样，CustomTime可以在JSON和Gorm之间无缝集成，方便进行时间数据的处理。

- 阅读更多 -

golang用wails开发类似360的悬浮球

System

2024-08-14

所有,golang

在上一节中，我们已经创建了悬浮球的基本框架，并实现了悬浮球的显示和隐藏。在这一节中，我们将继续实现悬浮球的拖拽功能。

首先，我们需要在floatingBall.go中添加一个新的方法来处理拖拽事件：




// floatingBall.go
 
package main
 
import (
    "github.com/wailsapp/wails"
)
 
type FloatingBall struct {
    runtime *wails.Runtime
    show    bool
    x       int
    y       int
}
 
// ... 省略其他代码 ...
 
// Drag 处理悬浮球的拖拽逻辑
func (b *FloatingBall) Drag(data string) {
    // 将data转换为DragInfo结构体
    var info DragInfo
    err := json.Unmarshal([]byte(data), &info)
    if err != nil {
        b.runtime.LogError("解析拖拽数据失败: ", err)
        return
    }
 
    // 更新悬浮球位置
    b.x = info.X
    b.y = info.Y
    b.runtime.Events.Emit("updatePosition", map[string]interface{}{
        "x": b.x,
        "y": b.y,
    })
}
 
// ... 省略其他代码 ...

然后，我们需要在前端代码中监听拖拽事件，并在拖拽结束后更新悬浮球位置：




<!-- renderer/main/main.html -->
 
<!DOCTYPE html>
<html>
<head>
  <!-- ... 省略其他代码 ... -->
</head>
<body>
  <!-- ... 省略其他代码 ... -->
 
  <script>
    // ... 省略其他代码 ...
 
    window.wails.Events.on('updatePosition', (payload) => {
      ball.style.left = payload.x + 'px';
      ball.style.top = payload.y + 'px';
    });
 
    ball.addEventListener('mousedown', (e) => {
      isDragging = true;
      offsetX = e.clientX - parseInt(ball.style.left);
      offsetY = e.clientY - parseInt(ball.style.top);
    });
 
    window.addEventListener('mousemove', (e) => {
      if (isDragging) {
        const x = e.clientX - offsetX;
        const y = e.clientY - offsetY;
        ball.style.left = x + 'px';
        ball.style.top = y + 'px';
        window.wails.Events.emit('drag', JSON.stringify({ x, y }));
      }
    });
 
    window.addEventListener('mouseup', () => {
      isDragging = false;
    });
 
    // ... 省略其他代码 ...
  </script>
</body>
</html>

在上面的代码中，我们添加了updatePosition事件的监听，用于更新悬浮球的位置。我们还为悬浮球添加了mousedown、mousemove和mouseup事件监听器，以实现拖拽功能。当用户拖动悬浮球时，我们发送drag事件给后端，并在前端更新悬浮球的位置。

这样，悬浮球的拖拽功能就完成了。你可以运行你的应用，并试着拖动悬浮球看看效果。

System

2024-08-14

所有,golang

在GoLand中创建第一个Go项目的步骤如下：

打开GoLand。
点击 File 菜单，然后选择 New -> Project。
在弹出的对话框中，选择 Go 作为项目类型，然后点击 Next。
填写项目位置和其他相关信息，然后点击 Finish。

以下是创建项目后，在GoLand中编写的一个简单的Go程序示例：




package main
 
import "fmt"
 
func main() {
    fmt.Println("Hello, World!")
}

保存文件后，可以点击右上角的运行按钮或使用快捷键 Shift+F10 运行程序。程序会在控制台输出 "Hello, World!"。

- 阅读更多 -

速度与稳健：Go与Java的编程语言对决

System

2024-08-14

所有,golang

这个问题的本质是比较两种编程语言的特性和使用场景，并没有提供具体的代码实现，因此我将提供一个概括性的比较，并给出简单的代码示例。

Go 语言:

优点：

高并发和性能
内存管理自动化
编译速度快，生成的二进制文件较小
语法简单，支持多返回值和管道操作
工作效率高，特别适合分布式系统和网络编程

不足：

没有明显的垃圾回收，内存管理需要开发者小心处理
标准库相对较小，社区支持和生态系统不如Java

Java 语言:

优点：

内存管理自动化，垃圾回收机制
成熟的平台无关的标准库
广泛的社区支持和庞大的生态系统，如Spring框架
在企业级应用、服务器端和大数据领域有成熟的框架和工具

不足：

运行速度和内存使用可能不如Go
编译生成的字节码较大，运行时环境依赖较多
语法较复杂，需要更多的学习资源

代码示例对比不再适宜，因为主要是比较语言本身的特性。然而，我可以提供一个简单的Go和Java程序来展示各自的特点。

Go 程序（Hello World）:




package main
 
import "fmt"
 
func main() {
    fmt.Println("Hello, World!")
}

Java 程序（Hello World）:




public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

这两个程序都是输出"Hello, World!"，Go程序更简洁，Java程序提供了更多的结构和模块化能力。

- 阅读更多 -

go-zero框架入门

System

2024-08-14

所有,golang

go-zero是一个服务端的高性能RPC框架，它以Go语言为核心，提供了微服务开发模式中的基础设施。以下是一个使用go-zero框架创建简单服务的步骤和示例代码：

安装go-zero工具：




go get -u github.com/zeromicro/go-zero/tools/goctl

使用goctl生成服务模板：




goctl rpc protoc --src=path/to/your.proto

这里的your.proto是你的RPC服务定义文件，需要按照Protocol Buffers的语法规范编写。

编写服务逻辑。在生成的服务目录下，编辑your_service.go文件，实现RPC方法。
运行服务：




go run your_service.go -f config.yaml

其中config.yaml是服务的配置文件。

以下是一个简单的RPC服务定义文件your.proto的例子：




syntax = "proto3";
 
package your;
 
// 定义请求结构
message YourRequest {
  string name = 1;
}
 
// 定义响应结构
message YourResponse {
  string message = 1;
}
 
// 定义RPC服务
service YourService {
  rpc DoYourThing(YourRequest) returns (YourResponse);
}

使用goctl生成服务模板后，会得到默认的服务逻辑实现文件，你可以在这个文件中填充具体的业务逻辑。

这个简单的例子展示了如何使用go-zero框架创建一个RPC服务的基础流程。在实际应用中，你需要根据具体的业务需求来编写.proto文件以及在生成的服务文件中实现业务逻辑。

- 阅读更多 -

Go语言学习Day6：数组与切片

System

2024-08-14

所有,golang




package main
 
import "fmt"
 
func main() {
    // 定义并初始化一个整型数组
    var numbers = [5]int{1, 2, 3, 4, 5}
 
    // 打印数组中的元素
    fmt.Println("数组:", numbers)
 
    // 使用range创建一个切片，包含数组的前三个元素
    slice := numbers[:3]
    fmt.Println("切片:", slice)
 
    // 修改切片中的一个元素
    slice[0] = 10
    fmt.Println("修改后的数组:", numbers)
    fmt.Println("修改后的切片:", slice)
 
    // 使用append添加元素到切片
    slice = append(slice, 6)
    fmt.Println("添加元素后的切片:", slice)
}

这段代码首先定义并初始化了一个整型数组，然后使用range创建了一个切片，并打印了数组和切片的内容。接着，修改了切片中的一个元素，并打印了修改后的数组和切片。最后，使用append函数向切片中添加了一个新元素，并打印了添加元素后的切片。这个过程展示了数组、切片的定义、修改和扩展，是学习Go语言数组和切片相关概念的一个很好的例子。

- 阅读更多 -

xgo: golang基于-toolexec实现猴子补丁

System

2024-08-14

所有,golang

"猴子补丁"（Monkey Patch）是一个术语，通常用于计算机编程中，指的是在运行时动态修改已有代码。在Golang中，如果你想要实现类似的功能，可以使用反射包来修改变量或函数。

以下是一个简单的例子，展示了如何使用反射来修改Golang中的函数：




package main
 
import (
    "fmt"
    "reflect"
)
 
func originalFunction() string {
    return "Original Function"
}
 
func monkeyPatch(target interface{}, newValue interface{}) {
    v := reflect.ValueOf(target)
 
    if v.Kind() != reflect.Func {
        panic("target is not a function")
    }
 
    // 将target的值设置为newValue
    reflect.ValueOf(target).Set(reflect.ValueOf(newValue))
}
 
func main() {
    fmt.Println(originalFunction()) // 输出: Original Function
 
    // 定义一个新的函数来替换originalFunction
    newFunction := func() string {
        return "Monkey Patched Function"
    }
 
    // 进行猴子补丁
    monkeyPatch(originalFunction, newFunction)
 
    fmt.Println(originalFunction()) // 输出: Monkey Patched Function
}

在这个例子中，我们定义了一个原始函数originalFunction，然后创建了一个monkeyPatch函数，它接受一个目标函数和一个新的函数值，并使用反射来替换原有的函数实现。在main函数中，我们首先调用原始函数，然后应用猴子补丁，并再次调用原始函数以展示其行为已经被修改。

请注意，在实际编程中，实现动态修改函数或变量的代码可能会更复杂，并且可能需要考虑并发安全性问题。此外，在Golang中，动态修改已导入的包中的函数或变量不是一个推荐的做法，因为这可能会导致难以预测的副作用和潜在的安全问题。通常，你应该尽可能通过接口、组合或继承等方式来实现需求。

- 阅读更多 -

Go语言的四种开发框架

System

2024-08-14

所有,golang

Go语言有许多不同的框架，但是最常见和最受欢迎的四种是：

Gin
Gin是一种轻量级的HTTP web框架，它拥有极好的性能，API简洁，源码易读。




package main
 
import "github.com/gin-gonic/gin"
 
func main() {
    r := gin.Default()
    r.GET("/ping", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "pong",
        })
    })
    r.Run() // 在 0.0.0.0:8080 上启动服务
}

Beego
Beego是一个开源的网络框架，它可以用于快速构建RESTFul的web应用。




package main
 
import "github.com/astaxie/beego"
 
type MainController struct {
    beego.Controller
}
 
func (c *MainController) Get() {
    c.Ctx.WriteString("hello world")
}
 
func main() {
    beego.Router("/", &MainController{})
    beego.Run()
}

Echo
Echo是一种高度可扩展的HTTP(S) web框架，它提供了强大的路由功能，可以轻松地集成其他库。




package main
 
import (
    "net/http"
    "github.com/labstack/echo"
)
 
func main() {
    e := echo.New()
    e.GET("/", func(c echo.Context) error {
        return c.String(http.StatusOK, "Hello, World!")
    })
    e.Start(":8080")
}

Iris
Iris是一种高性能的Go语言的HTTP框架，它提供了一个灵活的，友好的API来构建企业级的web应用。




package main
 
import "github.com/kataras/iris"
 
func main() {
    app := iris.Default()
    app.Get("/", func(ctx iris.Context) {
        ctx.WriteString("Hello world!")
    })
    app.Listen(":8080")
}

以上代码都是简单的示例，展示了如何启动一个基础的web服务器，并在根路由返回一个简单的响应。每个框架都有其独特的风格和特性，开发者可以根据项目需求选择合适的框架。

- 阅读更多 -

goland的debug模式修复

System

2024-08-14

所有,golang

为了提供解决方案，我需要更多的上下文信息，因为“Goland的debug模式修复”是一个非常广泛的主题。Goland是JetBrains开发的一个IDE，专门为Go语言设计。如果在使用Goland进行debug时遇到问题，可能的原因和解决方法包括：

配置问题：
- 确保Debug配置正确，包括程序路径、端口、环境变量等。
- 检查是否有任何配置错误，如路径错误、参数不正确等。
IDE问题：
- 重启Goland，尝试清除缓存或重置设置。
- 确保Goland是最新版本，如果不是，请更新。
Go环境问题：
- 确保Go环境配置正确，使用go env检查Go的环境变量设置。
- 确保Go的版本与项目兼容。
依赖问题：
- 确保所有依赖项都已正确安装，使用go mod tidy和go mod vendor来整理和可能的依赖。
代码问题：
- 检查代码中是否有导致debug不稳定的问题，如死锁、无限循环等。
插件问题：
- 确保所有相关插件都是最新的，有时第三方插件可能会导致问题。

如果上述方法都不能解决问题，建议查看Goland的日志文件，搜索错误信息，或者在JetBrains的支持论坛中搜索类似问题，也可以联系JetBrains的客服或技术支持。

- 阅读更多 -