精华内容
下载资源
问答
  • 常见的目录结构有哪些
    千次阅读
    2022-07-01 14:58:09

    通过cd /命令到达根目录下,再输入ls查看。

    1 /dev:

    是Linux内核的设备管理器,该文件夹中存放的都是一些关于设备的文件,例如光驱、硬盘、U盘、以及一些IDE(hd开头)和SATA(sd开头)、SCSI(sd开头)、USB(sd开头)相关的文件。

    2 /etc:

    存放所有的系统管理所需要的配置文件和子目录,它必须是静态的,不能是可执行二进制文件。

    3 /home:

    • 用户的主目录,在 Linux 中,每个用户都有一个自己的目录,一般该目录名是以用户的名字命名的。
    • 使用用户的主目录,比如说有个用户叫user1,那他的主目录就是/home/user1我们通常同“~”来表示家目录。
    • / 表示根目录,~表示的是当前用户的家目录

    4 /lib:

    存放着系统最基本的动态连接共享库,其作用类似于 Windows 里的 DLL 文件。几乎所有的应用程序都需要用到这些共享库。

    5 /opt:

    可选的目录。

    6 /proc:

    伪文件系统,该文件夹中的文件在系统启动之前是空的。存储的很多都是一些内核的镜像文件。该文件夹中可以看到一些目前系统的性能状态信息,例如网卡的数据信息、支不支持IPV4、支不支持路由功能。通过调整该文件夹中的某些文件可以调整操作系统的根本工作属性,系统的调优选就和这个文件夹有关。

    7 /sys:

    也是一个伪文件系统:跟硬件设备相关的属性映射文件。

    8 /tmp:

    临时文件夹

    9 /var:

    可变化的文件。/var/run:存储应用程序的进程号码,PID:进程ID号。

    10 /bin:

    存储的是系统操作的可执行命令,比如:cat、mv、cp、su等。

    11 /sbin:

    存储的是管理命令。/bin、/sbin、/lib、/etc:这几个文件具有一定的相关性,每个文件和其它的文件都有一定的关联性。

    12 /usr:

    类似Windows的Program files目录,用户很多应用程序都安装在此目录下。

    /usr/bin、/usr/sbin、/usr/lib:系统启动后为了一些功能而使用的命令。

    /usr/local/bin、/usr/local/sbin、/usr/local/lib:存储的是当前系统启动后的第三方软件需要用到的一些可执行文件和库文件,第三方应用程序也常安装在/usr/local/下。

    更多相关内容
  • 常见项目svn目录结构

    热门讨论 2007-12-07 16:41:34
    常见项目svn目录结构
  • Linux目录结构

    千次阅读 2022-03-22 19:32:40
    Linux命令选集3Linux目录结构查看及检索文件查看文件内容cat命令查看文件内容more命令查看文件内容less命令查看文件内容head,tail命令统计文件内容wc命令检索和过滤文件内容grep命令压缩命令gzip,bzip2命令 ...


    引言: 知道系统的目录结构可以有助于我们更高效的对书籍进行存储和查组

    一.Linux目录结构

    Linux操作条统生定过文件水位门时,使用机"进行分带(第子Windows操作系统中的反斜杠””)。整个树形目录结构中,使用独立的一个"“表示根目录,根目录是Linux操作文件系统的起点,其所在的分区称为根分区。在根目录下,Linux操作系统将默认建立一些特殊的子目录,分别具有不同的用途。下面简单介绍一下其中常见的子目录及其作用。
    /boot:此目录是系统内核存放的目录,同时也是系统启动时所需文件的存放目录。如vmlinuz和 initrd.img。在安装Linux操作系统时,为boot目录创建一个分区,有利于对系统进行备份。
    /bin:bin是binary的缩写这一目录存放了所有用户都可执行的且经常使用的命令,如cp、ls等。
    /dev: 此目录保存了接口设备文如/dev/hdal、/dev/cdrom等
    /etc:系统主要的配文件几平都放置到这个目录内,例如人员的账号密码文件、各种服务的起始文件第。
    /home: 存放所有普通系统用户的默认工作文件夹(即宿主目录、家目录),如用户账号’'teacher”对应的宿主目录位于”/home/teacher/“如果服务器需要提供给大量的普通用户使用,建议将/home”目录也划分为独立的分区,以方便用户数据的备份。
    /root:该目录是Linux操作系统管理员(超级用户)root的宿主目录,默认情况下只有 root用户的宿主目录在根目录下而不是在”/home"目录下。
    /sbin: 存放Linux操作系统中最基本的管理命令,一般管理员用户才有权限执行。
    /usr: 存放其他的用户应用程序,通常还被划分成很多子目录,用于存放不同类型的应用程序。
    /var: 存放系统中经常需要变化的一些文件,如系统日志文件、用户邮箱目录等。在实际应用系统中。
    /va: 目录通常也被划分为独立的分区
    以上列举的只是Linux操作系统中用户经常用到的子目录,还有其他一些子目家需要用户在使用Linux操作系统的过程中逐渐去熟悉。

    二.查看及检索文件

    在 Linux操作系统中,绝大多数的配置文件是以普通文木格式保存的,这些配置文件决定着系统及相关服务、程序的运行特性。本节将学习如何查看及检索文本文件的内容,快速了解相关配置信息,以便为管理、维护操作系统提供有效的参考。

    2.1查看文件内容cat命令

    作用:显示出文件的内容
    格式:cat 【选项】文件名…

    示例:

    查看/etc/下的hosts目录内容
    在这里插入图片描述
    查找etc为目录下所有以.conf结尾的的文件并通过more展示出来
    在这里插入图片描述

    2.2 查看文件内容more命令

    格式:more 【选项】文件名…

    交互操作方法

    1.按Enter键向下逐行滚动
    2.按空格键向下翻一屏
    3.按b键向上翻一屏
    4.按q键退出
    示例: 查看/var下的log/messages
    在这里插入图片描述

    2.3 查看文件内容less命令

    与more命令相同,但扩展功能更多
    格式:less【选项】文件名

    交互操作方法

    1.Page UP向上翻页,Page Down向下翻页
    2.按“/”键查找内容,“n”下一内容,“N”向上内容
    3.按Enter键向下逐行滚动
    4.按空格键向下翻一屏
    5.按b键向上翻一屏
    6.按q键退出
    示例: 查看/var下的log/messages
    在这里插入图片描述

    2.4 查看文件内容head,tail命令

    head命令
    用途:查看文件开头的一部分内容(默认十行)
    格式:head -n 文件名…
    示例: 查看文件messages前三行
    在这里插入图片描述

    tail命令
    用途:查看文件结尾的少部分内容(默认十行)
    格式:
    tail -n 文件名…
    tail -f 文件名

    -f 用于动态追踪
    在这里插入图片描述

    2.5 统计文件内容wc命令

    统计文件中的单词数量(Word Count)等信息
    格式:wc【选项】…目标文件…
    常用命令选项
    1.-l:统计行数
    2.-w:统计单词个数
    3.-c:统计字节数
    示例: 查找liang 目录下的行数,单词数,字节数在这里插入图片描述

    2.6 检索和过滤文件内容grep命令

    作用:在文件中查找并显示包含指定字符串的行
    格式:grep 【选项】…查找条件 目标文件
    常用命令选项
    1.-i:查找时忽略大小
    2.-v:反转查找,输出与查找目标条件不相符的行
    查找条件设置
    1.要查找的字符串以双引号括起来
    2.“^……”表示以……开头,“……$”表示以……结尾
    3.“^ $ ” 表示空行
    示例: 在/etc/passwd中查找ftp
    在这里插入图片描述
    在维护Linux操作系统的过程中,经常会遇到包含大量内容的配置文件,而其中往往包含了许多空行和以"#”开头的注释文字,当只需要分析其中的有效配置信息时,这些空行和注释文字的存在不利于快速浏览。使用 grep命令可以过滤掉这些无关信息

    2.7 压缩命令gzip,bzip2命令

    制作压缩文件、解开 压缩文件
    制作压缩文件:
    gzip 【-9】文件名…
    bzip【-9】文件名…

    解开压缩文件;
    gzip -d .gz格式的压缩文件
    bzip2 -d .bz2格式的压缩文件

    常用命令选项:-9,-d
    示例:
    用gzip 压缩文件1.txt
    在这里插入图片描述
    用bzip2格式压缩2.txt
    在这里插入图片描述
    若想压缩的文件含有其他连接则无法被压缩
    例:用bzip2压缩19.txt
    在这里插入图片描述
    cp(复制)命令,但是当需要备份的文件、目录数量较多时,仅仅使用 cp命令就显得"力不从心”,并目备份的文件数量及其所占用的磁盘空间都可能会对服务器产生不小的压力。因此,有必要对需要备份的数 据进行归档和压缩。这里所说的归档操作实际上相当于“打包”,即将许多个文件和目录合并保存为一个整体的包文件,以方便传递或携带。而压缩操作可以进一步降低打包后的归档文件所占用的磁盘空间,充分提高备份介质的利用率。

    总结:

    为了更搞笑的处理文件,我们需要知道Linux系统的目录结构以一些常用的查找和处理文件的命令.列如一些必要的关键词查找,,当服务器宕机的时候我们需要学会追踪数据动向等

    展开全文
  • Go 项目目录结构、Makefile 结构、编译命令

    1. 目录规范

    一个好的目录结构至少要满足以下几个要求。

    • 命名清晰:目录命名要清晰、简洁,不要太长,也不要太短,目录名要能清晰地表达出该目录实现的功能,并且目录名可根据实际情况选择单数或者复数。
    • 功能明确:一个目录所要实现的功能应该是明确的、并且在整个项目目录中具有很高的辨识度。也就是说,当需要新增一个功能时,我们能够非常清楚地知道把这个功能放在哪个目录下。
    • 全面性:目录结构应该尽可能全面地包含研发过程中需要的功能,例如文档、脚本、源码管理、API 实现、工具、第三方包、测试、编译产物等。
    • 可预测性:项目规模一定是从小到大的,所以一个好的目录结构应该能够在项目变大时,仍然保持之前的目录结构。
    • 可扩展性:每个目录下存放了同类的功能,在项目变大时,这些目录应该可以存放更多同类功能。

    根据功能,我们可以将目录结构分为结构化目录结构和平铺式目录结构两种。

    • 结构化目录结构主要用在 Go 应用中,相对来说比较复杂;
    • 而平铺式目录结构主要用在 Go 包中,相对来说比较简单;

    2. 平铺式目录结构

    一个 Go 项目可以是一个应用,也可以是一个代码框架 / 库,当项目是代码框架 / 库时,比较适合采用平铺式目录结构。

    平铺方式就是在项目的根目录下存放项目的代码,整个目录结构看起来更像是一层的,例如 loggithub.com/golang/glog 就是平铺式的,目录如下:

    $ ls glog/
    glog_file.go  glog.go  glog_test.go  LICENSE  README
    

    3. 结构化目录结构

    当前 Go 社区比较推荐的结构化目录结构是 https://github.com/golang-standards/project-layout。虽然它并不是官方和社区的规范,但因为组织方式比较合理,被很多 Go 开发人员接受。

    ├── api
    ├── assets
    ├── build
    ├── cmd
    ├── configs
    ├── deployments
    ├── docs
    ├── examples
    ├── githooks
    ├── go.mod
    ├── init
    ├── internal
    ├── LICENSE.md
    ├── Makefile
    ├── pkg
    ├── README_zh-CN.md
    ├── scripts
    ├── test
    ├── third_party
    ├── tools
    ├── vendor
    ├── web
    └── website
    

    一个 Go 项目包含 3 大部分:Go 应用 、项目管理和文档。所以,我们的项目目录也可以分为这 3 大类。同时,Go 应用又贯穿开发阶段、测试阶段和部署阶段,相应的应用类的目录,又可以按开发流程分为更小的子类。所以整体来看,我们的目录结构可以按下图所示的方式来分类:
    dir

    3.1 Go 应用开发目录

    开发的代码包含前端代码和后端代码,可以分别存放在前端目录和后端目录中。

    3.1.1 /web

    前端代码存放目录,主要用来存放 Web 静态资源,服务端模板和单页应用(SPAs)。

    3.1.2 /cmd

    一个项目有很多组件,可以把组件 main 函数所在的文件夹统一放在 /cmd 目录下,例如:

    $ ls cmd/
    gendocs  geniamdocs  genman   genyaml  apiserver iamctl  iam-pump
    
    $ ls cmd/apiserver/
    apiserver.go
    

    这里要保证 /cmd/<组件名> 目录下不要存放太多的代码,如果你认为代码可以导入并在其他项目中使用,那么它应该位于 /pkg 目录中。如果代码不是可重用的,或者你不希望其他人重用它,请将该代码放到 /internal 目录中。

    3.1.3 /internal

    存放私有应用和库代码。如果一些代码,你不希望在其他应用和库中被导入,可以将这部分代码放在/internal 目录下。

    在引入其它项目 internal 下的包时,Go 语言会在编译时报错:

    An import of a path containing the element “internal” is disallowed
    if the importing code is outside the tree rooted at the parent of the
    "internal" directory.
    

    如果 internal 目录下直接存放每个组件的源码目录(一个项目可以由一个或多个组件组成),当项目变大、组件增多时,可以将新增加的组件代码存放到 internal 目录,这时 internal 目录就是可扩展的。例如:

    $ ls internal/
    apiserver  authzserver  iamctl  pkg  pump  watcher
    

    /internal 目录建议包含如下目录:

    • /internal/apiserver:该目录中存放真实的应用代码。这些应用的共享代码存放在 /internal/pkg 目录下。
    • /internal/pkg:存放项目内可共享,项目外不共享的包。这些包提供了比较基础、通用的功能,例如工具、错误码、用户验证等功能。

    建议是,一开始将所有的共享代码存放在 /internal/pkg 目录下,当该共享代码做好了对外开发的准备后,再转存到 /pkg 目录下。

    3.1.4 /pkg

    该目录中存放可以被外部应用使用的代码库,其他项目可以直接通过 import 导入这里的代码。所以,我们在将代码库放入该目录时一定要慎重。

    3.1.5 /vendor

    项目依赖,可通过 go mod vendor 创建。需要注意的是,如果是一个 Go 库,不要提交 vendor 依赖包。

    3.1.6 /third_party

    外部帮助工具,分支代码或其他第三方应用(例如 Swagger UI)。比如我们 fork 了一个第三方 go 包,并做了一些小的改动,我们可以放在目录 /third_party/forked 下。一方面可以很清楚的知道该包是 fork 第三方的,另一方面又能够方便地和 upstream 同步。

    3.2 Go 应用测试目录

    3.2.1 /test

    用于存放其他外部测试应用和测试数据。/test 目录的构建方式比较灵活:对于大的项目,有一个数据子目录是有意义的。例如,如果需要 Go 忽略该目录中的内容,可以使用 /test/data/test/testdata 目录。

    需要注意的是,Go 也会忽略以 ._ 开头的目录或文件。这样在命名测试数据目录方面,可以具有更大的灵活性。

    3.3 Go 应用部署目录

    3.3.1 /configs

    这个目录用来配置文件模板或默认配置。例如,可以在这里存放 confdconsul-template 模板文件。这里有一点要注意,配置中不能携带敏感信息,这些敏感信息,我们可以用占位符来替代,例如:

    apiVersion: v1    
    user:    
      username: ${CONFIG_USER_USERNAME} # iam 用户名    
      password: ${CONFIG_USER_PASSWORD} # iam 密码
    

    3.3.2 /deployments

    用来存放 IaasPaaS 系统和容器编排部署配置和模板(Docker-ComposeKubernetes/HelmMesosTerraformBosh)。在一些项目,特别是用 Kubernetes 部署的项目中,这个目录可能命名为 deploy

    3.3.3 /init

    存放初始化系统(systemdupstartsysv)和进程管理配置文件(runitsupervisord)。比如 sysemdunit 文件。这类文件,在非容器化部署的项目中会用到。

    3.4 Go 应用项目管理目录

    3.4.1 /Makefile

    一个 Go 项目在其根目录下应该有一个 Makefile 工具,用来对项目进行管理,Makefile 通常用来执行静态代码检查、单元测试、编译等功能。其他常见功能:

    • 静态代码检查(lint):推荐用 golangci-lint
    • 单元测试(test):运行 go test ./...
    • 编译(build):编译源码,支持不同的平台,不同的 CPU 架构。
    • 镜像打包和发布(image/image.push):现在的系统比较推荐用 Docker/Kubernetes 进行部署,所以一般也要有镜像构建功能。
    • 清理(clean):清理临时文件或者编译后的产物。
    • 代码生成(gen):比如要编译生成 protobuf pb.go 文件。
    • 部署(deploy,可选):一键部署功能,方便测试。
    • 发布(release):发布功能,比如:发布到 Docker Hubgithub 等。
    • 帮助(help):告诉 Makefile 有哪些功能,如何执行这些功能。
    • 版权声明(add-copyright):如果是开源项目,可能需要在每个文件中添加版权头,这可以通过 Makefile 来添加。
    • API 文档(swagger):如果使用 swagger 来生成 API 文档,这可以通过 Makefile 来生成。

    建议:直接执行 make 时,执行如下各项 format -> lint -> test -> build,如果是有代码生成的操作,还可能需要首先生成代码 gen -> format -> lint -> test -> build

    3.4.2 /scripts

    该目录主要用来存放脚本文件,实现构建、安装、分析等不同功能。不同项目,里面可能存放不同的文件,但通常可以考虑包含以下 3 个目录:

    • /scripts/make-rules:用来存放 makefile 文件,实现 /Makefile 文件中的各个功能。Makefile 有很多功能,为了保持它的简洁,我建议你将各个功能的具体实现放在 /scripts/make-rules 文件夹下
    • /scripts/libshell 库,用来存放 shell 脚本。一个大型项目中有很多自动化任务,比如发布、更新文档、生成代码等,所以要写很多 shell 脚本,这些 shell 脚本会有一些通用功能,可以抽象成库,存放在 /scripts/lib 目录下,比如 logging.shutil.sh 等。
    • /scripts/install:如果项目支持自动化部署,可以将自动化部署脚本放在此目录下。如果部署脚本简单,也可以直接放在 /scripts 目录下。

    另外,shell 脚本中的函数名,建议采用语义化的命名方式,例如 iam::log::info 这种语义化的命名方式,可以使调用者轻松的辨别出函数的功能类别,便于函数的管理和引用。

    3.4.3 /build

    这里存放安装包和持续集成相关的文件。这个目录下有 3 个大概率会使用到的目录,在设计目录结构时可以考虑进去。

    • /build/package:存放容器(Docker)、系统(deb, rpm, pkg)的包配置和脚本。
    • /build/ci:存放 CI的配置文件和脚本。
    • /build/docker:存放子项目各个组件的 Dockerfile 文件。

    3.4.4 /tools

    存放这个项目的支持工具。这些工具可导入来自 /pkg/internal 目录的代码。

    3.4.5 /githooks

    Git 钩子。比如,我们可以将 commit-msg 存放在该目录。

    3.4.6 /assets

    项目使用的其他资源 (图片、CSSJavaScript 等)。

    3.4.7 /website

    如果你不使用 Github 页面,则在这里放置项目的网站数据。

    3.5 Go 应用文档目录

    3.5.1 /README.md

    项目的 README 文件一般包含了项目的介绍、功能、快速安装和使用指引、详细的文档链接以及开发指引等。

    3.5.2 /docs

    存放设计文档、开发文档和用户文档等(除了 godoc 生成的文档)。推荐存放以下几个子目录:

    • /docs/devel/{en-US,zh-CN}:存放开发文档、hack 文档等。
    • /docs/guide/{en-US,zh-CN}: 存放用户手册,安装、quickstart、产品文档等,分为中文文档和英文文档。
    • /docs/images:存放图片文件。

    3.5.3 /CONTRIBUTING.md

    开源就绪的项目,用来说明如何贡献代码,如何开源协同等等。CONTRIBUTING.md 不仅能够规范协同流程,还能降低第三方开发者贡献代码的难度。

    3.5.4 /api

    /api 目录中存放的是当前项目对外提供的各种不同类型的 API 接口定义文件,其中可能包含类似 /api/protobuf-spec/api/thrift-spec/api/http-specopenapiswagger 的目录,这些目录包含了当前项目对外提供和依赖的所有 API 文件。

    3.5.5 /LICENSE

    版权文件可以是私有的,也可以是开源的。常用的开源协议有:Apache 2.0MITBSDGPLMozillaLGPL

    3.5.6 /CHANGELOG

    当项目有更新时,为了方便了解当前版本的更新内容或者历史更新内容,需要将更新记录存放到 CHANGELOG 目录。

    3.5.7 /examples

    存放应用程序或者公共包的示例代码

    4. 不建议的目录

    4.1 /src

    其中一个重要的原因是:在默认情况下,Go 语言的项目都会被放置到 $GOPATH/src 目录下。这个目录中存放着所有代码,如果我们在自己的项目中使用 /src 目录,这个包的导入路径中就会出现两个 src,例如:

    $GOPATH/src/github.com/marmotedu/project/src/main.go
    

    这样的目录结构看起来非常怪。

    5. 建议

    对于小型项目,可以考虑先包含 cmdpkginternal 3 个目录,其他目录后面按需创建,例如:

    $ tree --noreport -L 2 tms
    tms
    ├── cmd
    ├── internal
    ├── pkg
    └── README.md
    

    另外,在设计目录结构时,一些空目录无法提交到 Git 仓库中,但我们又想将这个空目录上传到 Git 仓库中,以保留目录结构。这时候,可以在空目录下加一个 .keep 文件,例如:

    $ ls -A build/ci/ 
    .keep
    

    6. 实际项目参考目录

    ├── admin.sh                     # 进程的start|stop|status|restart控制文件
    ├── conf                         # 配置文件统一存放目录
    │   ├── config.yaml              # 配置文件
    │   ├── server.crt               # TLS配置文件
    │   └── server.key
    ├── config                       # 专门用来处理配置和配置文件的Go package
    │   └── config.go                 
    ├── db.sql                       # 在部署新环境时,可以登录MySQL客户端,执行source db.sql创建数据库和表
    ├── docs                         # swagger文档,执行 swag init 生成的
    │   ├── docs.go
    │   └── swagger
    │       ├── swagger.json
    │       └── swagger.yaml
    ├── handler                      # 类似MVC架构中的C,用来读取输入,并将处理流程转发给实际的处理函数,最后返回结果
    │   ├── handler.go
    │   ├── sd                       # 健康检查handler
    │   │   └── check.go 
    │   └── user                     # 核心:用户业务逻辑handler
    │       ├── create.go            # 新增用户
    │       ├── delete.go            # 删除用户
    │       ├── get.go               # 获取指定的用户信息
    │       ├── list.go              # 查询用户列表
    │       ├── login.go             # 用户登录
    │       ├── update.go            # 更新用户
    │       └── user.go              # 存放用户handler公用的函数、结构体等
    ├── main.go                      # Go程序唯一入口
    ├── Makefile                     # Makefile文件,一般大型软件系统都是采用make来作为编译工具
    ├── model                        # 数据库相关的操作统一放在这里,包括数据库初始化和对表的增删改查
    │   ├── init.go                  # 初始化和连接数据库
    │   ├── model.go                 # 存放一些公用的go struct
    │   └── user.go                  # 用户相关的数据库CURD操作
    ├── pkg                          # 引用的包
    │   ├── auth                     # 认证包
    │   │   └── auth.go
    │   ├── constvar                 # 常量统一存放位置
    │   │   └── constvar.go
    │   ├── errno                    # 错误码存放位置
    │   │   ├── code.go
    │   │   └── errno.go
    │   ├── token
    │   │   └── token.go
    │   └── version                  # 版本包
    │       ├── base.go
    │       ├── doc.go
    │       └── version.go
    ├── README.md                    # API目录README
    ├── router                       # 路由相关处理
    │   ├── middleware               # API服务器用的是Gin Web框架,Gin中间件存放位置
    │   │   ├── auth.go 
    │   │   ├── header.go
    │   │   ├── logging.go
    │   │   └── requestid.go
    │   └── router.go
    ├── service                      # 实际业务处理函数存放位置
    │   └── service.go
    ├── util                         # 工具类函数存放目录
    │   ├── util.go 
    │   └── util_test.go
    └── vendor                         # vendor目录用来管理依赖包
        ├── github.com
        ├── golang.org
        ├── gopkg.in
        └── vendor.json
    

    Go API 项目中,一般都会包括这些功能项:Makefile 文件、配置文件目录、RESTful API 服务器的 handler 目录、model 目录、工具类目录、vendor 目录,以及实际处理业务逻辑函数所存放的 service 目录。这些都在上述的代码结构中有列出,新加功能时将代码放入对应功能的目录/文件中,可以使整个项目代码结构更加清晰,非常有利于后期的查找和维护。

    参考:
    https://juejin.cn/book/6844733730678898702/section/6844733730720841735

    7. makefile 的规则

    Makefile 基本格式如下:

    target ... : prerequisites ...
        command
        ...
    

    其中:

    • target:编译文件要生成的目标
    • prerequisites:编译文件需要的依赖
    • command:依赖生成目标所需要执行的命令(任意的 shell 命令),Makefile 中的命令必须以 [tab] 开头

    比如我们平时使用的 gcc a.c b.c -o test 这里的 test 就是我们要生成的目标, a.cb.c就是我们生成目标需要的依赖,而 gcc a.c b.c -o test 则是命令。将这行命令用 Makefile 的方式来写就是:

    test: a.c b.c
        gcc a.c b.c -o test
    
    all: gotool
    	@go build -v .
    clean:
    	rm -f apiserver
    	find . -name "[._]*.s[a-w][a-z]" | xargs -i rm -f {}
    gotool:
    	gofmt -w .
    	go tool vet . |& grep -v vendor;true
    ca:
    	openssl req -new -nodes -x509 -out conf/server.crt -keyout conf/server.key -days 3650 -subj "/C=DE/ST=NRW/L=Earth/O=Random Company/OU=IT/CN=127.0.0.1/emailAddress=xxxxx@qq.com"
    
    help:
    	@echo "make - compile the source code"
    	@echo "make clean - remove binary file and vim swp files"
    	@echo "make gotool - run go tool 'fmt' and 'vet'"
    	@echo "make ca - generate ca files"
    
    .PHONY: clean gotool ca help
    

    上面的 Makefile 文件中,.PHONY 是个伪目标,形式上是一个目标,但是不需要依赖,伪目标一般只是为了执行目标下面的命令(比如 clean 就是伪目标)。@ 放在行首,表示不打印此行。默认在编译的过程中,会把此行的展开效果字符串打印出来。

    上面的 Makefile 实现了如下功能:

    • make:执行 go build -v . 生成 Go 二进制文件
    • make gotool:执行 gofmt -w .go tool vet .(格式化代码和源码静态检查)
    • make clean:做一些清理工作:删除二进制文件、删除 vim swp 文件
    • make ca:生成证书
    • make help:打印 help 信息
    package main
    
    import (
    	"encoding/json"
    	"fmt"
    	"os"
    	"runtime"
    
    	"github.com/spf13/pflag"
    )
    
    var (
    	version = pflag.BoolP("version", "v", false, "show version info.")
    )
    
    var (
    	gitTag       string = ""
    	gitCommit    string = "$Format:%H$"          // sha1 from git, output of $(git rev-parse HEAD)
    	gitTreeState string = "not a git tree"       // state of git tree, either "clean" or "dirty"
    	buildDate    string = "1970-01-01T00:00:00Z" // build date in ISO8601 format, output of $(date -u +'%Y-%m-%dT%H:%M:%SZ')
    )
    
    // Info contains versioning information.
    type Info struct {
    	GitTag       string `json:"gitTag"`
    	GitCommit    string `json:"gitCommit"`
    	GitTreeState string `json:"gitTreeState"`
    	BuildDate    string `json:"buildDate"`
    	GoVersion    string `json:"goVersion"`
    	Compiler     string `json:"compiler"`
    	Platform     string `json:"platform"`
    }
    
    // String returns info as a human-friendly version string.
    func (info Info) String() string {
    	return info.GitTag
    }
    
    func Get() Info {
    	return Info{
    		GitTag:       gitTag,
    		GitCommit:    gitCommit,
    		GitTreeState: gitTreeState,
    		BuildDate:    buildDate,
    		GoVersion:    runtime.Version(),
    		Compiler:     runtime.Compiler,
    		Platform:     fmt.Sprintf("%s/%s", runtime.GOOS, runtime.GOARCH),
    	}
    }
    
    func main() {
    	pflag.Parse()
    	if *version {
    		v := Get()
    		marshalled, err := json.MarshalIndent(&v, "", "  ")
    		if err != nil {
    			fmt.Printf("%v\n", err)
    			os.Exit(1)
    		}
    
    		fmt.Println(string(marshalled))
    		return
    	}
    
    }
    
    
    SHELL := /bin/bash
    BASEDIR = $(shell pwd)
    
    # build with verison infos
    versionDir = "apiserver/pkg/version"
    gitTag = $(shell if [ "`git describe --tags --abbrev=0 2>/dev/null`" != "" ];then git describe --tags --abbrev=0; else git log --pretty=format:'%h' -n 1; fi)
    buildDate = $(shell TZ=Asia/Shanghai date +%FT%T%z)
    gitCommit = $(shell git log --pretty=format:'%H' -n 1)
    gitTreeState = $(shell if git status|grep -q 'clean';then echo clean; else echo dirty; fi)
    
    ldflags="-w -X ${versionDir}.gitTag=${gitTag} -X ${versionDir}.buildDate=${buildDate} -X ${versionDir}.gitCommit=${gitCommit} -X ${versionDir}.gitTreeState=${gitTreeState}"
    
    all: gotool
    	@go build -v -ldflags ${ldflags} .
    clean:
    	rm -f apiserver
    	find . -name "[._]*.s[a-w][a-z]" | xargs -i rm -f {}
    gotool:
    	gofmt -w .
    	go tool vet . |& grep -v vendor;true
    ca:
    	openssl req -new -nodes -x509 -out conf/server.crt -keyout conf/server.key -days 3650 -subj "/C=DE/ST=NRW/L=Earth/O=Random Company/OU=IT/CN=127.0.0.1/emailAddress=xxxxx@qq.com"
    
    help:
    	@echo "make - compile the source code"
    	@echo "make clean - remove binary file and vim swp files"
    	@echo "make gotool - run go tool 'fmt' and 'vet'"
    	@echo "make ca - generate ca files"
    
    .PHONY: clean gotool ca help
    

    其中 gitTaggitCommitgitTreeState 等变量的值是通过 -ldflags -X importpath.name=value 在编译时传到程序中的。为此我们需要在编译时传入这些信息,并在 go build 中添加这些 flag

    go build -v -ldflags ${ldflags} .
    

    -w 为去掉调试信息(无法使用 gdb 调试),这样可以使编译后的二进制文件更小。

    $ ./apiserver -v
    
    {
      "gitTag": "7322949",
      "gitCommit": "732294928b3c4dff5b898fde0bb5313752e1173e",
      "gitTreeState": "dirty",
      "buildDate": "2018-06-05T07:43:26+0800",
      "goVersion": "go1.10.2",
      "compiler": "gc",
      "platform": "linux/amd64"
    }
    

    我们可以将这些信息写在配置文件中,程序运行时从配置文件中取得这些信息进行显示。但是在部署程序时,除了二进制文件还需要额外的配置文件,不是很方便。或者将这些信息写入代码中,这样不需要额外的配置,但要在每次编译时修改代码文件,也比较麻烦。Go 官方提供了一种更好的方式:通过 -ldflags -X importpath.name=value(详见 -ldflags -X importpath.name=value)来给程序自动添加版本信息。https://golang.org/cmd/link/

    package main
    
    import "fmt"
    
    var (
        VERSION    string
        BUILD_TIME string
        GO_VERSION string
    )
    
    func main() {
        fmt.Printf("%s\n%s\n%s\n", VERSION, BUILD_TIME, GO_VERSION)
    }
    

    编译命令

    go build -ldflags "-w -s  -X main.VERSION=1.0.0 -X 'main.BUILD_TIME=`date`' -X 'main.GO_VERSION=`go version`'"
    

    因为 datego version 的输出有空格,所以 main.BUILD_TIMEmain.GO_VERSION 必须使用引号括起来

    • -w 去掉 DWARF 调试信息,得到的程序就不能用 gdb 调试了。

    • -s 去掉符号表,panic 时候的 stack trace 就没有任何文件名/行号信息了,这个等价于普通C/C++ 程序被 strip 的效果, -w -s 如果使用这两个将会看不见文件名、行号, 对于调试不利 gdb 看不到源码

    • -X 设置包中的变量值

    gcflags

    • -N 参数代表禁止优化;
    • -l 参数代表禁止内联;

    go 在编译目标程序的时候会嵌入运行时( runtime)的二进制,禁止优化和内联可以让运行时(runtime)中的函数变得更容易调试。

    go build -gcflags='all=-N -l' main.go
    
    展开全文
  • Linux 系统目录结构介绍

    千次阅读 2021-06-13 08:09:07
    1.目录结构 2.常见目录说明 3.绝对路径与相对路径 4.家目录的概念 1. 目录结构      Linux 系统的目录结构是一颗倒状树。      ①. 目录结构      ...

    目录

    1.目录结构
    2.常见目录说明
    3.绝对路径与相对路径
    4.家目录的概念

    1. 目录结构

         Linux 系统的目录结构是一颗倒状树。
         ①. 目录结构
    在这里插入图片描述
         ②. 终端命令显示目录
    在这里插入图片描述

    2. 常见目录说明

         ①. /bin :存放常用命令(即二进制可执行程序)

         ②. /etc :存放系统配置文件

         ③. /home :所有普通用户的家目录

         ④. /root :管理员用户的家目录

         ⑤. /usr :存放系统应用程序及文档

         ⑥. /proc :虚拟文件系统目录,以进程为单位存储内存的映射

         ⑦. /dev :存放设备文件

         ⑧. /mnt :临时挂载点

         ⑨. /lib :存放库文件

         ⑩. /boot :系统内核及启动有关的文件

         ⑪. /tmp :存放各种临时文件,是所有用户均可访问的地点

         ⑫. /var :存放系统运行中常改变的文件,如系统日志

    3. 绝对路径与相对路径

    3.1 绝对路径

         ①. 绝对路径:是从系统根目录(“ / ”)开始到指定位置的路径。

         ②. 参考示例:以绝对路径位置表示 c217 的位置 /home/wartensie/c217。
    在这里插入图片描述
    3.2 相对路径

         ①. 相对路径:是从当前目录开始到指定位置的相对路径

         ②. 参考示例:(1)“ . ” 代表当前位置。(2)“ … ” 代表当前位置的上一层目录。(3)“ ./c217/day01 ” 代表当前位置下的 c217 目录下的 day01 目录。
    在这里插入图片描述

    4. 家目录的概念

    4.1 家目录

         ①. 家目录:所有普通用户都在 “ /home ” 下以该用户的用户名创建了一个目录,该目录就是此用户的家目录。

         ②. 参考示例:wartensie 用户的家目录就是:/home/wartensie。
    在这里插入图片描述
    4.2 注意事项

         每个用户只能在自己的家目录下创建文件、修改文件等,不能访问其他用户的家目录,更不能修改其他用户家目录中的文件

    展开全文
  • Linux目录结构详解(最全最详细版)

    千次阅读 2021-05-13 22:15:34
    对于每一个Linux学习者来说,了解Linux文件系统的目录结构,是学好Linux的至关重要的一步.,深入了解linux文件目录结构的标准和每个目录的详细功能,对于我们用好linux系统只管重要,下面我们就开始了解一下linux...
  • vue项目目录结构详解

    千次阅读 2022-05-18 17:08:43
    |-- build 构建脚本目录 |--build.js ---- 生产环境构建脚本 |--build-server.js ---- 运行本地构建服务器,可以访问构建后的页面 |--dev-client.js ---- 开发服务器热重载脚本,主要用来实现开发阶段的页面自动...
  • Linux目录结构——树形目录结构

    千次阅读 2020-11-02 09:09:02
    Linux目录结构——树形目录结构 根目录:所有目录分区、目录、文件等位置起点 整个树形目录结构中,使用独立的一个“/” 常见的子目录: /root /bin /boot /dev /etc /home /var /usr /sbin 查看文件内容...
  • 文件系统是操作系统用于明确存储设备(常见的是磁盘,也基于NAND Flash的固态硬盘)或分区上的文件的方法和数据结构;即在存储设备上组织文件的方法。操作系统中负责管理和存储文件信息的软件机构称为文件管理系统...
  • *理解JavaWeb目录结构

    千次阅读 2021-04-30 21:15:17
    额外了解到的java项目常见目录结构3.搜索controller的时候出现三层架构总结 前言 最近在做毕设题目自己拟好后,在网上找了很多开源项目,但是发现一些很规整的javaweb的目录结构不是太懂 我想弄清楚: 写目录结构的...
  • [ linux ] 文件系统和目录结构详解

    千次阅读 多人点赞 2021-12-07 20:29:21
    1、Linux目录结构的特点 Linux采用的是树型结构。最上层是根目录,其他的所有目录都是从根目录出发而生成的。 微软的DOS和windows也是采用树型结构,但是在DOS和 windows中这样的树型结构的根是磁盘分区的盘符,...
  • 数据结构:八大常见数据结构

    千次阅读 2019-11-26 14:42:39
    数据结构目录: 一、结构分类 二、区别联系 1. 数组 2. 栈 3. 队列 4. 链表 5. 树 6. 散列表 7. 堆 8. 图 数据结构是指,相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成...
  • Spring开发项目常用目录结构

    千次阅读 2020-01-07 12:04:29
    Spring项目目录结构说明推荐工程结构示例一、代码层的结构二、资源resources文件的结构 Boot框架对工程结构并没有什么特殊的限制,只是良好的工程结构划分可以使项目更清晰,明确,减少不必要的冲突,提高代码的统一性. ...
  • 设置wps如何自动生成论文目录结构

    千次阅读 2021-12-02 13:49:11
    1、首先在已的文档中自动生成目录结构 点击->导航栏->引用->目录-点击自动目录,这些操作完成后,就自动生成自己想要的目录树了。见图如下: 2、常见的编写过程中添加目录 首先定义章节:在开始->...
  • iOS 项目目录结构

    千次阅读 2016-02-20 13:21:16
    由于近期离职进行中,特整理目前负责的现有项目的目录结构和程序架构(MVC),程序架构后期整理。 目的: 第一,方便现有同事后期开发; 第二,方便后期自己开发; 第三,方便这方面需要的开发人员参考。 ...
  • 数据结构有什么用? 常见的数据结构 栈 队列 数组 链表 红黑树
  • python项目目录结构

    千次阅读 2020-02-16 16:21:01
    python 项目目录结构 目录组织方式 假设你的项目名为foo, 我比较建议的最方便快捷目录结构这样就足够了: Foo/ |-- bin/ | |-- foo | |-- foo/ | |-- tests/ | | |-- init.py | | |-- test_main.py | | | |-- init.py...
  • SVN 常用目录结构说明

    千次阅读 2018-07-18 17:03:00
    SVN是开发常用的版本控制工具,目录结构一般是:branches, tags, trunk trunk : 主干,当前开发的主项目,一般公司里进行开发的时候都是在主干里进行的 branches : 1)分支目录,添加非主线的功能的时候使用,...
  • CentOS7目录结构详细版

    万次阅读 多人点赞 2018-08-19 17:15:03
    原文地址:http://www.cnblogs.com/ellisonDon/archive/2012/10/03/2710730.html 原文地址:... linux 目录分类 CentOS的目录大体上可分为四类:管理类、用户类、应用程序类、信息类文件目录。 ...
  • Ubuntu文件目录结构详解

    万次阅读 多人点赞 2017-11-23 17:06:00
    1、对于每一个Linux Ubuntu系统学习者来说,了解Linux文件系统的目录结构是学好Linux的至关重要的一步.,深入了解linux文件目录结构的标准和每个目录的详细功能,对于我们用好linux系统只管重要,下面我们就开始了解...
  • 树形结构目录

    2014-05-06 18:45:28
    该文件包含中常见的树形结构目录,主要思想为创建CNLTreeMenu,然后实例化信息MyCNLTreeMenu1.InitCss。
  • JavaWeb项目目录结构

    万次阅读 2015-08-14 17:24:44
    Java Web项目的目录结构
  • Linux内核目录结构介绍(超详细)

    千次阅读 多人点赞 2019-09-25 14:45:30
    现在介绍一下Linux内核(kernel)的目录结构。 内核在系统目录下的路径,一般为:/usr/src/(我的ubuntu下测试的) 你也可以自己在/home目录下创建一个文件夹命名为work,作为自己开发内核的工作目录,...
  • 基于maven的Java项目目录结构总结

    千次阅读 2019-12-20 11:41:52
    基于Maven模板构建的三种常见Java项目2.1 maven工程样例 maven-archetype-quickstart 目录结构2.2 maven工程样例 maven-archetype-webapp2.3 maven工程样例 cocoon-22-archetype-webapp3. Maven 的41种骨架功能介绍...
  • python 项目目录结构

    万次阅读 多人点赞 2019-01-18 15:48:08
    关于如何组织一个较好的Python工程目录结构,已经一些得到了共识的目录结构。在Stackoverflow的这个问题上,能看到大家对Python目录结构的讨论。 这里面说的已经很好了,我也不打算重新造轮子列举各种不同的方式...
  • github上项目的目录结构说明

    千次阅读 2020-07-23 18:29:48
    .gitignore 哪些文件不要上传到 GitHub .gitattributes 文件属性,如 EOL、是否为二进制等 LICENSE 授权协议 README.md 自述文件,里面至少得写: 项目的特色 各种 Badge 比如 CI 的 怎么下载安装 示例运行/使用 ...
  • SpringBoot项目标准的目录结构

    千次阅读 2020-06-16 00:12:38
    SpringBoot项目标准目录结构。【附】 常见的vue前端项目结构
  • 补充:现在的dao文件夹下,一般的开发中还会一个接口类,而UserDao也会被命名为UserDaoImpl接口实现类。
  • Python工程目录结构

    千次阅读 2019-02-13 21:51:47
    软硬件环境 windows 10 64bit pycharm miniconda with python 3.7.1 ...作为一名编码人员,基本上都会遇到需要去接手一些过往的工程项目,面对一些组织结构混乱,代码编写我行我素的项目,是不是很冲动想骂娘?虽...
  • nginx目录结构和配置文件详解

    千次阅读 2022-04-11 14:12:51
    nginx目录结构和配置文件详解 0x00 Nginx 目录结构 Nginx 文件结构比较简洁,主要包括配置文件和二进制可执行程序,通过安装包形式安装的 nginx 文件结构跟各 Linux 发行版目录规则存放配置文件和二进制文件的位置...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 387,935
精华内容 155,174
热门标签
关键字:

常见的目录结构有哪些