go 语言快速开发

haoside666

已于 2023-08-04 10:34:43 修改

阅读量86

点赞数

分类专栏： go 文章标签： golang 开发语言后端

于 2023-08-03 22:55:56 首次发布

本文链接：https://blog.csdn.net/couldok/article/details/132094008

版权

go 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

文章目录

go 语言快速开发

笔记内容按照中文文案排版指北进行排版，以保证内容的可读性。
自动化排版工具 ,clone 下来之后,点击 index.html 就可以使用了

go 语言快速开发

最近在学习 go 语言的第三方库 (这里有很多库，可以选择一些进行学习)，发现项目结构都差不多，而且库学习刚开始基本上都是 CV 代码，改一改。。浪费大部分时间在 ide 上，感觉没必要，就索性写了一个脚本来加快学习速度。

项目结构

参考 Go 社区推荐的结构化目录项目 (https://github.com/golang-standards/project-layout),由于这里只是简单的学习第三方库，故使用以下目录结构即可

├── cmd
├── go.mod
├── internal
│   └── fmtStudy
│       └── fmtStudy.go
└── main.go

cmd 目录用于存放生成的二进制文件
internal 目录用于存放库代码 (这里以 fmt 库为例)

如果还要学习 flag 库,结构应该如下:

├── cmd
├── go.mod
├── internal
│   ├── flagStudy
│   │   └── flagStudy.go
│   └── fmtStudy
│       └── fmtStudy.go
└── main.go

对于库文件以 fmtStudy.go 为例，大致结构如下

packge fmtStudy
// Print 系列
func FmtTest01() {
	fmt.Print("111")
	name := "小明"
	fmt.Printf("我是：%s\n", name)
	fmt.Println("在终端打印单独一行显示")
}

// Fprint 系列
// Fprint 系列函数会将内容输出到一个 io.Writer 接口类型的变量 w 中，我们通常用这个函数往文件中写入内容。
func FmtTest02() {
	fmt.Fprintln(os.Stdout, "向标准输出写入内容")
	fileObj, err := os.OpenFile("./internal/fmtStudy/1.txt", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
	if err != nil {
		fmt.Println("打开文件出错，err:", err)
		return
	}
	content := "666"
	fmt.Fprintf(fileObj, "往文件中写如信息：%s", content)
}

// Sprint 系列
// Sprint 系列函数会把传入的数据生成并返回一个字符串。
func FmtTest03() {
	s1 := fmt.Sprint("123")
	name := "小明"
	age := 18
	s2 := fmt.Sprintf("name:%s,age:%d", name, age)
	s3 := fmt.Sprintln("666")
	fmt.Println(s1, s2, s3)
}

...

需求分析

对于 fmt 库

1.需要创建./internal/fmtStudy 目录
2.创建 fmtStudy.go 文件
3.在 fmtStudy.go 文件中有如下内容
packge fmtStudy

//
func FmtTest01() {
	
}

// 
func FmtTest02() {
	
}

// 
func FmtTest03() {
	
}
...

对于 main.go,需要以下内容

//模块 fmt
func test() {
	fmtStudy.FmtTest01()
	fmtStudy.FmtTest02()
	fmtStudy.FmtTest03()
	...
}

这里我使用的是 golang,import 会自动添加进来，如果是其他编译器，可以手动添加

import “{ProjectName}/internal/fmtStudy”
分析完之后，直接写脚本，选择的是 shell 脚本

工具一：自动框架脚本

脚本名 ./BatchGenerateFunc.sh(位于工程根目录下，即与 main.go 在同一目录下)

#!/bin/bash
#判断参数是否为 0 个
if [ $# == 0 ]; then
  echo "please use ./BatchGenerateFunc.sh [create|delete|main] [args...]"
else
  #记录下所有参数
  args=("$@")
  len=${#args[@]}
  if [ $1 == "create" ]; then
    if [ $# == 1 ]; then
      echo "please use ./BatchGenerateFunc.sh create [要创建的模块名 ]"
    else
      echo "输入的功能为:${args[0]},参数个数为$(($len - 1))"
      for ((i = 1; i < ${len}; i++)); do
        moduleName=${args[i]}
        moduleName=${moduleName,,}
        echo "------------create ${moduleName} module--------------"
        dir="./internal/${moduleName}Study"
        if [ -d "$dir" ]; then
          echo "$dir Directory already exists"
          continue
        else
          mkdir -p "$dir"
          echo "$dir Directory created"
        fi
        echo "package ${moduleName}Study" >${dir}/${moduleName}Study.go
        echo >>${dir}/${moduleName}Study.go
        for j in {1..10}; do
          echo "//" >>${dir}/${moduleName}Study.go
          echo "func ${moduleName^}Test${j}(){" >>${dir}/${moduleName}Study.go
          echo >>${dir}/${moduleName}Study.go
          echo "}" >>${dir}/${moduleName}Study.go
          echo >>${dir}/${moduleName}Study.go
          echo >>${dir}/${moduleName}Study.go
        done
        echo "模块${moduleName} 创建成功!"
      done
    fi
  elif [ $1 == "delete" ]; then
    if [ $# == 1 ]; then
      echo "please use ./BatchGenerateFunc.sh delete [要删除的模块名 ]"
    else
      echo "输入的功能为:${args[0]},参数个数为$(($len - 1))"
      for ((i = 1; i < ${#args[@]}; i++)); do
        moduleName=${args[i]}
        moduleName=${moduleName,,}
        rm -r ./internal/${moduleName}Study
        if [ $? == 0 ]; then
          echo "模块${moduleName} 删除成功!"
        else
          echo "模块${moduleName} 删除失败!"
        fi
      done
    fi
  elif [ $1 == "main" ]; then
    echo "请输入模块名:"
    read -r moduleName
    moduleName=${moduleName,,}
    echo "请输入编号:(如 3-->test3)"
    read -r num
    echo "请输入子函数个数:"
    read -r funcNum
    echo "-----------------以下是生成的内容------------------"
    printf "//模块%s\n" ${moduleName}
    printf "func test%s() {\n" ${num}
    for ((i = 1; i <= ${funcNum}; i++)); do
      printf "    %sStudy.%sTest%d()\n" ${moduleName} ${moduleName^} ${i}
    done
    printf "}\n"
  else
    echo "error:Wrong parameter!"
    echo "please use ./BatchGenerateFunc.sh create|delete|main [args...]"
  fi
fi

测试

1.添加模块

用法：./BatchGenerateFunc.sh create [要创建的模块名 ]

(base) 是指 anachore 的 base 环境，不用管,libraryStudy 是工程名，也不用管,后面的为命令
(base) ➜  libraryStudy tree
.
├── BatchGenerateFunc.sh
├── cmd
├── go.mod
├── internal
│   └── fmtStudy
│       └── fmtStudy.go
└── main.go

3 directories, 4 files
(base) ➜  libraryStudy ./BatchGenerateFunc.sh create module1 module2
输入的功能为:create,参数个数为 2
------------create module1 module--------------
./internal/module1Study Directory created
模块 module1 创建成功!
------------create module2 module--------------
./internal/module2Study Directory created
模块 module2 创建成功!
(base) ➜  libraryStudy tree                                         
.
├── BatchGenerateFunc.sh
├── cmd
├── go.mod
├── internal
│   ├── fmtStudy
│   │   └── fmtStudy.go
│   ├── module1Study
│   │   └── module1Study.go
│   └── module2Study
│       └── module2Study.go
└── main.go

5 directories, 6 files

2.删除模块

用法： ./BatchGenerateFunc.sh delete [要删除的模块名 ]
(base) ➜  libraryStudy ./BatchGenerateFunc.sh delete module1 module2
输入的功能为:delete,参数个数为 2
模块 module1 删除成功!
模块 module2 删除成功!

3.main 模块

用法： ./BatchGenerateFunc.sh main,之后要分别输入模块名，编号以及子函数个数

(base) ➜  libraryStudy ./BatchGenerateFunc.sh main          
请输入模块名:
module1
请输入编号:(如 3-->test3)
3
请输入子函数个数:
10
-----------------以下是生成的内容------------------
//模块 module1
func test3() {
    module1Study.Module1Test1()
    module1Study.Module1Test2()
    module1Study.Module1Test3()
    module1Study.Module1Test4()
    module1Study.Module1Test5()
    module1Study.Module1Test6()
    module1Study.Module1Test7()
    module1Study.Module1Test8()
    module1Study.Module1Test9()
    module1Study.Module1Test10()
}

测试完毕，非常完美!

最后放一下我常用 Makefile(go 语言版本的哦)，对于使用命令行的朋友们非常有效:)

工具二：Makefile(自动构建)

TARGET            = main
DEBUG_TARGET      = $(TARGET).debug
RELEASE_TARGET    = $(TARGET).release
SRC               = $(wildcard *.go)
GO               ?= go
BUILD_DEBUG_FLAGS    := -gcflags=all="-N -l" -ldflags "-s -w -compressdwarf=false"
BUILD_RElEASE_FLAGS  :=


## build: build the target
build: $(TARGET)
$(TARGET):$(SRC)
    $(GO) build $(BUILD_RElEASE_FLAGS) -o $@ $^

## release: build release version of the target,strip symbol table and debug information
release: $(RELEASE_TARGET)
$(RELEASE_TARGET):$(TARGET)
    strip -o $@ $^

## debug: build debug version of the target
debug: $(DEBUG_TARGET)
$(DEBUG_TARGET):$(SRC)
    $(GO) build $(BUILD_DEBUG_FLAGS) -o $@ $^

## all: build debug and release and default version of the target
all:$(RELEASE_TARGET) $(DEBUG_TARGET)

## clean: clean the intermediate file
clean:
    rm -rf $(TARGET) $(TARGET).release $(TARGET).debug


## help: print this help message
help: ./Makefile
    @echo -e "\nUsage: make <TARGETS> ...\n\nTargets:"
    @sed -n 's/^##//p' $< | column -t -s ':' | sed -e 's/^/ /'
    @echo

.PHONY: build release debug all clean help

用法:

第一行-->TARGET            = main 这里的 main 可以修改为你项目的 app 名字
make help 查看使用说明

最后,赶紧写 demo 了,速度学起来。。

haoside666

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录