Golang for Node.js Developers

Contents

Examples

comments

Node.js

// this is a line comment/* this is a block comment*/

Go

package mainfuncmain() {// this is a line comment/*   this is a block comment*/}

printing

Node.js

console.log('print to stdout')console.log('format %s %d','example',1)console.error('print to stderr')

print to stdoutformat example 1print to stderr

Go

package mainimport ("fmt""os")funcmain() {fmt.Println("print to stdout")fmt.Printf("format %s %v\n","example",1)fmt.Fprintf(os.Stderr,"print to stderr")}

print to stdoutformat example 1print to stderr

logging

Node.js

console.log((newDate()).toISOString(),'hello world')

2021-04-11T20:55:07.451Z hello world

Go

package mainimport"log"funcmain() {log.Println("hello world")}

2021/04/11 13:55:07 hello world

variables

Node.js

// function scopedvarfoo='foo'// block scopedletbar='bar'// constantconstqux='qux'

Go

package mainfuncmain() {// explicitvarfoostring="foo"// type inferredvarbar="foo"// shorthandbaz:="bar"// constantconstqux="qux"}

interpolation

Node.js

constname='bob'constage=21constmessage=`${name} is${age} years old`console.log(message)

bob is 21 years old

Go

package mainimport"fmt"funcmain() {name:="bob"age:=21message:=fmt.Sprintf("%s is %d years old",name,age)fmt.Println(message)}

bob is 21 years old

types

Node.js

// primitivesconstmyBool=trueconstmyNumber=10constmyString='foo'constmySymbol=Symbol('bar')constmyNull=nullconstmyUndefined=undefined// object typesconstmyObject={}constmyArray=[]constmyFunction=function(){}constmyError=newError('error')constmyDate=newDate()constmyRegex=/a/constmyMap=newMap()constmySet=newSet()constmyPromise=Promise.resolve()constmyGenerator=function*(){}constmyClass=class{}

Go

package mainfuncmain() {// primitivesvarmyBoolbool=truevarmyIntint=10varmyInt8int8=10varmyInt16int16=10varmyInt32int32=10varmyInt64int64=10varmyUintuint=10varmyUint8uint8=10varmyUint16uint16=10varmyUint32uint32=10varmyUint64uint64=10varmyUintptruintptr=10varmyFloat32float32=10.5varmyFloat64float64=10.5varmyComplex64complex64=-1+10ivarmyComplex128complex128=-1+10ivarmyStringstring="foo"varmyBytebyte=10// alias to uint8varmyRunerune='a'// alias to int32// composite typesvarmyStructstruct{}=struct{}{}varmyArray []string= []string{}varmyMapmap[string]int=map[string]int{}varmyFunctionfunc()=func() {}varmyChannelchanbool=make(chanbool)varmyInterfaceinterface{}=nilvarmyPointer*int=new(int)}

type check

Node.js

functiontypeOf(obj){return{}.toString.call(obj).split(' ')[1].slice(0,-1).toLowerCase()}constvalues=[true,10,'foo',Symbol('bar'),null,undefined,NaN,{},[],function(){},newError(),newDate(),/a/,newMap(),newSet(),Promise.resolve(),function*(){},class{},]for(valueofvalues){console.log(typeOf(value))}

booleannumberstringsymbolnullundefinednumberobjectarrayfunctionerrordateregexpmapsetpromisegeneratorfunctionfunction

Go

package mainimport ("fmt""reflect""regexp""time")funcmain() {values:= []interface{}{true,int8(10),int16(10),int32(10),int64(10),uint(10),uint8(10),uint16(10),uint32(10),uint64(10),uintptr(10),float32(10.5),float64(10.5),complex64(-1+10i),complex128(-1+10i),"foo",byte(10),'a',rune('a'),struct{}{},[]string{},map[string]int{},func() {},make(chanbool),nil,new(int),time.Now(),regexp.MustCompile(`^a$`),}for_,value:=rangevalues {fmt.Println(reflect.TypeOf(value))}}

boolint8int16int32int64uintuint8uint16uint32uint64uintptrfloat32float64complex64complex128stringuint8int32int32struct {}[]stringmap[string]intfunc()chan bool<nil>*inttime.Time*regexp.Regexp

if/else

Node.js

constarray=[1,2]if(array){console.log('array exists')}if(array.length===2){console.log('length is 2')}elseif(array.length===1){console.log('length is 1')}else{console.log('length is other')}constisOddLength=array.length%2==1 ?'yes' :'no'console.log(isOddLength)

array existslength is 2no

Go

package mainimport"fmt"funcmain() {array:= []byte{1,2}ifarray!=nil {fmt.Println("array exists")}iflen(array)==2 {fmt.Println("length is 2")}elseiflen(array)==1 {fmt.Println("length is 1")}else {fmt.Println("length is other")}// closest thing to ternary operatorisOddLength:="no"iflen(array)%2==1 {isOddLength="yes"}fmt.Println(isOddLength)}

array existslength is 2no

for

Node.js

for(leti=0;i<=5;i++){console.log(i)}

012345

Go

package mainimport"fmt"funcmain() {fori:=0;i<=5;i++ {fmt.Println(i)}}

012345

while

Node.js

leti=0while(i<=5){console.log(i)i++}

012345

Go

package mainimport"fmt"funcmain() {i:=0fori<=5 {fmt.Println(i)i++}}

012345

switch

Node.js

constvalue='b'switch(value){case'a':console.log('A')breakcase'b':console.log('B')breakcase'c':console.log('C')breakdefault:console.log('first default')}switch(value){case'a':console.log('A - falling through')case'b':console.log('B - falling through')case'c':console.log('C - falling through')default:console.log('second default')}

BB - falling throughC - falling throughsecond default

Go

package mainimport"fmt"funcmain() {value:="b"switchvalue {case"a":fmt.Println("A")case"b":fmt.Println("B")case"c":fmt.Println("C")default:fmt.Println("first default")}switchvalue {case"a":fmt.Println("A - falling through")fallthroughcase"b":fmt.Println("B - falling through")fallthroughcase"c":fmt.Println("C - falling through")fallthroughdefault:fmt.Println("second default")}}

BB - falling throughC - falling throughsecond default

arrays

Node.js

constarray=[1,2,3,4,5]console.log(array)constclone=array.slice(0)console.log(clone)constsub=array.slice(2,4)console.log(sub)constconcatenated=clone.concat([6,7])console.log(concatenated)constprepended=[-2,-1,0].concat(concatenated)console.log(prepended)

[ 1, 2, 3, 4, 5 ][ 1, 2, 3, 4, 5 ][ 3, 4 ][ 1, 2, 3, 4, 5, 6, 7 ][ -2, -1, 0, 1, 2, 3, 4, 5, 6, 7 ]

Go

package mainimport"fmt"funcmain() {array:= []int{1,2,3,4,5}fmt.Println(array)clone:=make([]int,len(array))copy(clone,array)fmt.Println(clone)sub:=array[2:4]fmt.Println(sub)concatenated:=append(array, []int{6,7}...)fmt.Println(concatenated)prepended:=append([]int{-2,-1,0},concatenated...)fmt.Println(prepended)}

[1 2 3 4 5][1 2 3 4 5][3 4][1 2 3 4 5 6 7][-2 -1 0 1 2 3 4 5 6 7]

uint8 arrays

Node.js

constarray=newUint8Array(10)console.log(array)constoffset=1array.set([1,2,3],offset)console.log(array)constsub=array.subarray(2)console.log(sub)constsub2=array.subarray(2,4)console.log(sub2)console.log(array)constvalue=9conststart=5constend=10array.fill(value,start,end)console.log(array)console.log(array.byteLength)

Uint8Array [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]Uint8Array [ 0, 1, 2, 3, 0, 0, 0, 0, 0, 0 ]Uint8Array [ 2, 3, 0, 0, 0, 0, 0, 0 ]Uint8Array [ 2, 3 ]Uint8Array [ 0, 1, 2, 3, 0, 0, 0, 0, 0, 0 ]Uint8Array [ 0, 1, 2, 3, 0, 9, 9, 9, 9, 9 ]10

Go

package mainimport"fmt"funcmain() {array:=make([]uint8,10)fmt.Println(array)offset:=1copy(array[offset:], []uint8{1,2,3})fmt.Println(array)sub:=array[2:]fmt.Println(sub)sub2:=array[2:4]fmt.Println(sub2)fmt.Println(array)value:=uint8(9)start:=5end:=10fori:=start;i<end;i++ {array[i]=value}fmt.Println(array)fmt.Println(len(array))}

[0 0 0 0 0 0 0 0 0 0][0 1 2 3 0 0 0 0 0 0][2 3 0 0 0 0 0 0][2 3][0 1 2 3 0 0 0 0 0 0][0 1 2 3 0 9 9 9 9 9]10

array iteration

Node.js

constarray=['a','b','c']array.forEach((value,i)=>{console.log(i,value)})constmapped=array.map(value=>{returnvalue.toUpperCase()})console.log(mapped)constfiltered=array.filter((value,i)=>{returni%2==0})console.log(filtered)constreduced=array.reduce((acc,value,i)=>{if(i%2==0){acc.push(value.toUpperCase())}returnacc},[])console.log(reduced)

0'a'1'b'2'c'['A','B','C' ]['a','c' ]['A','C' ]

Go

package mainimport ("fmt""strings")funcmain() {array:= []string{"a","b","c"}fori,value:=rangearray {fmt.Println(i,value)}mapped:=make([]string,len(array))fori,value:=rangearray {mapped[i]=strings.ToUpper(value)}fmt.Println(mapped)varfiltered []stringfori,value:=rangearray {ifi%2==0 {filtered=append(filtered,value)}}fmt.Println(filtered)varreduced []stringfori,value:=rangearray {ifi%2==0 {reduced=append(reduced,strings.ToUpper(value))}}fmt.Println(reduced)}

0 a1 b2 c[A B C][a c][A C]

array sorting

Node.js

conststringArray=['a','d','z','b','c','y']conststringArraySortedAsc=stringArray.sort((a,b)=>a>b ?1 :-1)console.log(stringArraySortedAsc)conststringArraySortedDesc=stringArray.sort((a,b)=>a>b ?-1 :1)console.log(stringArraySortedDesc)constnumberArray=[1,3,5,9,4,2,0]constnumberArraySortedAsc=numberArray.sort((a,b)=>a-b)console.log(numberArraySortedAsc)constnumberArraySortedDesc=numberArray.sort((a,b)=>b-a)console.log(numberArraySortedDesc)constcollection=[{name:"Li L",age:8},{name:"Json C",age:3},{name:"Zack W",age:15},{name:"Yi M",age:2}]constcollectionSortedByAgeAsc=collection.sort((a,b)=>a.age-b.age)console.log(collectionSortedByAgeAsc)constcollectionSortedByAgeDesc=collection.sort((a,b)=>b.age-a.age)console.log(collectionSortedByAgeDesc)

['a','b','c','d','y','z' ]['z','y','d','c','b','a' ][ 0, 1, 2, 3, 4, 5, 9 ][ 9, 5, 4, 3, 2, 1, 0 ][ { name:'Yi M', age: 2 },  { name:'Json C', age: 3 },  { name:'Li L', age: 8 },  { name:'Zack W', age: 15 } ][ { name:'Zack W', age: 15 },  { name:'Li L', age: 8 },  { name:'Json C', age: 3 },  { name:'Yi M', age: 2 } ]

Go

package mainimport ("fmt""sort")typePersonstruct {NamestringAgeint}typePersonCollection []Personfunc (pcPersonCollection)Len()int {returnlen(pc)}func (pcPersonCollection)Swap(i,jint) {pc[i],pc[j]=pc[j],pc[i]}func (pcPersonCollection)Less(i,jint)bool {// ascreturnpc[i].Age<pc[j].Age}funcmain() {intList:= []int{1,3,5,9,4,2,0}// ascsort.Ints(intList)fmt.Println(intList)// descsort.Sort(sort.Reverse(sort.IntSlice(intList)))fmt.Println(intList)stringList:= []string{"a","d","z","b","c","y"}// ascsort.Strings(stringList)fmt.Println(stringList)// descsort.Sort(sort.Reverse(sort.StringSlice(stringList)))fmt.Println(stringList)collection:= []Person{{"Li L",8},{"Json C",3},{"Zack W",15},{"Yi M",2},}// ascsort.Sort(PersonCollection(collection))fmt.Println(collection)// descsort.Sort(sort.Reverse(PersonCollection(collection)))fmt.Println(collection)}

[0 1 2 3 4 5 9][9 5 4 3 2 1 0][a b c d y z][z y d c b a][{Yi M 2} {Json C 3} {Li L 8} {Zack W 15}][{Zack W 15} {Li L 8} {Json C 3} {Yi M 2}]

buffers

Node.js

constbuf=Buffer.alloc(6)letvalue=0x1234567890abletoffset=0letbyteLength=6buf.writeUIntBE(value,offset,byteLength)lethexstr=buf.toString('hex')console.log(hexstr)constbuf2=Buffer.alloc(6)value=0x1234567890aboffset=0byteLength=6buf2.writeUIntLE(value,offset,byteLength)hexstr=buf2.toString('hex')console.log(hexstr)letisEqual=Buffer.compare(buf,buf2)===0console.log(isEqual)isEqual=Buffer.compare(buf,buf)===0console.log(isEqual)

1234567890abab9078563412falsetrue

Go

package mainimport ("bytes""encoding/binary""encoding/hex""fmt""log""math/big""reflect")funcwriteUIntBE(buffer []byte,value,offset,byteLengthint64) {slice:=make([]byte,byteLength)val:=new(big.Int)val.SetUint64(uint64(value))valBytes:=val.Bytes()buf:=bytes.NewBuffer(slice)err:=binary.Write(buf,binary.BigEndian,&valBytes)iferr!=nil {log.Fatal(err)}slice=buf.Bytes()slice=slice[int64(len(slice))-byteLength :len(slice)]copy(buffer[offset:],slice)}funcwriteUIntLE(buffer []byte,value,offset,byteLengthint64) {slice:=make([]byte,byteLength)val:=new(big.Int)val.SetUint64(uint64(value))valBytes:=val.Bytes()tmp:=make([]byte,len(valBytes))fori:=rangevalBytes {tmp[i]=valBytes[len(valBytes)-1-i]}copy(slice,tmp)copy(buffer[offset:],slice)}funcmain() {buf:=make([]byte,6)writeUIntBE(buf,0x1234567890ab,0,6)fmt.Println(hex.EncodeToString(buf))buf2:=make([]byte,6)writeUIntLE(buf2,0x1234567890ab,0,6)fmt.Println(hex.EncodeToString(buf2))isEqual:=reflect.DeepEqual(buf,buf2)fmt.Println(isEqual)isEqual=reflect.DeepEqual(buf,buf)fmt.Println(isEqual)}

1234567890abab9078563412falsetrue

maps

Node.js

constmap=newMap()map.set('foo','bar')letfound=map.has('foo')console.log(found)letitem=map.get('foo')console.log(item)map.delete('foo')found=map.has('foo')console.log(found)item=map.get('foo')console.log(item)constmap2={}map2['foo']='bar'item=map2['foo']deletemap2['foo']constmap3=newMap()map3.set('foo',100)map3.set('bar',200)map3.set('baz',300)for(let[key,value]ofmap3){console.log(key,value)}

truebarfalseundefinedfoo 100bar 200baz 300

Go

package mainimport"fmt"funcmain() {map1:=make(map[string]string)map1["foo"]="bar"item,found:=map1["foo"]fmt.Println(found)fmt.Println(item)delete(map1,"foo")item,found=map1["foo"]fmt.Println(found)fmt.Println(item)map2:=make(map[string]int)map2["foo"]=100map2["bar"]=200map2["baz"]=300forkey,value:=rangemap2 {fmt.Println(key,value)}}

truebarfalsefoo 100bar 200baz 300

objects

Node.js

constobj={someProperties:{'foo':'bar'},someMethod:(prop)=>{returnobj.someProperties[prop]}}letitem=obj.someProperties['foo']console.log(item)item=obj.someMethod('foo')console.log(item)

barbar

Go

package mainimport"fmt"typeObjstruct {SomePropertiesmap[string]string}funcNewObj()*Obj {return&Obj{SomeProperties:map[string]string{"foo":"bar",},}}func (o*Obj)SomeMethod(propstring)string {returno.SomeProperties[prop]}funcmain() {obj:=NewObj()item:=obj.SomeProperties["foo"]fmt.Println(item)item=obj.SomeMethod("foo")fmt.Println(item)}

barbar

functions

Node.js

functionadd(a,b){returna+b}constresult=add(2,3)console.log(result)

5

Go

package mainimport"fmt"funcadd(aint,bint)int {returna+b}funcmain() {result:=add(2,3)fmt.Println(result)}

5

default values

Node.js

functiongreet(name='stranger'){return`hello${name}`}letmessage=greet()console.log(message)message=greet('bob')console.log(message)

hello strangerhello bob

Go

package mainimport"fmt"funcgreet(name*string)string {n:="stranger"ifname!=nil {n=*name}returnfmt.Sprintf("hello %s",n)}funcmain() {message:=greet(nil)fmt.Println(message)name:="bob"message=greet(&name)fmt.Println(message)}

hello strangerhello bob

destructuring

Node.js

constobj={key:'foo',value:'bar'}const{ key, value}=objconsole.log(key,value)

foo bar

Go

package mainimport"fmt"typeObjstruct {KeystringValuestring}func (o*Obj)Read() (string,string) {returno.Key,o.Value}funcmain() {obj:=Obj{Key:"foo",Value:"bar",}// option 1: multiple variable assignmentkey,value:=obj.Key,obj.Valuefmt.Println(key,value)// option 2: return multiple values from a functionkey,value=obj.Read()fmt.Println(key,value)}

foo barfoo bar

spread operator

Node.js

constarray=[1,2,3,4,5]console.log(...array)

1 2 3 4 5

Go

package mainimport"fmt"funcmain() {array:= []byte{1,2,3,4,5}vari []interface{}for_,value:=rangearray {i=append(i,value)}fmt.Println(i...)}

1 2 3 4 5

rest operator

Node.js

functionsum(...nums){lett=0for(letnofnums){t+=n}returnt}consttotal=sum(1,2,3,4,5)console.log(total)

15

Go

package mainimport"fmt"funcsum(nums...int)int {vartintfor_,n:=rangenums {t+=n}returnt}funcmain() {total:=sum(1,2,3,4,5)fmt.Println(total)}

15

swapping

Node.js

leta='foo'letb='bar'console.log(a,b);[b,a]=[a,b]console.log(a,b)

foo barbar foo

Go

package mainimport"fmt"funcmain() {a:="foo"b:="bar"fmt.Println(a,b)b,a=a,bfmt.Println(a,b)}

foo barbar foo

classes

Node.js

classFoo{constructor(value){this.item=value}getItem(){returnthis.item}setItem(value){this.item=value}}constfoo=newFoo('bar')console.log(foo.item)foo.setItem('qux')constitem=foo.getItem()console.log(item)

barqux

Go

package mainimport"fmt"typeFoostruct {Itemstring}funcNewFoo(valuestring)*Foo {return&Foo{Item:value,}}func (f*Foo)GetItem()string {returnf.Item}func (f*Foo)SetItem(valuestring) {f.Item=value}funcmain() {foo:=NewFoo("bar")fmt.Println(foo.Item)foo.SetItem("qux")item:=foo.GetItem()fmt.Println(item)}

barqux

generators

Node.js

function*generator(){yield'hello'yield'world'}letgen=generator()while(true){let{ value, done}=gen.next()console.log(value,done)if(done){break}}// alternativelyfor(letvalueofgenerator()){console.log(value)}

hellofalseworldfalseundefinedtruehelloworld

Go

package mainimport"fmt"funcGenerator()chanstring {c:=make(chanstring)gofunc() {c<-"hello"c<-"world"close(c)}()returnc}funcGeneratorFunc()func() (string,bool) {s:= []string{"hello","world"}i:=-1returnfunc() (string,bool) {i++ifi>=len(s) {return"",false}returns[i],true}}funcmain() {gen:=Generator()for {value,more:=<-genfmt.Println(value,more)if!more {break}}// alternativelyforvalue:=rangeGenerator() {fmt.Println(value)}// alternativelygenfn:=GeneratorFunc()for {value,more:=genfn()fmt.Println(value,more)if!more {break}}}

hellotrueworldtruefalsehelloworldhellotrueworldtruefalse

datetime

Node.js

constnowUnix=Date.now()console.log(nowUnix)constdatestr='2019-01-17T09:24:23+00:00'constdate=newDate(datestr)console.log(date.getTime())console.log(date.toString())constfutureDate=newDate(date)futureDate.setDate(date.getDate()+14)console.log(futureDate.toString())constformatted=`${String(date.getMonth()+1).padStart(2,0)}/${String(date.getDate()).padStart(2,0)}/${date.getFullYear()}`console.log(formatted)

15477188441681547717063000Thu Jan 17 2019 01:24:23 GMT-0800 (Pacific Standard Time)Thu Jan 31 2019 01:24:23 GMT-0800 (Pacific Standard Time)01/17/2019

Go

package mainimport ("fmt""time")funcmain() {nowUnix:=time.Now().Unix()fmt.Println(nowUnix)datestr:="2019-01-17T09:24:23+00:00"date,err:=time.Parse("2006-01-02T15:04:05Z07:00",datestr)iferr!=nil {panic(err)}fmt.Println(date.Unix())fmt.Println(date.String())futureDate:=date.AddDate(0,0,14)fmt.Println(futureDate.String())formatted:=date.Format("01/02/2006")fmt.Println(formatted)}

154771884415477170632019-01-17 09:24:23 +0000 +00002019-01-31 09:24:23 +0000 +000001/17/2019

timeout

Node.js

setTimeout(callback,1e3)functioncallback(){console.log('called')}

called

Go

package mainimport ("fmt""sync""time")varwg sync.WaitGroupfunccallback() {deferwg.Done()fmt.Println("called")}funcmain() {wg.Add(1)time.AfterFunc(1*time.Second,callback)wg.Wait()}

called

interval

Node.js

leti=0constid=setInterval(callback,1e3)functioncallback(){console.log('called',i)if(i===3){clearInterval(id)}i++}

called 0called 1called 2called 3

Go

package mainimport ("fmt""time")funccallback(iint) {fmt.Println("called",i)}funcmain() {ticker:=time.NewTicker(1*time.Second)i:=0forrangeticker.C {callback(i)ifi==3 {ticker.Stop()break}i++}}

called 0called 1called 2called 3

IIFE

Node.js

(function(name){console.log('hello',name)})('bob')

hello bob

Go

package mainimport"fmt"funcmain() {func(namestring) {fmt.Println("hello",name)}("bob")}

hello bob

files

Node.js

constfs=require('fs')// create filefs.closeSync(fs.openSync('test.txt','w'))// open file (returns file descriptor)constfd=fs.openSync('test.txt','r+')letwbuf=Buffer.from('hello world.')letrbuf=Buffer.alloc(12)letoff=0letlen=12letpos=0// write filefs.writeSync(fd,wbuf,pos)// read filefs.readSync(fd,rbuf,off,len,pos)console.log(rbuf.toString())// close filefs.closeSync(fd)// delete filefs.unlinkSync('test.txt')

hello world.

Go

package mainimport ("fmt""os""syscall")funcmain() {// create filefile,err:=os.Create("test.txt")iferr!=nil {panic(err)}// close filefile.Close()// open filefile,err=os.OpenFile("test.txt",os.O_RDWR,0755)iferr!=nil {panic(err)}// file descriptorfd:=file.Fd()// open file (using file descriptor)file=os.NewFile(fd,"test file")wbuf:= []byte("hello world.")rbuf:=make([]byte,12)varoffint64// write fileif_,err:=file.WriteAt(wbuf,off);err!=nil {panic(err)}// read fileif_,err:=file.ReadAt(rbuf,off);err!=nil {panic(err)}fmt.Println(string(rbuf))// close file (using file descriptor)iferr:=syscall.Close(int(fd));err!=nil {panic(err)}// delete fileiferr:=os.Remove("test.txt");err!=nil {panic(err)}}

hello world.

json

Node.js

letjsonstr='{"foo":"bar"}'letparsed=JSON.parse(jsonstr)console.log(parsed)jsonstr=JSON.stringify(parsed)console.log(jsonstr)

{ foo:'bar' }{"foo":"bar"}

Go

package mainimport ("encoding/json""fmt")typeTstruct {Foostring`json:"foo"`}funcmain() {jsonstr:=`{"foo":"bar"}`t:=new(T)err:=json.Unmarshal([]byte(jsonstr),t)iferr!=nil {panic(err)}fmt.Println(t)marshalled,err:=json.Marshal(t)jsonstr=string(marshalled)fmt.Println(jsonstr)}

&{bar}{"foo":"bar"}

big numbers

Node.js

letbn=75n;console.log(bn.toString(10))bn=BigInt('75')console.log(bn.toString(10))bn=BigInt(0x4b)console.log(bn.toString(10))bn=BigInt('0x4b')console.log(bn.toString(10))bn=BigInt('0x'+Buffer.from('4b','hex').toString('hex'))console.log(bn.toString(10))console.log(Number(bn))console.log(bn.toString(16))console.log(Buffer.from(bn.toString(16),'hex'))letbn2=BigInt(100)letisEqual=bn===bn2console.log(isEqual)letisGreater=bn>bn2console.log(isGreater)letisLesser=bn<bn2console.log(isLesser)

7575757575754b<Buffer 4b>falsefalsetrue

Go

package mainimport ("encoding/hex""fmt""math/big")funcmain() {bn:=new(big.Int)bn.SetUint64(75)fmt.Println(bn.String())bn=new(big.Int)bn.SetString("75",10)fmt.Println(bn.String())bn=new(big.Int)bn.SetUint64(0x4b)fmt.Println(bn.String())bn=new(big.Int)bn.SetString("4b",16)fmt.Println(bn.String())bn=new(big.Int)bn.SetBytes([]byte{0x4b})fmt.Println(bn.String())fmt.Println(bn.Uint64())fmt.Println(hex.EncodeToString(bn.Bytes()))fmt.Println(bn.Bytes())bn2:=big.NewInt(100)isEqual:=bn.Cmp(bn2)==0fmt.Println(isEqual)isGreater:=bn.Cmp(bn2)==1fmt.Println(isGreater)isLesser:=bn.Cmp(bn2)==-1fmt.Println(isLesser)}

7575757575754b[75]falsefalsetrue

promises

Node.js

functionasyncMethod(value){returnnewPromise((resolve,reject)=>{setTimeout(()=>{resolve('resolved: '+value)},1e3)})}functionmain(){asyncMethod('foo').then(result=>console.log(result)).catch(err=>console.error(err))Promise.all([asyncMethod('A'),asyncMethod('B'),asyncMethod('C')]).then(result=>console.log(result)).catch(err=>console.error(err))}main()

resolved: foo['resolved: A','resolved: B','resolved: C' ]

Go

package mainimport ("fmt""sync""time""github.com/prometheus/common/log")funcasyncMethod(valuestring)chaninterface{} {ch:=make(chaninterface{},1)gofunc() {time.Sleep(1*time.Second)ch<-"resolved: "+valueclose(ch)}()returnch}funcresolveAll(ch...chaninterface{})chaninterface{} {varwg sync.WaitGroupres:=make([]string,len(ch))resCh:=make(chaninterface{},1)gofunc() {fori,c:=rangech {wg.Add(1)gofunc(jint,ifcChchaninterface{}) {ifc:=<-ifcChswitchv:=ifc.(type) {caseerror:resCh<-vcasestring:res[j]=v}wg.Done()}(i,c)}wg.Wait()resCh<-resclose(resCh)}()returnresCh}funcmain() {varwg sync.WaitGroupwg.Add(2)gofunc() {result:=<-asyncMethod("foo")switchv:=result.(type) {casestring:fmt.Println(v)caseerror:log.Errorln(v)}wg.Done()}()gofunc() {result:=<-resolveAll(asyncMethod("A"),asyncMethod("B"),asyncMethod("C"),)switchv:=result.(type) {case []string:fmt.Println(v)caseerror:log.Errorln(v)}wg.Done()}()wg.Wait()}

resolved: foo[resolved: A resolved: B resolved: C]

async/await

Node.js

functionhello(name){returnnewPromise((resolve,reject)=>{setTimeout(()=>{if(name==='fail'){reject(newError('failed'))}else{resolve('hello '+name)}},1e3)})}asyncfunctionmain(){try{letoutput=awaithello('bob')console.log(output)output=awaithello('fail')console.log(output)}catch(err){console.log(err.message)}}main()

hello bobfailed

Go

package mainimport ("errors""fmt""time""github.com/prometheus/common/log")funchello(namestring)chaninterface{} {ch:=make(chaninterface{},1)gofunc() {time.Sleep(1*time.Second)ifname=="fail" {ch<-errors.New("failed")}else {ch<-"hello "+name}}()returnch}funcmain() {result:=<-hello("bob")switchv:=result.(type) {casestring:fmt.Println(v)caseerror:log.Errorln(v)}result=<-hello("fail")switchv:=result.(type) {casestring:fmt.Println(v)caseerror:log.Errorln(v)}}

hello bobfailed

streams

Node.js

const{ Readable, Writable}=require('stream')constinStream=newReadable()inStream.push(Buffer.from('foo'))inStream.push(Buffer.from('bar'))inStream.push(null)// end streaminStream.pipe(process.stdout)constoutStream=newWritable({write(chunk,encoding,callback){console.log('received: '+chunk.toString('utf8'))callback()}})outStream.write(Buffer.from('abc'))outStream.write(Buffer.from('xyz'))outStream.end()

foobarreceived: abcreceived: xyz

Go

package mainimport ("bufio""bytes""fmt""io""os""runtime")funcmain() {inStream:=new(bytes.Buffer)w:=bufio.NewWriter(inStream)_,err:=w.Write([]byte("foo"))iferr!=nil {panic(err)}_,err=w.Write([]byte("bar"))iferr!=nil {panic(err)}err=w.Flush()iferr!=nil {panic(err)}inStream.WriteTo(os.Stdout)fmt.Print("\n")outStream:=new(bytes.Buffer)outStream.Write([]byte("abc\n"))outStream.Write([]byte("xyc\n"))piper,pipew:=io.Pipe()gofunc() {sc:=bufio.NewScanner(piper)forsc.Scan() {fmt.Println("received: "+sc.Text())}iferr:=sc.Err();err!=nil {panic(err)}os.Exit(0)}()gofunc() {deferpipew.Close()io.Copy(pipew,outStream)}()deferruntime.Goexit()}

foobarreceived: abcreceived: xyc

event emitter

Node.js

constEventEmitter=require('events')classMyEmitterextendsEventEmitter{}constmyEmitter=newMyEmitter()myEmitter.on('my-event',msg=>{console.log(msg)})myEmitter.on('my-other-event',msg=>{console.log(msg)})myEmitter.emit('my-event','hello world')myEmitter.emit('my-other-event','hello other world')

hello worldhello other world

Go

package mainimport ("fmt")typeMyEmittermap[string]chanstringfuncmain() {myEmitter:=MyEmitter{}myEmitter["my-event"]=make(chanstring)myEmitter["my-other-event"]=make(chanstring)gofunc() {for {select {casemsg:=<-myEmitter["my-event"]:fmt.Println(msg)casemsg:=<-myEmitter["my-other-event"]:fmt.Println(msg)}}}()myEmitter["my-event"]<-"hello world"myEmitter["my-other-event"]<-"hello other world"}

hello worldhello other world

errors

Node.js

consterr1=newError('some error')console.log(err1)classFooErrorextendsError{constructor(message){super(message)this.name='FooError'this.message=message}toString(){returnthis.message}}consterr2=newFooError('my custom error')console.log(err2)

Error: some error{ FooError: my custom error }

Go

package mainimport ("errors""fmt")typeFooErrorstruct {sstring}func (f*FooError)Error()string {returnf.s}funcNewFooError(sstring)error {return&FooError{s}}funcmain() {err1:=errors.New("some error")fmt.Println(err1)err2:=NewFooError("my custom error")fmt.Println(err2)}

some errormy custom error

try/catch

Node.js

functionfoo(fail){if(fail){throwError('my error')}}functionmain(){try{foo(true)}catch(err){console.log(`caught error:${err.message}`)}}main()

caught error: my error

Go

package mainimport ("errors""fmt")funcfoo(failbool)error {iffail {returnerrors.New("my error")}returnnil}funcmain() {err:=foo(true)iferr!=nil {fmt.Printf("caught error: %s\n",err.Error())}}

caught error: my error

exceptions

Node.js

functionfoo(){throwError('my exception')}functionmain(){foo()}process.on('uncaughtException',err=>{console.log(`caught exception:${err.message}`)process.exit(1)})main()

caught exception: my exception

Go

package mainimport ("fmt")funcfoo() {panic("my exception")}funcmain() {deferfunc() {ifr:=recover();r!=nil {fmt.Printf("caught exception: %s",r)}}()foo()}

caught exception: my exception

regex

Node.js

letinput='foobar'letreplaced=input.replace(/foo(.*)/i,'qux$1')console.log(replaced)letmatch=/o{2}/i.test(input)console.log(match)input='111-222-333'letmatches=input.match(/([0-9]+)/gi)console.log(matches)

quxbartrue['111','222','333' ]

Go

package mainimport ("fmt""regexp")funcmain() {input:="foobar"re:=regexp.MustCompile(`(?i)foo(.*)`)replaced:=re.ReplaceAllString(input,"qux$1")fmt.Println(replaced)re=regexp.MustCompile(`(?i)o{2}`)match:=re.Match([]byte(input))fmt.Println(match)input="111-222-333"re=regexp.MustCompile(`(?i)([0-9]+)`)matches:=re.FindAllString(input,-1)fmt.Println(matches)}

quxbartrue[111 222 333]

exec (sync)

Node.js

const{ execSync}=require('child_process')constoutput=execSync(`echo 'hello world'`)console.log(output.toString())

hello world

Go

package mainimport ("fmt""os/exec")funcmain() {output,err:=exec.Command("echo","hello world").Output()iferr!=nil {panic(err)}fmt.Println(string(output))}

hello world

exec (async)

Node.js

const{ exec}=require('child_process')exec(`echo 'hello world'`,(error,stdout,stderr)=>{if(error){console.error(err)}if(stderr){console.error(stderr)}if(stdout){console.log(stdout)}})

hello world

Go

package mainimport ("os""os/exec")funcmain() {cmd:=exec.Command("echo","hello world")cmd.Stdout=os.Stdoutcmd.Stderr=os.Stderrcmd.Run()}

hello world

tcp server

Node.js

constnet=require('net')functionhandler(socket){socket.write('Received: ')socket.pipe(socket)}constserver=net.createServer(handler)server.listen(3000)

$echo'hello'| nc localhost 3000Received: hello

Go

package mainimport ("bufio""net")funchandler(conn net.Conn) {deferconn.Close()reader:=bufio.NewReader(conn)for {message,err:=reader.ReadString('\n')iferr!=nil {return}conn.Write([]byte("Received: "))conn.Write([]byte(message))}}funcmain() {listener,err:=net.Listen("tcp",":3000")iferr!=nil {panic(err)}deferlistener.Close()for {conn,err:=listener.Accept()iferr!=nil {panic(err)}gohandler(conn)}}

$echo'hello'| nc localhost 3000Received: hello

udp server

Node.js

constdgram=require('dgram')constserver=dgram.createSocket('udp4')server.on('error',err=>{console.error(err)server.close()})server.on('message',(msg,rinfo)=>{constdata=msg.toString('utf8').trim()console.log(`received:${data} from${rinfo.address}:${rinfo.port}`)})server.on('listening',()=>{constaddress=server.address()console.log(`server listening${address.address}:${address.port}`)})server.bind(3000)