DEV Community: Linda_pp

TIL: window.setImmediate() has gone

Linda_pp — Sun, 20 Jan 2019 17:34:41 +0000

window.setImmediate was non-standard browser API to execute given function as soon as possible in another JavaScript context.
But Chrome removed this.

VM237:1 Uncaught ReferenceError: setImmediate is not defined

The alternative is window.queueMicrotask(), which was defined by WHATWG as standard spec.

https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#microtask-queuing

window.queueMicrotask(() => console.log('this code runs as soon as possible!'));

TIL: How to Resolve Go Import Paths in Go

Linda_pp — Sat, 01 Dec 2018 17:33:03 +0000

Go import path is corresponding to one directory in filesystem. For example, import "fmt" is resolved to /usr/local/opt/go/libexec/src/fmt (opt is a symlink to directory of the latest Go installation by Homebrew) in my environment.

I needed to resolve the import paths in Go.

At first, I tried go/ast and go/types packages. They both have ast.Package, ast.ImportSpec and types.Package structs. But none of them has the directory path of package. They only have its path (e.g. "fmt").

But Go compiler resolves each import paths. To know how it does, I explored Go sources. Type checker needs to resolve import paths to know types of symbols from external package. So it must resolve import paths.

Actually resolving paths is done in Importer interface value in type checking. There are three types of importers provided by Go standard library; gc, gccgo and source, where gc is for a standard Go compiler, gccgo is for cgo, and source is for static analysis tools.
source seemed to match to my use case.

Implementation of source importer is in go/internal package.

https://github.com/golang/go/blob/624e197c71b673f0b3ebc57f774536131b4f0f26/src/go/internal/srcimporter/srcimporter.go#L23

And I found how it resolves import paths.

bp, err := p.ctxt.Import(path, srcDir, 0)

where ctxt is instance of go/build.Context. It utilizes go/build.Context.Import method.

https://golang.org/pkg/go/build/#Context.Import

Let's see if it gives what I want:

package main

import (
    "fmt"
    "go/build"
)

func main() {
    // Use default context
    ctx := build.Default

    for _, importPath := range []string{
        "fmt",
        "github.com/pkg/errors",
    } {
        pkg, err := ctx.Import(importPath, ".", build.FindOnly)
        if err != nil {
            panic(err)
        }
        fmt.Println(importPath, "->", pkg.Dir)
    }
}

Output:

fmt -> /usr/local/Cellar/go/1.11.2/libexec/src/fmt
github.com/pkg/errors -> /Users/rhysd/.go/src/github.com/pkg/errors

Yay! I finally could resolve import paths into directory paths.

Setting build.FindOnly flag is better to avoid cost to collect the entire package information.

Note: Go version is 1.11.2

TIL: Pitfall on getting all environment variables in Go

Linda_pp — Tue, 13 Nov 2018 15:24:58 +0000

Hello, this is my first post at DEV.TO 🐶

To get the list of all environment variables in Go, I found a function to do that in standard libraries

os.Environ()

Environ returns a copy of strings representing the environment, in the form "key=value".

Using this function, I tried to write a function to get all environment variables key-value pairs in map[string]string.

Bad example 😣

I at first wrote following code.

kv := os.Environ()
m := make(map[string]string, len(kv))
for _, s := range kv {
    if idx := strings.IndexRune(s, '='); idx >= 0 {
        m[s[:idx]] = s[idx+1:]
    }
}

// `m` is what I wanted!

This example looked working fine at first, however later I found in some case it did not work only on Windows.

I found that the m contains empty string key "" and checked the output from os.Environ() line by line. And finally I found the cause.

=C:=C:\path\to\current\dir

What's this? But environment variable $=C: was actually existing on system. It was a hidden environment variable not listed in output of set command.

I dug Go standard library and found a comment (thank you @mattn for helping me to find out this!).

https://github.com/golang/go/blob/50bd1c4d4eb4fac8ddeb5f063c099daccfb71b26/src/syscall/env_windows.go#L58-L60

Environment variables can begin with =
so start looking for the separator = at j=1.
https://blogs.msdn.com/b/oldnewthing/archive/2010/05/06/10008132.aspx

The post in the comment, What are these strange =C: environment variables? explained what $=C: is.

Okay, so the command processor sets these things, but what are they? They are a leftover from the command processor's attempt to mimic the old MS-DOS way that drives and directories were handled. Whereas in Win32, there is only one current directory, in MS-DOS, there was one current directory for each drive.

So this is a hidden special environment variable on Windows and I need to consider it on getting all environment variables.

Good example 😆

Fortunately, fix was easy. = is at first character, and environment variable name is never empty. So we can simply ignore the first character.

kv := os.Environ()
m := make(map[string]string, len(kv))
for _, s := range kv {
    // On Windows, environment variable names may start with '=' (e.g. =C:).
    // To handle the variables properly, skip first character of KEY=VALUE line.
    for i := 1; i < len(s); i++ {
        if s[i] == '=' {
            m[s[:i]] = s[i+1:]
            break
        }
    }
}

// `m` is what I wanted!