Problem​

I was trying to run a Makefile in VSCode and I got the following error:

Makefile:4: *** missing separator.  Stop.

Solution​

The problem is that the Makefile is using tabs instead of spaces. To fix this, you can:

1. Open the Makefile in VSCode
2. Open the command palette with Ctrl + Shift + P or View > Command Palette. If you are using a Mac, you can use Cmd + Shift + P
3. Search for Convert Indentation to Tabs

If you want to prevent this from happening in the future, you can:

1. Open settgings in VSCode with Ctrl + , or File > Preferences > Settings. If you are using a Mac, you can use Cmd + ,
2. Search for Insert Spaces
3. Uncheck the box for Editor: Insert Spaces

Problem​

It's a common problem to count the number of (visible) characters in a string.

In Golang, we can use utf8.RuneCountInString() function to count the number of characters in a string.

It works well for most cases, including multi-byte characters like Chinese.

Code example​

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    str := "abc世界"
    fmt.Println(utf8.RuneCountInString(str)) // 5
}

But if the string contains emoji characters like 👉🏻, then in some cases this function will not calculate correctly.

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    emojiWorld := "🌍"
    fmt.Println(utf8.RuneCountInString(emojiWorld)) // 1  ✅ no problem

    emojiHand := "👉"
    fmt.Println(utf8.RuneCountInString(emojiHand)) // 1  ✅ no problem

    emojiHandBlack := "👉🏿"
    fmt.Println(utf8.RuneCountInString(emojiHandBlack)) // 2 ❌ Got 2, expected 1.

    emojiOne := "1️⃣"
    fmt.Println(utf8.RuneCountInString(emojiOne)) // 3 ❌ Got 3, expected 1.
}

You can copy the emoji from here emojipedia.

Why​

This is because some emoji are composed of multiple unicode characters (Code Points), while the utf8.RuneCountInString() function only counts the number of unicode characters.

For example, 1️⃣ this emoji is composed of 3 Code Points, which are:

Rendered by Markdown Table

Solution​

So we need to count the number of Grapheme Clusters instead of Code Points.

Use third-party library rivo/uniseg​

package main

import (
    "fmt"

    "github.com/rivo/uniseg"
)

func main() {
    emojiWorld := "🌍"
    fmt.Println(uniseg.GraphemeClusterCount(emojiWorld)) // 1  ✅ 没有问题

    emojiHand := "👉"
    fmt.Println(uniseg.GraphemeClusterCount(emojiHand)) // 1  ✅ 没有问题

    emojiHandBlack := "👉🏿"
    fmt.Println(uniseg.GraphemeClusterCount(emojiHandBlack)) // 1  ✅ 没有问题

    emojiOne := "1️⃣"
    fmt.Println(uniseg.GraphemeClusterCount(emojiOne)) // 1  ✅ 没有问题
}

Reference​

Go で文字数をカウントする 在 Go 中计算字符数

文字数をカウントする 7 つの方法

Go: Unicode と rune 型

背景​

在 labstack/gommon 的代码中 看到了这个库 valyala/fasttemplate, 于是就去 调查了一下。

什么是 fasttemplate​

fasttemplate 是一个高效的 Go 模板引擎，比 Go 标准库的模板引擎 text/template 快很多，

而且比 strings.Replace, strings.Replacer 和 fmt.Fprintf 都要快。

具体可以看一下 fasttemplate 的 benchmark。

fasttemplate 的使用​

基础用法​

    template := "http://{{host}}/?q={{query}}&foo={{bar}}{{bar}}"
    t := fasttemplate.New(template, "{{", "}}")
    s := t.ExecuteString(map[string]interface{}{
        "host":  "google.com",
        "query": url.QueryEscape("hello=world"),
        "bar":   "foobar",
    })
    fmt.Printf("%s", s)

    // Output:
    // http://google.com/?q=hello%3Dworld&foo=foobarfoobar

高阶用法​

    template := "Hello, [user]! You won [prize]!!! [foobar]"
    t, err := fasttemplate.NewTemplate(template, "[", "]")
    if err != nil {
        log.Fatalf("unexpected error when parsing template: %s", err)
    }
    s := t.ExecuteFuncString(func(w io.Writer, tag string) (int, error) {
        switch tag {
        case "user":
            return w.Write([]byte("John"))
        case "prize":
            return w.Write([]byte("$100500"))
        default:
            return w.Write([]byte(fmt.Sprintf("[unknown tag %q]", tag)))
        }
    })
    fmt.Printf("%s", s)

    // Output:
    // Hello, John! You won $100500!!! [unknown tag "foobar"]

