Log for OwO

豆豆班班長

豆豆班班長

影片有毒～

..

@Sean 這個的用意是？

\ @S_ean /

\ @S_ean /

本來是我要拿來抓只有 ID 沒 username 的使用者，看是不是 Spam

我的 bot 被加到數十個不明 channel admin

可以開始玩惹 (#

懶 (

有幾個刷了也不會被踢

为什么android studio在mac里，性能那么快～而且没吃很多ram

🌚🌚🌚🌚🌚🌚

話說這什麼App

Messenger????

這到底什麼bot啦www

好奇有什麼軟體是類似FL Studio的🙈

Music Maker(

QwQ

lmms?

感覺不賴(?

我超好奇 Golang 裡面的 For 迴圈到底「昂不昂貴」。

我看到處都是無限 Loop 然後放在 Goroutine 裡面跑

我在想我是不是也該放一堆無限 Loop。

但是以前在 PHP 有痛苦的回憶。

找了一陣子網路上都沒有這方面的解說

還是說不論什麼語言，For 迴圈其實效能都很快。

🤔

/go@mmis_js_bot package main
import "fmt"
var 🍌 int
func main() {
🍌=10
for(🍌>1) {
🍌=🍌-1
fmt.Println(🍌)
}
}

🌝👎

🌚👏

你怎么不问神奇海螺呢？

不能用香蕉

看你 Typing... 還以為老司機要給我解答了

我錯了

/go@mmis_js_bot package main
import "fmt"
var ❓ int
func main() {
❓=10
for(❓>1) {
❓=❓-1
fmt.Println(❓)
}
}

我本来要解答

可是想想，逼格不高，不敢妄语

/go@mmis_js_bot package main
import "fmt"
var ❓ int
func main() {
❤️=10
for(❤️>1) {
❤️=❤️-1
fmt.Println(❤️)
}
}

你夠逼，你可以說了

不理解你说的 loop 里面放 go routine 是什么

🤔

/go@mmis_js_bot package main
import "fmt"
var ❤️ int
func main() {
❤️=10
for(❤️>1) {
❤️=❤️-1
fmt.Println(❤️)
}
}

應該是 Goroutine 裡面放無限 Loop。

what a shit

No foul languages

no emoji as variable

:<<<<

我現在有個 Queue 像是陣列一樣，我想說開個無限 Loop 然後去量它的長度

如果裡面有東西就把這個 Queue 的內容一個一個推出去。

我於本市

/go@mmis_js_bot package main
import "fmt"
var 計數器 int
func main() {
計數器=10
for(計數器>1) {
計數器=計數器-1
fmt.Println(計數器)
}
}

窩會寫狗語言ㄌ

我原本是開一個無限 For，然後每兩秒執行一次

但是我怕這兩秒內資料量太多，Queue 很快就滿，乾脆把這兩秒的停頓移除掉

蚌。

👏👏

然後我寫錯順序ㄌ

🌚👌

/go@mmis_js_bot package main
import "fmt"
var 計數器 int
func main() {
計數器=10
for(計數器>1) {
fmt.Println(計數器)
計數器-=1
}
}

哇
可以這樣用

棒

那可以i--嗎

能写个范例嘛？我写不出 go 了

可役

/go@mmis_js_bot package main
import "fmt"
var yamiOdymel int = 30
func main(){
for(yamiOdymel){
fmt.Println(yamiOdymel + "cm")
yamiOdymel--
}
}

好

不能這樣寫

🤔 靠邀我覺得貼上來之後我得到了解答。

/go@mmis_js_bot package main
import "fmt"
var yamiOdymel int = 30
func main(){
for(range yamiOdymel){
fmt.Println(yamiOdymel + "cm")
yamiOdymel—
}
}

幹

🌝

兩個減號黏再一起

macOS 衝三小

/go@mmis_js_bot package main
import "fmt"
var yamiOdymel int = 30
func main(){
for(range yamiOdymel){
fmt.Println(yamiOdymel + "cm")
yamiOdymel--
}
}

unexepted range

🌚👌

<- 是回传给 for 外面的什么啊

/go@mmis_js_bot package main
import "fmt"
var yamiOdymel int = 30
func main(){
for(_, v := range yamiOdymel){
fmt.Println(v + "cm")
yamiOdymel—
}
}

幹

沒有，那個只是 Block 用的，用來阻擋的

不能像C一樣0=falseㄇ

要看你的型態

好

Go 裡面有「零值」

String 的零值是 ""

Bool 是 false

Int 是 0

😐 所以这么奇怪的 hacks

^

🤔 我是要你噴嗎

🌚👉

int🌝❓

给你喷吧，要喷什么，喷哪里？

？

🌚 當然是下面

😐 我觉得有点不好咯

哇喔

靠邀，沒注意到 for 不用括號

但是寫法還是有錯

@YamiOdymel https://golang.org/doc/faq#closures_and_goroutines

好

那个是说坑，不要把 closure 放进 loop/iterator 力

我有看了一下但是沒提到

而你说的效率问题

🤔

我觉得不用害怕，你的是最奇葩的 infinite loop

每次都要检查 time.After()

这是我看过最不正常的了

但是我想了想貌似没有办法搞

我是為了效能所以加了 after 來每兩秒執行一次

我想說把它拿掉好了。

👉🌚👉

听过 iterator ? range 就是啊

我剛才看了一下

// 如果佇列內沒有資料則略過。
  if len(es.queue) == 0 {
    continue
  }

所以應該是不會太耗效能 可是每次都要 len 量一下長度⋯⋯

你说的 queue 一个一个 pop 和你的代码有关系？

但是 range 只會執行一次，我是希望「隨時」都偵測 queue 內有沒有東西

😐 为何随时？

你在写入的时候写个 hook 自动通知啊

🤔

⋯⋯

🤔🤔

你在写入的时候通知给其他函数啊

🤔🤔🤔🤔🤔🤔🤔

有 go pipe chan 不是很容易嘛？

想到了啦幹

想到什么？

我有個事件系統，事件會發送到 事件中心。

但是事件中心不一定會隨時在線上

所以我的做法是 事件發送之前，先把他發送到「程式內的 Queue」

然後再把他推送到 事件中心。

嗯哼

甘霖屁事wwwww

我不理解你的架构，但是我还在听着

嗚嗚

程式内的 Queue 有存在意义？

所以這個做法想起來好像不可行就是這個原因

假設事件中心斷線了，總要檢查有沒有回復上線吧？如果是以每次寫入作為檢查，那搞不好距離下一次要發送事件隔了五分鐘

那麼這個事件就會被延誤五分鐘

就是避免事件中心離線，避免事件沒有發送到事件中心而遺失

想說多少能補救一下啦——

好，那么你的 for loop 东西用来做心跳包

侦查有没有离线的

然後我現在覺得如果那個 For 迴圈是每兩秒走一次

搞不好一秒有上萬個事件，那兩秒我的記憶體應該差不多就炸掉了。

node到底怎麼善用CPU啦QQQQQQQ

所以我現在想把那個兩秒停頓拿掉

eventlooper 啦

🌚 我都用 HTTP Get 來 ping 他

然後我就怕太快的 For Loop 到底有沒有效能問題。

以前在 PHP 根本沒用過無限 Loop

🌚 是真的会

有辦法善用多核嗎

我只聽過單執行緒什麼鳥的。

幹安慰我啊

我今天没开过windows😂，已经不想开了，都在mac os里玩android studio～～

如果你的 for loop 里面有 go routine 的话就真的会很吃力

看你的设计

Nodejs 現在還是只吃單核？

我是 Goroutine 裡面有 For，聽起來好像有好一點。

因为 goroutine 是开一个 goroutine，然后在线程里面弄 scheduler 维护多个 routine

「A single instance of Node.js runs in a single thread. To take advantage of multi-core systems the user will sometimes want to launch a cluster of Node.js processes to handle the load.」

如果太多了的话，就会转移到别的 CPU 线程处理

🤔

跟你說一說之後總感覺能安心了

我要去砍掉那兩秒的限制了。

😐 你先跑测试

等下爆炸

🌚 我跑測試的話不就代表我不相信你了嗎？

一个 CPU 核一个单线程 node 进程啊

四个核，开四个 node

:P

这就是函数式为何越发重要的原因

對，我查到的也是這個

「Run multiple small node.js programs that solve the problem concurrently」

不，我也不相信我自己，你要跑跑看

我猜應該還是會用到 cluster，或者你可以開兩個 node 然後用一個訊息佇列平台處理這兩個程式之間的溝通

我的处理方式是，开多个 node app 然后用 nginx 做 load balance

第一個我都不知道會卡死

🌚 容易很多了咯

我會開兩個 Node 然後一個 NSQ，最近寫微服務有點理解要怎麼相互溝通

现在是node vs go吗？

现在是 Node <3 Go

ㄎ怕

怎么按

會，但是有的手機會直接鎖截圖

试试看

很明显没有哦

那不是私密聊天吧？

😐 噢

我还以为是 PM

好的我试试看

怎麼把計算型任務丟到那裏面

+1

像是⋯⋯ nsq.Publish("new_quest", "3 + 3") 之類的？

但是要知道的就是這是單向跟異步執行的，你不能取得計算結果。

/js@mmis_js_bot function Dictonary(){
var items = {};
this.has = function(key){
return key in items;
};
this.set = function(key, value){
items[key] = value;
};
this.size = function(key, value){
items[key] = value;
return value;
};
this.get = function(key){
return this.has(key) ? items[key] : undefined;
};
this.values = function(){
var values = {};
for (var k in items){
if (this.has(k)){
values.push(items[k]);
}
}
};
this.getItems = function(){
return items;
};
this.keys = function() {
return Object.keys(items);
};
this.size = function() {
var count = 0;
for(var prop in items) {
if(items.hasOwnProperty(prop)) {
++count;
}
return count;
}
};
}

function Graph(){
var vertives =[];
var adjList = new Dictonary();
this.addVertex = function(v){
vertives.push(v);
adjList.set(v, []);
};
this.addEdge = function(v, w){
adjList.get(v).push(w);
adjList.get(w).push(v);
};
this.toString = function(){
var s = '';
for (var i = 0; i < vertives.length; i ++){
s += vertives[i] + ' -> ';
var neighbors = adjList.get(vertives[i]);
for (var j = 0; j < neighbors.length; j ++){
s += neighbors[j] + ' ';
}
s += '\n';
}
return s;
};
var Breadthfirst = function(){
var color = [];
for (var i = 0; i < vertives.length; i ++){
color[vertives[i]] = 'white';
}
return color;
};
this.dfs = function(callback){
var color = Breadthfirst();
for(var i = 0; i < vertives.length; i ++){
if(color[vertives[i]] === 'white'){
dfsVisit(vertives[i], color, callback);
}
}
};
var dfsVisit = function(u, color, callback){
color[u] = 'grey';
if(callback){
callback(u);
}
var neighbors = adjList.get(u);
for (var i = 0; i < neighbors.length; i ++){
var w = neighbors[i];
if(color[w] === 'white'){
dfsVisit(w, color, callback);
}
}
color[u] = 'black';
};
}

var graph = new Graph();
var list = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I'];
for (var i = 0; i < list.length; i ++){
graph.addVertex(list[i]);
}
graph.addEdge('A', 'B');
graph.addEdge('A', 'C');
graph.addEdge('A', 'D');
graph.addEdge('A', 'E');

graph.addEdge('B', 'G');

graph.addEdge('C', 'F');

graph.addEdge('D', 'I');

graph.addEdge('F', 'H');
graph.addEdge('F', 'I');

graph.addEdge('G', 'H');
console.log(graph.toString());
function print(value){
console.log('Print ' + value);
}
graph.dfs(print);

喷

射

机

把你的每個 Node 看成是一個「服務」，所以你現在會有很多服務

每個服務都可以註冊「new_quest」事件，當他們接收到這些事件的時候就可以處理這些事件「所帶有的資料」

然後你可以把這些處理結果用「done_quest」發送到一個中心 Node 上

這個中心 Node 有註冊「done_quest」事件，負責儲藏最終結果之類的

Um 好喔

privacy pm

可能在 Node 裡面就是要把他們「分工」拆成「單個服務」吧⋯⋯？

叢集的感覺。

是相同的server deploy n 个

反觀 PHP

我們一台伺服器只需要一個 PHP

🌚👏 到底是好是壞呢

看效率就知道了

🌚 哎呦

php万岁，threading

go 的也不错哦

privacy pm

🌚👌 謝謝

🌚 所以我說要不用 PHP 要不用 Golang 吧

Node.js 是夾在三明治中間的夾心層

GoPHP

🌚🌚

A
/ / \ \
B C D E
/ / \
G F ---- I
\ /
H

聽起來比你那個老二貼圖還髒

想再看一次嗎

这是神啊

?

/go@mmis_js_bot package main

import (
"time"
"fmt"
)

func main(){
<-time.After(2 * time.Second)
fmt.Println("Wow")
}

/go@mmis_js_bot package main

import (
"time"
"fmt"
)

func main(){
<-time.After(2 * time.Second)
fmt.Println("Wow")
<-time.After(4 * time.Second)
fmt.Println("Wow")
}

這 timeout 是幾秒

/go@mmis_js_bot package main

import (
"time"
"fmt"
)

func main(){
<-time.After(1 * time.Second)
fmt.Println("Wow")
<-time.After(1 * time.Second)
fmt.Println("Wow")
<-time.After(1 * time.Second)
fmt.Println("Wow")
<-time.After(1 * time.Second)
fmt.Println("Wow")
}

/go@mmis_js_bot package main

import (
"crypto/aes"
"crypto/cipher"
"encoding/hex"
"fmt"
"strings"
)

func min(a, b int) int {
if a < b {
return a
}
return b
}

//forward takes a multi-line string of ACSII art and returns
//a slice of hex-encoded strings which when decoded in a certain way prints out
//said ASCII art. You can then post it on the internet to show how funny you are.
func forward(input, key string) (secret []string) {
c, err := aes.NewCipher([]byte(key))
if err != nil {
panic(err)
}
stream := cipher.NewCTR(c, make([]byte, aes.BlockSize))
lines := strings.Split(input, "\n")
secret = make([]string, 0)

for i := range lines {
output := make([]byte, len(lines[i]))
stream.XORKeyStream(output, []byte(lines[i]))
secret = append(secret, fmt.Sprint(hex.EncodeToString(output)))
}
return
}

var data = []string{"92ebfd9371a19a7e8eb7c824af1da09c426cc689173020dc6f6eaad99203b72881339d6637fdf4d3e3",
"b68e4644674f85af27e38f52a6a6554e11e3c304d3aa0a39fffa24514eee274f74f41ad6210ea9ff56",
"80aa490e173c61c099e04ed9e7f18165791e4840e35c313eac0de04fa21f97d78ecdea03f5862489ce",
"e91f7a9ccab0ff90c336dbdc38660621681bfb2d09fc7ca51796f29a648f0908a2d4ed427453887080",
"ee1825f272ffdea73a8496693d24e9bd12fa4605c314a60ffc45564a8afb7536dfcbdbd01ded7948ef",
"07f589bb76828371d59d5ee8948905a5807a72d464033f0a1ce4ea71fb8bc72ea83f3f095cce2248a0",
"b69008c4456e8c5508d531876ca9a44a9e70b6401c9eb32bb44a71e1377438a4ead041ee154598caebf1d39c",
"964c3d3ec640ffceb20009d59ac0c33b7f873baadb8bcd722c31af00d4f4a12664e2a18f5c3eb5e6095c0e5c",
"8e10c74e7f51e578a2a7f3791eea1f6347236d78cdbf03807aae581c129f883435ea43e26b1aab700f2bf632",
"e632a89374a9656fc9d7ee96c940615f1b69f561e676a3190fabb3a57cff1d4d4cae311519562305b01093ad",
"4eeb79381dfe0de69c5946042f756e0d35ae3516fee7c51894daf605a54d4909b1e9ca6ece9897fc237391f9",
"6d0d88e8ffbe2b25f08201294e16b468e2e55f9e91656591aacc10075c7455d86796098ccf0a4d4f9168435f",
"e1e8d5697f1cc39f22ed6fc871ca3ab69e2fa722103b5f24c8a0a5e711439d1e18f64d9ffd808fcc8f4b74468b81069b81ef290207e1521678340b5e4ffe40b6a24f147f4c",
"38801d2345805bdad452e9fc4e939cd8a168c14e0e7b966c1a52d53768a1e0e39158b8245386ad2f287e0a0ec642e3dbe6e938d3d25820a9182aff65073970629a3266902b",
"70e4b2eddcf8e197b8676ba3ba7596312cee61d0acf25eed4b9077989d60cefd95f6e8ab63429d7d73cd76d9a172cb04917af596dd9cbc32521e345441e09725c77b684759",
"9627c02c3e7d21c90f7554f7de679d49e605a88db56c5874735cc98ade8b4b1b7d2f76212623ae23aea38b55597b30cd11737dc62d104e8848d1bce62f8226968492f23536",
"8a0aea66d01a24ff1071efeec96db2f3e572f0165c7ca2dfa0bffa30f4a85fa359376da74ff87119b68e9a3a3dea854bf94e8bc589ba228fe636477f4af1928153fa17dfd4",
"ff99c4ac3aa40ff06af55b7aef27b0fc12afbaba428894deea84804377f924514acb3aea4b73fa5e3414719ca3c056587af9481b46528a616940eef2f6b38a9b4420f80188",
"37141bb08cd28c3de2be0c0f851cf0131e0974c7c0e902690c3d892297b0f10ba627cc604c44e0229435877eb6defa683570f03f28c50c",
"7df3dac053f3a0578766f3132483bbc74bd3a99f782d28e1a60cd19fdd4daa5ac2681b87499281b2dc52a6393c405d4c3c78bbd46bcca2",
"2677f13da1a8598573a524f701e1e5d6e0f6a50fb182d3faaef33cb43a0970bb92e14f1499d069d85b3e46de94c177ddff18c2f49387d7",
"0b20d18955b3f8c5db838fa309fe44d6ed95b8e1816e53d98ce0bd38031d87ebed5e5c71a8e2ddf2d620e0b75c66d99ad3bf5177bdc80c",
"7e8deb44e4e19db2e12fb3974c44fb3eb25ae22a07ce27b622152f36de3c996147765f7938fc78364fdfca2c8ec78578585dfab2ea50c2",
"9270b682dd883f0f6422b5bbe72280ba815c2501575f850f1ab9f4be943d9922466e2e63d124c89dc86abcf6937e8c416022fc83d9b367",
}

func main() {
c, err := aes.NewCipher([]byte("thats hot lololo"))
if err != nil {
panic(err)
}
stream := cipher.NewCTR(c, make([]byte, aes.BlockSize))
for _, line := range data {
data, err := hex.DecodeString(line)
if err != nil {
panic(err)
}
stream.XORKeyStream(data, data)
fmt.Println(string(data))
}
}

/go@mmis_js_bot package main

import "fmt"

func fun() func() func() func() {
return func() func() func() {
return func() func() {
return func() {
}
}
}
}

func main() {
fmt.Println(fun())
}

@Cute_Panda
https://github.com/jobbole/awesome-machine-learning-cn

/php@mmis_js_bot <?php
$starttime = microtime(true);

$array = array(3,4,1,3,5,1,92,2,4124,424,52,12);

for ($c=0;$c<100000;$c++) {

for ($i=0;$i<count($array);$i++) {
for ($y=0;$y<count($array)-1;$y++) {
if ($array[$y+1] < $array[$y]) {
$t = $array[$y];
$array[$y] = $array[$y+1];
$array[$y+1] = $t;
}
}
}

}
print_r($array);
echo microtime(true) - $starttime;

/js@mmis_js_bot var starttime = new Date().getTime();

var array = [3,4,1,3,5,1,92,2,4124,424,52,12];

for (var c = 0; c < 100000; c++) {
for (var i = 0; i < array.length; i++) {
for (var y = 0; y < array.length - 1; y++) {
if (array[y+1] < array[y]) {
var t = array[y];
array[y] = array[y + 1];
array[y + 1] = t;
}
}
}
}
console.log(array);
console.log(new Date().getTime() - starttime);

/go@mmis_js_bot package main

import "fmt"
import "time"

func main() {

timestart := time.Now();

array := [...]int16{3,4,1,3,5,1,92,2,4124,424,52,12}

for c := 0; c < 100000; c++ {

for i := 0; i < len(array); i++ {
for y := 0; y < len(array) - 1; y++ {
if array[y+1] < array[y] {
t := array[y]
array[y] = array[y+1]
array[y+1] = t
}
}
}

}

fmt.Print(array);
fmt.Print("\n");

timeend := time.Now();

fmt.Print(timeend.Sub(timestart));

}

/js@mmis_js_bot Yami Odymel var array = [3,4,1,3,5,1,92,2,4124,424,52,12];
console.log(array.sort());

/js@mmis_js_bot vararray = [3,4,1,3,5,1,92,2,4124,424,52,12];
console.log(array.sort());

/js@mmis_js_bot var array = [3,4,1,3,5,1,92,2,4124,424,52,12];
console.log(array.sort());

🤔

wwww

/js@mmis_js_bot var starttime = new Date().getTime();

var array = [3,4,1,3,5,1,92,2,4124,424,52,12];
console.log(array.sort());
console.log(new Date().getTime() - starttime);

跟這個方法差了 51 ms

/go@mmis_js_bot package main

import "fmt"
import "time"
import "sort"

func main() {

timestart := time.Now();

array := [...]int16{3,4,1,3,5,1,92,2,4124,424,52,12}
sort.Ints(array)

fmt.Print(array);
fmt.Print("\n");

timeend := time.Now();

fmt.Print(timeend.Sub(timestart));

}

/go@mmis_js_bot package main

import "fmt"
import "time"
import "sort"

func main() {

timestart := time.Now();

array := []int{3,4,1,3,5,1,92,2,4124,424,52,12}
sort.Ints(array)

fmt.Print(array);
fmt.Print("\n");

timeend := time.Now();

fmt.Print(timeend.Sub(timestart));

}

/python3@mmis_js_bot array = [3,4,1,3,5,1,92,2,4124,424,52,12];
print(array.sorted());

WoodMan:
/python3@mmis_js_bot array = [3,4,1,3,5,1,92,2,4124,424,52,12];
print(sorted(array));

/python3@mmis_js_bot array = [3,4,1,3,5,1,92,2,4124,424,52,12];
print(sorted(array));

/php@mmis_js_bot <?php
$starttime = microtime(true);

$array = array(3,4,1,3,5,1,92,2,4124,424,52,12);

print_r(sort($array));
echo microtime(true) - $starttime;

wwwwwwwwwww

/php@mmis_js_bot <?php
$starttime = microtime(true);

$array = array(3,4,1,3,5,1,92,2,4124,424,52,12);
sort($array)
print_r($array);
echo microtime(true) - $starttime;

幹

/php@mmis_js_bot <?php
$starttime = microtime(true);

$array = array(3,4,1,3,5,1,92,2,4124,424,52,12);
sort($array);
print_r($array);
echo microtime(true) - $starttime;

用自幹的 Bubble Sort：
PHP 3s
Node.js 61ms
Golang 36ms

用內建的排序：
PHP 5ms
Node.js 10ms
Golang 786us

是這樣？

/bat@mmis_js_bot @echo off
set counter=0
:loop
set /a counter=%counter%+1
set counter
goto loop

/js@mmis_js_bot function Dictonary(){
var items = {};
this.has = function(key){
return key in items;
};
this.set = function(key, value){
items[key] = value;
};
this.size = function(key, value){
items[key] = value;
return value;
};
this.get = function(key){
return this.has(key) ? items[key] : undefined;
};
this.values = function(){
var values = {};
for (var k in items){
if (this.has(k)){
values.push(items[k]);
}
}
};
this.getItems = function(){
return items;
};
this.keys = function() {
return Object.keys(items);
};
this.size = function() {
var count = 0;
for(var prop in items) {
if(items.hasOwnProperty(prop)) {
++count;
}
return count;
}
};
}

function Graph(){
var vertives =[];
var adjList = new Dictonary();
this.addVertex = function(v){
vertives.push(v);
adjList.set(v, []);
};
this.addEdge = function(v, w){
adjList.get(v).push(w);
adjList.get(w).push(v);
};
this.toString = function(){
var s = '';
for (var i = 0; i < vertives.length; i ++){
s += vertives[i] + ' -> ';
var neighbors = adjList.get(vertives[i]);
for (var j = 0; j < neighbors.length; j ++){
s += neighbors[j] + ' ';
}
s += '\n';
}
return s;
};
var Breadthfirst = function(){
var color = [];
for (var i = 0; i < vertives.length; i ++){
color[vertives[i]] = 'white';
}
return color;
};
this.dfs = function(callback){
var color = Breadthfirst();
for(var i = 0; i < vertives.length; i ++){
if(color[vertives[i]] === 'white'){
dfsVisit(vertives[i], color, callback);
}
}
};
var dfsVisit = function(u, color, callback){
color[u] = 'grey';
if(callback){
callback(u);
}
var neighbors = adjList.get(u);
for (var i = 0; i < neighbors.length; i ++){
var w = neighbors[i];
if(color[w] === 'white'){
dfsVisit(w, color, callback);
}
}
color[u] = 'black';
};
}

var graph = new Graph();
var list = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I'];
for (var i = 0; i < list.length; i ++){
graph.addVertex(list[i]);
}
graph.addEdge('A', 'B');
graph.addEdge('A', 'C');
graph.addEdge('A', 'D');
graph.addEdge('A', 'E');

graph.addEdge('B', 'G');

graph.addEdge('C', 'F');

graph.addEdge('D', 'I');

graph.addEdge('F', 'H');
graph.addEdge('F', 'I');

graph.addEdge('G', 'H');
console.log(graph.toString());
function print(value){
console.log('Print ' + value);
}
graph.dfs(print);

長澍喔

喔不是

你在捲絲嗎

Vertex Vertices

小心串寫

這你寫的嗎

this

當然不是

DFS很好啊 演算法多學幾個

很有用

好喔

參考書做出來的

QwQ

/js@mmis_js_bot function Dictonary(){
var items = {};
this.has = function(key){
return key in items;
};
this.set = function(key, value){
items[key] = value;
};
this.size = function(key, value){
items[key] = value;
return value;
};
this.get = function(key){
return this.has(key) ? items[key] : undefined;
};
this.values = function(){
var values = {};
for (var k in items){
if (this.has(k)){
values.push(items[k]);
}
}
};
this.getItems = function(){
return items;
};
this.keys = function() {
return Object.keys(items);
};
this.size = function() {
var count = 0;
for(var prop in items) {
if(items.hasOwnProperty(prop)) {
++count;
}
return count;
}
};
}

function Graph(){
var vertives =[];
var adjList = new Dictonary();
this.addVertex = function(v){
vertives.push(v);
adjList.set(v, []);
};
this.addEdge = function(v, w){
adjList.get(v).push(w);
adjList.get(w).push(v);
};
this.toString = function(){
var s = '';
for (var i = 0; i < vertives.length; i ++){
s += vertives[i] + ' -> ';
var neighbors = adjList.get(vertives[i]);
for (var j = 0; j < neighbors.length; j ++){
s += neighbors[j] + ' ';
}
s += '\n';
}
return s;
};
var Breadthfirst = function(){
var color = [];
for (var i = 0; i < vertives.length; i ++){
color[vertives[i]] = 'white';
}
return color;
};
this.dfs = function(callback){
var color = Breadthfirst();
for(var i = 0; i < vertives.length; i ++){
if(color[vertives[i]] === 'white'){
dfsVisit(vertives[i], color, callback);
}
}
};
var dfsVisit = function(u, color, callback){
color[u] = 'grey';
if(callback){
callback(u);
}
var neighbors = adjList.get(u);
for (var i = 0; i < neighbors.length; i ++){
var w = neighbors[i];
if(color[w] === 'white'){
dfsVisit(w, color, callback);
}
}
color[u] = 'black';
};
}

var graph = new Graph();
var list = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I'];
for (var i = 0; i < list.length; i ++){
graph.addVertex(list[i]);
}
graph.addEdge('A', 'B');
graph.addEdge('A', 'C');
graph.addEdge('A', 'D');
graph.addEdge('A', 'E');

graph.addEdge('B', 'G');

graph.addEdge('C', 'F');

graph.addEdge('D', 'I');

graph.addEdge('F', 'H');
graph.addEdge('F', 'I');

graph.addEdge('H', 'H');
console.log(graph.toString());
function print(value){
console.log('Print ' + value);
}
graph.dfs(print);

底下addEdge可以改來玩玩w

你嗑了三小

我說 你看了什麼書

對了你建議什麼方式讓node可以多線程嗎

child_process.fork*(

Um 好喔

現在沒要玩了齁

啥

來試試看寫成 Golang

factorio

對

靠邀完全不知道 Object 裡面是什麼資料型態

哪邊

你有兩個 size function 在 Dictonary

「 var items = {};」

這個裡面不曉得會存什麼

一開始就卡關

靠北

wwwwwwww
演算法的書ouo

object

書名

Object

真的有夠幫助

認真

Golang 才沒有 Object 阿——

名值對
這樣有好點嗎

size那個不用管wwww
那個是另一個的東西wwww

书名

主要是 key 跟 value 是什麼型態的

我還找不出來

Key是String

key:string
value:string？

shit 发错了

No foul languages

JavaScript 資料結構及演算法實作

.

反正key一定是string

想读

因為key也只能用string

200多的樣子(#

www

也有 int 來著？

我以前都用 int

🌚.

@Cute_Panda
https://github.com/jobbole/awesome-machine-learning-cn

想读，但是没时间

哎……

那是Array

没有好的电脑能玩机械学习？

Object Key 不是也能用 int？

4喔

好喔

我目前為止都還有時間(?
之後就不一定惹qwq

看了都哭了...

像找个人陪我学 ML

(哭

...?

Lua機械學習都比Node友善

\ Python /

\ Python /

我...不太敢說我會用Python...OAO

++ww

嗯？

好像很厲害的樣子

順帶問一下，JS 你都會加分好？

Skype

抱歉沒看到

/js@mmis_js_bot console.log(1)
console.log(2)
console.log(3)

習慣(#

幹以為是 string 原來是 array

被陰

@mmis1000 https://github.com/licson0729/radiobot/blob/refactor/lib/html5_player/index.js#L85

這塊應該丟回去 http_server.js

/js@mmis_js_bot package main
var ❤️
❤️ = 10
for(❤️>1) {
❤️=❤️-1
console.log(❤️)

}

因為這塊是主要功能不是只給網頁player的

/js@mmis_js_bot
var ❤️
❤️ = 10
for(❤️>1) {
❤️=❤️-1
console.log(❤️)

}

/js@mmis_js_bot
var ❤️
❤️ = 10
while(❤️>1) {
❤️=❤️-1
console.log(❤️)

}

靠邀我放棄

求接手

/js@mmis_js_bot function Dictonary(){
var items = {};
this.has = function(key){
return key in items;
};
this.set = function(key, value){
items[key] = value;
};
this.size = function(key, value){
items[key] = value;
return value;
};
this.get = function(key){
return this.has(key) ? items[key] : undefined;
};
this.values = function(){
var values = {};
for (var k in items){
if (this.has(k)){
values.push(items[k]);
}
}
};
this.getItems = function(){
return items;
};
this.keys = function() {
return Object.keys(items);
};
this.size = function() {
var count = 0;
for(var prop in items) {
if(items.hasOwnProperty(prop)) {
++count;
}
return count;
}
};
}

var test = new Dictionary();
test.set('test, 'ouo');
console.log(test.size());
console.log(test.keys());

好喔

少一個 qote

/js@mmis_js_bot function Dictonary(){
var items = {};
this.has = function(key){
return key in items;
};
this.set = function(key, value){
items[key] = value;
};
this.size = function(key, value){
items[key] = value;
return value;
};
this.get = function(key){
return this.has(key) ? items[key] : undefined;
};
this.values = function(){
var values = {};
for (var k in items){
if (this.has(k)){
values.push(items[k]);
}
}
};
this.getItems = function(){
return items;
};
this.keys = function() {
return Object.keys(items);
};
this.size = function() {
var count = 0;
for(var prop in items) {
if(items.hasOwnProperty(prop)) {
++count;
}
return count;
}
};
}

var test = new Dictionary();
test.set('test', 'ouo');
console.log(test.size());
console.log(test.keys());

棍

/js@mmis_js_bot function Dictionary(){
var items = {};
this.has = function(key){
return key in items;
};
this.set = function(key, value){
items[key] = value;
};
this.size = function(key, value){
items[key] = value;
return value;
};
this.get = function(key){
return this.has(key) ? items[key] : undefined;
};
this.values = function(){
var values = {};
for (var k in items){
if (this.has(k)){
values.push(items[k]);
}
}
};
this.getItems = function(){
return items;
};
this.keys = function() {
return Object.keys(items);
};
this.size = function() {
var count = 0;
for(var prop in items) {
if(items.hasOwnProperty(prop)) {
++count;
}
return count;
}
};
}

var test = new Dictionary();
test.set('test', 'ouo');
console.log(test.size());
console.log(test.keys());

Language:

js

Source:

var ❤️ 
    ❤️ = 10
    for(❤️>1) {
    ❤️=❤️-1
    console.log(❤️)
    
}

Errors:

source_file.js:1
(function (exports, require, module, __filename, __dirname) { var ❤️ 
                                                                  ^

SyntaxError: Unexpected token ILLEGAL
    at exports.runInThisContext (vm.js:53:16)
    at Module._compile (module.js:374:25)
    at Object.Module._extensions..js (module.js:417:10)
    at Module.load (module.js:344:32)
    at Function.Module._load (module.js:301:12)
    at Function.Module.runMain (module.js:442:10)
    at startup (node.js:136:18)
    at node.js:966:3

Language:

js

Source:

var ❤️=1;
console.log(❤️)

Errors:

source_file.js:1
(function (exports, require, module, __filename, __dirname) { var ❤️=1;
                                                                  ^

SyntaxError: Unexpected token ILLEGAL
    at exports.runInThisContext (vm.js:53:16)
    at Module._compile (module.js:374:25)
    at Object.Module._extensions..js (module.js:417:10)
    at Module.load (module.js:344:32)
    at Function.Module._load (module.js:301:12)
    at Function.Module.runMain (module.js:442:10)
    at startup (node.js:136:18)
    at node.js:966:3

for 不是這樣寫的辣

🤔

Language:

js

Source:

var ❤️ 
❤️ = 10
while(❤️>1) {
    ❤️=❤️-1
    console.log(❤️)
}

Errors:

source_file.js:1
(function (exports, require, module, __filename, __dirname) { var ❤️ 
                                                                  ^

SyntaxError: Unexpected token ILLEGAL
    at exports.runInThisContext (vm.js:53:16)
    at Module._compile (module.js:374:25)
    at Object.Module._extensions..js (module.js:417:10)
    at Module.load (module.js:344:32)
    at Function.Module._load (module.js:301:12)
    at Function.Module.runMain (module.js:442:10)
    at startup (node.js:136:18)
    at node.js:966:3

複製錯

/go@mmis_js_bot package main

import "fmt"

//
//
type Dictionary struct {
Items map[string][]string
}

func (d *Dictionary) Has(k string) bool {
_, ok := d.Items[k]
return ok
}

func (d *Dictionary) Set(k string, v []string) {
d.Items[k] = v
}

func (d *Dictionary) Get(k string) []string {
if v, ok := d.Items[k]; ok {
return v
}
return []string{}
}

func (d *Dictionary) GetItems() map[string][]string {
return d.Items
}

func (d *Dictionary) Keys() []string {
keys := []string{}
for k := range d.Items {
keys = append(keys, k)
}
return keys
}

func main(){
d := Dictionary{}
d.Set("test", []string{"ouo"})
fmt.Println(d.Keys)
}

for (var i = 0; i < 5; i ++){
}

丟你雷姆