索鸟网

  1. 首页
  2. golang 标准库间依赖的可视化展示

golang 标准库间依赖的可视化展示


简介

国庆看完 << Go 语言圣经 >>,总想做点什么,来加深下印象.以可视化的方式展示 golang 标准库之间的依赖,可能是一个比较好的切入点.做之前,简单搜了下相关的内容,网上也要讨论,但是没有发现直接能拿过来用的.标准库之间,是必然存在依赖关系的,不同库被依赖的程度必然是不一样的.但究竟有多大差别呢?

以下内容,数据源自真实环境的 golang 1.9 版本的标准库.所以,本文不仅是一篇可视化相关的讨论文章,更是提供了一个可以直接探究 golang 标准库间依赖关系的快速梳理工具.

数据准备

标准库各个包之间的相互关系,可以直接通过命令获取,然后简单变换为一个标准的 JSON 对象:

go list -json  std

示例输出:

{
    "Dir": "/usr/local/go/src/archive/tar",
    "ImportPath": "archive/tar",
    "Name": "tar",
    "Doc": "Package tar implements access to tar archives.",
    "Target": "/usr/local/go/pkg/darwin_amd64/archive/tar.a",
    "Goroot": true,
    "Standard": true,
    "StaleReason": "standard package in Go release distribution",
    "Root": "/usr/local/go",
    "GoFiles": [
        "common.go",
        "format.go",
        "reader.go",
        "stat_atimespec.go",
        "stat_unix.go",
        "strconv.go",
        "writer.go"
    ],
    "IgnoredGoFiles": [
        "stat_atim.go"
    ],
    "Imports": [
        "bytes",
        "errors",
        "fmt",
        "io",
        "io/ioutil",
        "math",
        "os",
        "path",
        "sort",
        "strconv",
        "strings",
        "syscall",
        "time"
    ],
    "Deps": [
        "bytes",
        "errors",
        "fmt",
        "internal/cpu",
        "internal/poll",
        "internal/race",
        "io",
        "io/ioutil",
        "math",
        "os",
        "path",
        "path/filepath",
        "reflect",
        "runtime",
        "runtime/internal/atomic",
        "runtime/internal/sys",
        "sort",
        "strconv",
        "strings",
        "sync",
        "sync/atomic",
        "syscall",
        "time",
        "unicode",
        "unicode/utf8",
        "unsafe"
    ],
    "TestGoFiles": [
        "reader_test.go",
        "strconv_test.go",
        "tar_test.go",
        "writer_test.go"
    ],
    "TestImports": [
        "bytes",
        "crypto/md5",
        "fmt",
        "internal/testenv",
        "io",
        "io/ioutil",
        "math",
        "os",
        "path",
        "path/filepath",
        "reflect",
        "sort",
        "strings",
        "testing",
        "testing/iotest",
        "time"
    ],
    "XTestGoFiles": [
        "example_test.go"
    ],
    "XTestImports": [
        "archive/tar",
        "bytes",
        "fmt",
        "io",
        "log",
        "os"
    ]
}

梳理过的数据源,参见: https://raw.githubusercontent.com/ios122/graph-go/master/data.js

可视化原理

主要涉及一下内容:

  • 可视化显示,使用的是 echarts
  • 使用原始数据的 ImportPath 而不是 Name,来作为每个数据节点的唯一id.这样是因为 golang 本身的包命名规范决定的.
  • 使用原始数据的 Imports 字段,来确定标准库包与包之间的相互依赖关系.golang是不允许循环依赖的,所以一些循环依赖相关的问题,不需要考虑.
  • 节点的大小,和包被其他包引入的次数成正相关.这样做,被依赖越多的包,图上最终显示时,就会越大.常用包和不常用包,一目了然.

数据整理

就是把原始数据,处理成 echarts 需要的数据,这里简要说下最核心的思路:

  • echarts 显示相关的代码,很大程度上参考了 graph-npm
  • 节点坐标和颜色,采用随机坐标和颜色,以去除节点和包之间的联系.我认为这样处理,能更纯粹地观察标准库包与包之间的联系.
  • 需要一个 edges 来记录包与包之间的依赖关系.在每次遍历 Imports 时,动态写入.
  • 需要一个 nodes 来记录包自身的一些信息,但是其 size 参数,需要计算过所有依赖关系后再填入.
  • 使用 nodedSize 来记录每个包被依赖的次数,为了提升效率,它是一个字典Map.
 /* 将原始数据,转换为图标友好的数据. 
    ImportPath 作为唯一 id 和 标签;
    Imports 用于计算依赖关系;
    节点的大小,取决于被依赖的次数;
    */