背景&目的​

项目中使用的第三方服务（Shopify）的 API 隔几个月就会发布新版本。

为了及时对应 API 变化，我们希望在该服务的 API 的 RSS 有更新时，能够及时收到通知。

但是 Lark（飞书）并没有提供 RSS 订阅的功能，所以我们需要通过其他方式实现。

实现方法​

通过 Zapier 将 RSS 新文章通知发送到 Lark（飞书）Webhook。

Zapier 是一个在线的自动化工作流程工具，可以将不同的应用程序连接起来，实现自动化工作流程。

实现步骤​

0. 前提条件​

• Lark（飞书）中创建一个接受通知的 Group，并设置 Webhook，用于接收通知。

1. Zapier 中创建一个 Zap​

分 2 步：

• 1️⃣ 添加 RSS by Zapier, 填入 Shopify API RSS 地址, 用于获取 RSS 新文章通知。(图 1)

• 2️⃣ 添加 Code by Zapier, 通过编写代码将 RSS 新文章发送到 Lark（飞书）Webhook。(图 2)

  • 如果是付费用户的话，可以使用 Webhook by Zapier 替代 Code by Zapier，省得写代码。
  • 代码语言支持 JavaScript 和 Python，这里用的是 JavaScript。

图 1 图 2

图 2 中的设置如下：

• 1️⃣ 添加变量 Webhook，用于存放 Lark（飞书）Webhook 地址。
• 2️⃣ 添加变量 Data，用于存放 RSS 新文章通知。 具体存放什么东西可以自己选择，这里存放的是 Title 和 Link等。
• 3️⃣ 代码如下：

// 获取设置的变量
let Webhook = inputData.Webhook.trim();
let Method = "POST";

// 发送给 Webhook 的 JSON 对象 （注意格式要符合 Lark（飞书）Webhook 的要求）
let JSONObject = {
  msg_type: "text",
  content: { text: inputData.Data },
};

// creates the Method, Headers, and Body of the HTTP POST Request
let Options = {
  method: Method,
  headers: {
    Accept: "application/json",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(JSONObject),
};

const Request = await fetch(Webhook, Options); // HTTP POST Request
const Response = await Request.json(); // HTTP POST Response

output = { Response, Request, Webhook, Method };

References​

Make a HTTP POST Request to Fire a Webhook with Headers and Parameters via a Zap Code Step

0. Manim 是什么？​

Manim 是一个用于创建数学动画的库，它是由 3Blue1Brown 的Grant Sanderson @X开发的。

Manim 的目标是提供一个用于创建数学动画的简单、快速且强大的工具。

它是一个用 Python 编写的开源项目，它的代码托管在 GitHub 上。

1. 最简单快速的安装方法： 利用 GitHub Codespaces​

1). 打开(或者 fork)我配置好的仓库 wifecooky/manim-devcontainer,​

1️⃣ 点击右上角的 Code 按钮， 2️⃣ 选择 Open with Codespaces，等待构建完成后，就可以在浏览器中使用 Manim 了。

2). 测试一下​

1️⃣ : 打开 example_scenes.py 文件。

2️⃣ : 在 terminal 运行 manim -ql example_scenes.py SquareToCircle。

3️⃣ : 等待运行完成，就可以在 media/videos 目录下看到生成的视频了。

2. 本地最快速的安装方法： 利用 Docker​

0). 安装 Docker​

已经安装过的请跳过这一步。

1). 拉取 Manim 镜像​

docker pull manimcommunity/manim

2). 使用 Docker 启动本地 JupyterLab​

docker run -it -p 8888:8888 manimcommunity/manim jupyter lab --ip=0.0.0.0

3). 打开 JupyterLab 链接并创建一个新的 Notebook​

4). 测试一下​

1️⃣ : 在 Notebook 中运行以下代码

%%manim -qm -v WARNING SquareToCircle

class SquareToCircle(Scene):
   def construct(self):
      square = Square()
      circle = Circle()
      circle.set_fill(PINK, opacity=0.5)
      self.play(Create(square))
      self.play(Transform(square, circle))
      self.wait()

Reference​

Manim easy Installation for all operating systems (Windows, Linux, Mac OS)

docker manimcommunity/manim

Problem​

Docusaurus（3.0） 的文档侧边栏默认是按文件的创建日期的升序排列的。

