golang | Golang语言学习，其中包含豆瓣歌曲爬虫代码

According to the Go memory model:

https://golang.org/ref/mem

There are no guarantees that one goroutine will see the operations performed by another goroutine unless there is an explicit synchronization between the two using channels, mutex. etc.

In your example: the fact that a goroutines sees done=true does not imply it will see a set. This is only guaranteed if there is explicit synchronization between the goroutines.

The sync.Once probably offers such synchronization, so that's why you have not observed this behavior. There is still a memory race, and on a different platform with a different implementation of sync.Once, things may change.

Azure Cosmos db is only supporting Unicode or ASCII in x-ms-documentdb-partitionkey while github.com/vippsas/go-cosmosdb package is using json.Marshal which internally transforms Unicode to Chinese characters automatically.

The only way to solve it is using English as partition key when creating documents.

If you plan to write a lot of WASM in Go, you might want to consider compiling with TinyGo, which is a Go compiler for embedded and WASM.

TinyGo supports a //export or alias //go:export comment directive that does what you're looking for.

I'm copy-pasting the very first example from TinyGo WASM docs:

1. It is the main method, so there is no need to cleanup. When main returns, the program exits. If this wasn't the main, then you would be correct.

2. There is no best practice that fits all use cases. The code you show here is a very common pattern. The function creates a goroutine, and returns a channel so that others can communicate with that goroutine. There is no rule that governs how channels must be created. There is no way to terminate that goroutine though. One use case this pattern fits well is reading a large resultset from a database. The channel allows streaming data as it is read from the database. In that case usually there are other means of terminating the goroutine though, like passing a context.

3. Again, there are no hard rules on how channels should be created/closed. A channel can be left open, and it will be garbage collected when it is no longer used. If the use case demands so, the channel can be left open indefinitely, and the scenario you worry about will never happen.

Scan places the value into the pointer to a variable you've given it (via &c), and returns a database transaction object. You're calling that transaction object items, which it isn't. The items (ie, the contents of your cart) are in c *Cart, not in the thing returned by Scan.

Your method modifies c by filling it, it doesn't have to return anything, unless you want to return the error that Scan may return.

Instead of this...

Moving data over a channel:

You should check for errors when doing statement.Exec() as well as that would've pointed you to the actual error.

The problem lies where you do CURRRENT_TIMESTAMP instead of CURRENT_TIMESTAMP (note number of Rs in CURRENT) and not using the DEFAULT keyword for ReviewID.

The syntax for creating a table is documented here: https://www.sqlite.org/lang_createtable.html

You may have luck using yaml for your input:

Your Run() does not have any parameters defined. Try func Run(list []string)

Good job on writing tests for your project.