function transData(datas){
    /* 存储依赖路径信息. */
    let edges = []

    /* 存储基础节点信息. */
    let nodes = []

    /* 节点尺寸.初始是1, 每被引入一次再加1. */
    let nodedSize = {}

    /* 尺寸单位1. */
    let unitSize = 1.5

    datas.map((data)=>{
        let itemId = data.ImportPath

        nodes.push({
            "label": itemId,
            "attributes": {},
            "id": itemId,
            "size": 1
        })

        if(data.Imports){
            data.Imports.map((importItem)=>{
                edges.push({
                    "sourceID": importItem,
                    "attributes": {},
                    "targetID": itemId,
                    "size": unitSize
                })

                if(nodedSize[importItem]){
                    nodedSize[importItem] = nodedSize[importItem] + unitSize
                }else{
                    nodedSize[importItem] = unitSize
                }
            })
        }
    })

    /* 尺寸数据合并到节点上. */
    nodes.map((item)=>{
        let itemId = item.id
        if(nodedSize[itemId]){
            item.size = nodedSize[itemId]
        }
    })

    return {
        nodes,edges
    }
}

效果与源码

相关链接

可视化 echarts golang

来源地址:https://segmentfault.com/a/1190000011469864 版权归作者所有!

相关教程

  • python标准库

    Python有一套很有用的标准库(standard library)。标准库会随着Python解释器,一起安装在你的电脑中的。它是Python的一个组成部分。这些标准库是Python为你准备好的利器,可以让编程事半功倍。 我将根据我个人的使用经验中,挑选出标准库三个方面的包(package)介绍:Python增强系统互动网络 第一类:Python增强Pytho
  • C++STL标准模板库

    标准模板库STL STL(Standard Template Library,标准模板库)以模板为基础,所以能用于任何数据结构和结构。 顺序容器:组织成对象的有限线性集合,所有对象都是同一类型。 vector(向量)、list(线性表)、deque(双端队列)   关联容器:提供了基于关键字(Key)快速检索数据的能力。 set(集合)、
  • Pod 依赖库建立

    Pod 依赖库建立 以下已HelloPod依赖库为例创建工程库文件 pod lib create HelloPod 打开生成的工作区文件,如果HelloPod需要添加某些依赖,则直接往Podfile中进行添加直接即可,添加完成之后注意工程编译的有效性 修改HelloPod.podspec文件,添加响应的工程网络路径 第三步完之后执行pod lib lint 检测podspec文件的有效性 将
  • C++标准库中各种排序归纳

    一、简介所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作。我们在编程过程中会经常接触到排序,比如游戏中的排行榜等。C++标准库中提供了各种不同的排序算法,这篇博客将逐一介绍。还有在什么场景下,具体该使用哪一个排序算法效率更高。二、算法1. sort原型: template<typename iterator
  • 将代码及依赖的静态库编译为新静态库

    将代码及依赖的静态库编译为新静态库 最近需要在一个开源库上实现一个新功能并封成新的lib。 方法: 将代码编译为.o 使用ar -x 将依赖的静态库拆成.o 使用ar -rcs 将.o编译生成新的.a 一些参数设置 AR:=(CPP)(CPP) (CFLAGS) (AR)−x../libboostrandom.a(AR) -x ../libboost_random.a (AR)
  • python标准库学习之Built-in Functions

    本文准备用临时时间,在自学的同时,翻译一部分内建标准库函数用法,同时尝试给出相应的示例代码。(本文不会一次性完成,根据自己的时间,“随时”更新)标准库版本以python 2.7.6为主。 python共包含80个内建函数,现在依次展开: abs(x):绝对值函数,返回一个数的绝对值,该数可以为素数、长整数、浮点数。如果参数x是一个复数,该函数将会返回一个复数的模。 &g
  • 第十章 Python常用标准库使用(必会)

    本章涉及标准库:1、sys2、os3、glob4、math5、random6、platform7、pikle与cPikle8、subprocess9、Queue10、StringIO11、logging12、ConfigParser13、urllib与urllib214、json15、time16、datetime10.1 sys1)sys.argv命令行参数。argv[0] #
  • C++“准”标准库Boost学习指南-variant的使用

    Variant库包含一个不同于union的泛型类,用于在存储和操作来自于不同类型的对象。这个库的一个特点是支持类型安全的访问,减少了不同数据类型的类型转换代码的共同问题。 Variant 库如何改进你的程序? 对用户指定的多种类型的进行类型安全的存储和取回在标准库容器中存储不同类型的方法变量访问的编译期检查高效的、基于栈的变量存储 Variant 库关注的是对一组限定类型