Docuaurus v3 's docs sidebar is sorted by the creation date of the file by default.

It's not very convenient for me to manage and find docs, so I want to reverse the order of the sidebar items.

Solution​

Modify the docusaurus.config.js file as follows:

+// Reverse the sidebar items ordering (including nested category items)
+function reverseSidebarItems(items) {
+  // Reverse items in categories
+  const result = items.map((item) => {
+    if (item.type === 'category') {
+      return {...item, items: reverseSidebarItems(item.items)};
+    }
+    return item;
+  });
+  // Reverse items at current level
+  result.reverse();
+  return result;
+}

 /** @type {import('@docusaurus/types').Config} */
 const config = {
   title: 'thewang',
   ...
    presets: [
    [
      'classic',
      /** @type {import('@docusaurus/preset-classic').Options} */
      ({
        docs: {
          routeBasePath: 'weekly',
          sidebarPath: require.resolve('./sidebars.js'),
          showLastUpdateTime: true,
          showLastUpdateAuthor: true,
          sidebarCollapsed: false,
+          async sidebarItemsGenerator({defaultSidebarItemsGenerator, ...args}) {
+            const sidebarItems = await defaultSidebarItemsGenerator(args);
+            return reverseSidebarItems(sidebarItems);
+            return sidebarItems;
+          },
        },
        ...

References​

Customize the sidebar items generator

问题​

当你在同一台电脑上使用多个 Git 用户的时候，你可能会遇到在 commit push 之后才发现自己没有切换到正确的用户的问题。

为了避免这种情况，我们可以在终端显示当前的 Git 用户信息。

解决方案​

终端的显示信息(Shell Prompt) ，我推荐 Starship 配置来实现。

安装 Starship 可以参考官方文档, 这里就不再赘述。

配置​

安装完后在 Starship 的配置文件 ~/.config/starship.toml 中添加以下配置, 格式可以按照自己的喜好修改 format = 部分 。

format = """
...
${custom.git_username}\
...

[custom.git_username]
command = "git config user.name"
when = "[ -d .git ] && echo .git || git rev-parse --git-dir > /dev/null 2>&1"
format = ' [$symbol($output)@git]($style) '

Background​

• It is a common requirement to get the common elements between two slices, but I found that some people still use double loops to implement it during Code Review. (The time complexity is O(n^2), and the efficiency is relatively low)
• I have been using Golang recently, so I will share how to get the common elements between two slices in Golang.

❌ Code example implemented with double loops:

func intersection(nums1 []int, nums2 []int) []int {
    var result []int

    // Double loop O(n^2)
    for _, v1 := range nums1 { // O(n)  outer loop
        for _, v2 := range nums2 { // O(n) inner loop
            if v1 == v2 {
                result = append(result, v1)
            }
        }
    }
    return result
}

Improvement​

Change the element lookup in the inner loop in the above example to be implemented using set*,

so that the time complexity of the inner loop part can be reduced to O(1), and the overall time complexity can be reduced to O(n).

Implementation example using set​

func intersection(nums1 []int, nums2 []int) []int {
    var result []int

    // Convert nums2 to set, so that the time complexity of looking up elements in nums2 becomes O(1).
    //  Consider performance optimization, you can compare the number of elements in nums1 and nums2, and convert the slice with more elements into set.
    set := make(map[int]struct{}) // There is no set in Golang, use map to implement. struct{} is an empty structure to save memory.
    for _, v := range nums2 {
        set[v] = struct{}{}
    }

    // Traverse nums1, if the element in nums1 exists in nums2, add it to result
    for _, v := range nums1 {
        if _, ok := set[v]; ok {
            result = append(result, v)
        }
    }
}

Implementation using third-party libraries​

If you consider performance optimization and various types of slices, we can use the following third-party libraries to implement.

• deckarep/golang-set
• samber/lo

deckarep/golang-set​

As the name suggests, it is a set implementation in Golang.

import (
  "fmt"
  mapset "github.com/deckarep/golang-set/v2"
)

func main() {
    set1 := mapset.NewSet[string]()
    set1.Add("a")
    set1.Add("b")
    set1.Add("c")

    set2 := mapset.NewSet[string]()
    set2.Add("c")
    set2.Add("d")
    set2.Add("e")

    // 交集 intersection
    intersectionSet := set1.Intersect(set2)
    fmt.Println(intersectionSet) // Set{c}

    // Besides intersection, it also supports union, difference, symmetric difference, etc.
    // 并集 union
    unionSet := set1.Union(set2)
    fmt.Println(unionSet) // Set{a, b, c, d, e}

    // 差集 difference
    diffSet := set1.Difference(set2)
    fmt.Println(diffSet) // Set{a, b}

    // 对称差集 symmetric difference
    symDiffSet := set1.SymmetricDifference(set2)
    fmt.Println(symDiffSet) // Set{a, b, d, e}
    }

samber/lo​

If you need to sort, group, etc. in addition to intersecting slices, you can consider using the samber/lo library.

It is similar to lodash in Javascript.

import (
    "github.com/samber/lo"
)

func main() {
    // 交集 intersection
    lo.Intersection([]int{1, 2, 3}, []int{2, 3, 4}) // return []int{2, 3}

    // 并集 union
    lo.Union([]int{1, 2, 3}, []int{2, 3, 4}) //return []int{1, 2, 3, 4}

    // 差集 difference
    lo.Difference([]int{1, 2, 3}, []int{2, 3, 4}) // return []int{1}, []int{4}
}

Symmetric API testing 是啥？​

这个概念应该是源自于 Gopher Academy Blog。

作者在维护一个 Golang 的 Twitter API 客户端，为了对 Twitter 的 API 进行测试，所以作者提出了 Symmetric API testing 的概念。

简单地说就是保存 API 的返回结果，然后在测试的时候，用保存的结果来进行测试。

这样就不用编写 mock 和 测试用例了。

至于名字为什么叫 Symmetric, 是相对于传统的需要编写 mock 和 测试用例的方式 Asymmetric 而言的。

其实个人觉得把它叫做 SnapShot Testing 更为合适。

怎么实现？​

除了手动保存 API 的返回结果，还可以使用 go-vcr 这个库来实现。

大概的代码如下：

r, err := recorder.New("<filename>")
if err != nil {
    return err
}
defer r.Stop()
client.Transport = r
res, err := client.Get("http://api.twitter.com/...")
if err != nil {
    return err
}

这里提供了完整的 示例代码。

Reference​

Symmetric API Testing

Symmetric API Testing という、手間なく堅牢に外部 API Client をテストする手法

go-vcr を使った Symmetric API Testing のメモ

背景&需求​

在 Golang 中，我们经常会遇到需要解析 JSON 数据的场景，比如从 HTTP 请求中获取 JSON 数据，或者从文件中读取 JSON 数据。

通常我们会提前定义好对应的结构体，然后才能将 JSON 数据解析到结构体中。

比如：

type User struct {
    Name string `json:"name"`
    Age int `json:"age"`
}

func main() {
    jsonStr := `{"name": "wen", "age": 18}`
    var user User
    json.Unmarshal([]byte(jsonStr), &user)
    fmt.Println(user)
}

但是有时候我们并不知道 JSON 数据的结构，或者 JSON 数据的结构会经常变化，这时候我们就无法提前定义好对应的结构体。

解决方案​

可以使用 map[string]any (Golang1.18 之前的话 map[string]interface{} ) 来解析 JSON 数据，这样就不需要提前定义结构体了。

func main() {
    jsonStr := `{"name": "wen", "age": 18}`
    var user map[string]any
    json.Unmarshal([]byte(jsonStr), &user)
    fmt.Println(user)

    // 获取具体的值
    fmt.Println(user["name"])
    fmt.Println(user["age"])
}

扩展​

如果觉得 map[string]any 这种方式解析速度比较慢，可以使用 jsonparser 这个库来解析，速度会快很多。

我用 User 结构体来测试了一下，解析速度快了 8-9 倍左右 🚀 。

其他的比较大的 JSON 数据，解析速度也会快很多，具体可以看下这里的 benchmark。

// Just for emulating field access, so it will not throw "evaluated but not used"
func nothing(_ ...interface{}) {}

// 使用 jsonparser
func BenchmarkJsonParserUser(b *testing.B) {
    for i := 0; i < b.N; i++ {
        jsonparser.Get(user, "name")
        jsonparser.Get(user, "age")
        nothing()
    }
}

// 使用 map[string]any
func BenchmarkEncodingJsonInterfaceUser(b *testing.B) {
    for i := 0; i <details b.N; i++ {
        var data interface{}
        json.Unmarshal(user, &data)
        m := data.(map[string]interface{})

        nothing(m["name"].(string), m["age"])
    }
}