DEV Community: Weerasak Chongnguluam

ดู document ของ Bash builtin commands ผ่านคำสั่ง help

Weerasak Chongnguluam — Thu, 18 Nov 2021 14:46:04 +0000

พวกคำสั่งที่เป็น builtin ของ Bash บางครั้งใช้ man เพื่อดู manual ไม่ได้ แต่ Bash เองเตรียมคำสั่งชื่อว่า help มาไว้เพื่อดู document ของพวก builtin commands เหล่านี้ได้

ถ้าเราสั่ง help เฉยๆจะขึ้นลิสต์ command ที่สามารถดู document ได้ เช่น

ถ้าเราอยากดู document ของแต่ละ command ก็สั่ง help ตามด้วยชื่อ command นั้นๆเช่น

help echo

คำสั่ง help ช่วยได้เยอะเลยยิ่งถ้าต้องเขียน shell script เพราะบางคำสั่งเราใช้ใน script บ่อยกว่าที่จะสั่งตรงๆเช่น if หรือ for

help for

help if

ใช้คำสั่ง docker บน Ubuntu โดยไม่ต้องใช้ sudo

Weerasak Chongnguluam — Tue, 16 Nov 2021 00:56:26 +0000

หลังจากลง Docker บน Ubuntu แล้วนั่นเราจะใช้งานมันได้เราต้องใช้สิทธิ์ root ซึ่งต้องสั่ง docker โดยใช้ sudo เช่น sudo docker ps

แต่ถ้าเราอยากสั่งโดยไม่ต้องใช้ sudo ก็สามารถทำได้โดยเพิ่ม user ของเราเข้าไปใช้ usergroup ที่ชื่อว่า docker ด้วยคำสั่งแบบนี้

sudo usermod -aG docker $USER

หลังจากนั้น logout แล้ว login อีกที (ถ้าไม่ได้ก็จัดการ restart OS อีกรอบ) เราก็สามารถสั่งคำสั่ง docker ด้วย user เราเองโดยไม่ต้องใช้สิทธิ์ root ผ่าน sudo อีกแล้ว เช่น

docker run hello-world

อ้างอิง: https://docs.docker.com/engine/install/linux-postinstall/

ใช้ SSH config ช่วยจำ option เวลาจะ remote ด้วย SSH

Weerasak Chongnguluam — Mon, 15 Nov 2021 15:16:30 +0000

SSH config ช่วยให้เรา config option ของแต่ละ host เอาไว้หลายๆอันได้ ทำให้ตอนเรียก ssh ใส่แค่ชื่อ hostname ใน config ก็พอแล้ว

เวลาใช้ ssh เพื่อ remote เครื่องอื่น ปกติแล้วจะสั่งประมาณนี้

ssh user@hostname

หรือถ้ามี port ที่ต่างจาก ssh ปกติ (22) ก็ใส่ option สำหรับ port เพิ่มคือ

ssh -p 2222 user@hostname

หรือถ้ามี IdentityFile ด้วย ก็ต้องเพิ่ม option ไปอีกแบบนี้

ssh -i identity.key -p 2222 user@hostname

ตัวอย่างเช่นผมจะ ssh เข้า Ubuntu ที่ลงไว้ใน Virtual Box โดยใช้ vagrant ปกติแล้วจะสั่ง vagrant ssh ก็ได้ แต่ถ้าจะสั่งด้วย ssh เองโดยตรงจะต้องสั่งประมาณนี้

ssh -i ~/vagrants/ubuntu/.vagrant/machines/default/virtualbox/private_key -p 2222 vagrant@127.0.0.1

ทีนี้ถ้าเราจะใช้ SSH config ช่วยเราก็สร้างไฟล์ config ที่ $HOME/.ssh/config

จากนั้นกำหนดค่าแบบนี้

Host ubuntu-vagrant
  HostName 127.0.0.1
  IdentityFile ~/vagrants/ubuntu/.vagrant/machines/default/virtualbox/private_key
  Port 2222
  User vagrant

ลักษณะ config file ของ SSH ก็มี key เช่น Host, HostName, IdentityFile, Port และ User แล้วเว้นวรรคด้วย 1 ช่องว่าง ตามด้วยค่าที่กำหนดให้ key นั้นๆ

แล้วก็มีการใช้ indentation เพื่อบอกว่าค่านั้นเป็น key/value ย่อยๆของ key หลักอีกที

จากตัวอย่างผมกำหนด Host คือ ubuntu-vagrant แล้วก็กำหนดค่า HostName เป็น IP หรือ Domain name ของ Host ที่เราต้องการต่อ แล้วก็ค่า IdentityFile ไปที่ path ของ private key ของ vagrant ที่กำหนดให้กับ VM ที่ต้องการ remote ตามด้วยค่า Port 2222 แล้วก็ User คือ username ในทีนี้คือ vagrant

เสร็จแล้วหลังจากนั้นเวลาเราต้องการ connect ไปที่ Ubuntu ใน VM ก็แค่สั่ง

ssh ubuntu-vagrant

เท่านี้ก็ได้แล้ว

หา process id ที่เปิด port อยู่ด้วย lsof -i

Weerasak Chongnguluam — Wed, 03 Nov 2021 01:50:37 +0000

บางครั้งเรารันโปรแกรมที่เป็น background process ไว้แล้วมันเปิด port ที่เราต้องการใช้งานเอาไว้ด้วย ทำให้เราเอา port ไปให้ต่อไม่ได้ ต้องทำการปิดโปรแกรมนั้นโดยหา process id แล้วไป kill process นั้นก่อน

คำสั่งที่ช่วยหาว่า process id อะไรของโปรแกรมไหนใช้ port อยู่คือ lsof โดยใช้ร่วมกับ option -i เช่นต้องการหาว่าโปรแกรมไหนเปิด port 12345 อยู่ก็สั่งได้แบบนี้

lsof -i :12345

ประกอบ slice ของ byte ด้วย bytes.Buffer

Weerasak Chongnguluam — Tue, 02 Nov 2021 01:04:50 +0000

ช่วงนี้ทำงานกับ binary data บ่อยๆเพื่อทำการ encode/decode ข้อมูลที่อยู่ในรูปแบบ binary สิ่งที่เราต้องทำประจำคือเอาข้อมูลแบบ binary ที่อยู่ใน slice ของ byte ([]byte) มารวมๆกันให้เป็น byte slice ก้อนใหญ่ก้อนนึง

ท่าในการเอา byte slice สองอันมารวมกันท่านึงที่นึกออกคือใช้ฟังก์ชัน append เช่นมีข้อมูลแบบนี้

a := []byte("Hello")
b := []byte("World")

เอา a และ b มารวมกันด้วย append ได้แบบนี้

s := append(a, b...)

แต่ว่านอกจากการใช้ append แล้วเรายังใช้ type bytes.Buffer ช่วยได้

bytes.Buffer (https://pkg.go.dev/bytes#Buffer) นั้นซ่อนข้อมูล []byte เอาไว้แล้วเตรียม method ที่ implements interface Reader และ Writer เอาไว้ให้ ทำให้เราประกอบข้อมูล []byte ผ่านทาง method พวกนี้ได้ และใช้ method/function อื่นๆที่ทำงานกับ Reader และ Writer ได้อีกด้วย

ตัวอย่างเราสามารถประกอบ a และ b ได้โดยการใช้ bytes.Buffer ได้ดังนี้

var buf bytes.Buffer

buf.Write(a)
buf.Write(b)
s := buf.Bytes()

ตัวอย่างที่ซับซ้อนขึ้นเช่นถ้าเราต้องการแปลงตัวเลข 32 bits (4 bytes) เป็น binary format เช่นมีเลข 65535 แปลงเป็น 32 bits format จะได้ 00000000000000001111111111111111 เขียนอยู่ในรูป byte slice จะได้ []byte{0, 0, 255, 255}

เราจะใช้ package binary ช่วยแปลงเลขเป็น byte slice แล้ว Write เข้าไปใน buffer แบบนี้

i := uint32(65535)
c := make([]byte, 4)
binary.BigEndian.PutUint32(c, i)
buf.Write(c)

แต่เนื่องจากว่า bytes.Buffer นั้น implements Writer เอาไว้เราเลยเขียนแบบนี้ได้สั้นกว่า

i := uint32(65535)
binary.Write(&buf, binary.BigEndian, i)

เพราะ binary.Write ค่าแรกนั้นรับ Writer นั่นเอง

Interface type literal

Weerasak Chongnguluam — Sun, 26 Sep 2021 05:09:00 +0000

เวลาเราต้องการใช้ interface ส่วนใหญ่เราจะสร้าง type ชื่อใหม่สำหรับ inteface แล้วค่อยเอา type ชื่อใหม่นั้นไปใช้ ประกาศตัวแปร หรือกำหนด parameter ของ function/method แต่จริงๆเราสามารถใช้งาน interface ได้เลยโดยไม่ต้องสร้าง type ใหม่ได้เช่นกัน

Type Literal

จาก spec ของ Go https://golang.org/ref/spec#Types บอกเอาไว้เกี่ยวกับ Type Literal เอาไว้ว่า

A type may be denoted by a type name, if it has one, or specified using a type literal, which composes a type from existing types.

TypeLit = ArrayType | StructType | PointerType | FunctionType | InterfaceType | SliceType | MapType | ChannelType.

จากที่เห็นในลิสต์นี้ ทั้งหมดนี่คือ type ที่เราเอามาใช้งานแบบ type literal ได้ ซึ่งก็รวมถึง InterfaceType ด้วยนั่นเอง

ประกาศตัวแปรโดยใช้ Interface type literal

เวลาประกาศตัวแปรของ interface type literal เราก็แค่ยก interface block แบบที่เราเคยใช้กับตอน ประกาศ type นั่นล่ะ มาใช้ได้เลย เช่น

var finder interface {
    Find(keyword string) []result
}

เท่านี้ตัวแปร finder ก็จะเป็นตัวแปรของ type interface ที่มี 1 method คือ Finder(keydord string) []result แล้ว

หรือมีจุดอื่นที่เราต้องการใช้งาน interface type เช่นตอนทำ type assertion เราก็สามารถยก type literal ไปใช้ได้เช่นกันโดยไม่ต้องสร้าง type ชื่อใหม่ เช่น

finder, ok := f.(interface { Finder(string) []result })

ตัวอย่างจาก standard package `errors`

package errors https://pkg.go.dev/errors นั้นมี concept ใหม่คือเรื่อง Unwrap error ซึ่ง document เขียนเอาไว้ว่า

The Unwrap, Is and As functions work on errors that may wrap other errors. An error wraps another error if its type has the method Unwrap() error

คือ Unwrap, Is และ As functions ใน package errors นั้นทำงานกับ error type ที่มี method Unwrap() error

บอกแบบนี้นั่นก็คือ type ที่ implements method Unwrap() error นั่นละ แต่ว่าถ้าเราดู type ที่อยู่ใน document ของ errors จะพบว่าเราไม่เจอ interface type สำหรับ Unwrap() error method เลย

แบบนี้แล้ว function Unwrap, Is และ As มันจัดยังไงนะ ลองเข้าไปดูโค้ดของสามฟังก์ชันนี้กัน

เริ่มที่ Unwrap

func Unwrap(err error) error {
    u, ok := err.(interface {
        Unwrap() error
    })
    if !ok {
        return nil
    }
    return u.Unwrap()
}

จะเห็นว่า ใช้ type assertion แต่ว่าตรงที่อยู่ใน () หลัง err. นั้นไม่ใช่ชื่อ type โดยตรง แต่เป็นการใช้ interface type literal นั่นเอง

ถัดไปดูที่ Is

func Is(err, target error) bool {
    if target == nil {
        return err == target
    }

    isComparable := reflectlite.TypeOf(target).Comparable()
    for {
        if isComparable && err == target {
            return true
        }
        if x, ok := err.(interface{ Is(error) bool }); ok && x.Is(target) {
            return true
        }

        if err = Unwrap(err); err == nil {
            return false
        }
    }
}

จะเห็นว่าก็มีจุดที่ใช้ type assertion พร้อมกับใช้ interface type literal เช่นกัน แต่เป็นการเช็คว่า type implements method Is(error) bool หรือเปล่า

ต่อไปก็ดูที่ As

func As(err error, target interface{}) bool {
    if target == nil {
        panic("errors: target cannot be nil")
    }
    val := reflectlite.ValueOf(target)
    typ := val.Type()
    if typ.Kind() != reflectlite.Ptr || val.IsNil() {
        panic("errors: target must be a non-nil pointer")
    }
    targetType := typ.Elem()
    if targetType.Kind() != reflectlite.Interface && !targetType.Implements(errorType) {
        panic("errors: *target must be interface or implement error")
    }
    for err != nil {
        if reflectlite.TypeOf(err).AssignableTo(targetType) {
            val.Elem().Set(reflectlite.ValueOf(err))
            return true
        }
        if x, ok := err.(interface{ As(interface{}) bool }); ok && x.As(target) {
            return true
        }
        err = Unwrap(err)
    }
    return false
}

ก็เหมือนกับสองอันก่อนหน้านี้แต่คราวนี้คือเช็คว่า type implements method As(interface{}) bool หรือเปล่า นั่นเอง

ทำไมเขาถึงเลือกใช้ท่านี้กันนะ 🤔

คิดว่าอาจจะเป็นเพราะ interface ที่จะใช้งานนั้นมีแค่ method เดียว แล้วก็ไม่ได้ใช้ที่อื่นเลยยกเว้นแค่ในตัวฟังก์ชันเอง

กับสิ่งที่ทำให้ทำแบบนี้ได้ก็เพราะ Go interface นั้นคน implements ไม่จำเป็นต้องรู้ type ของ interface ของแค่มี methods ตรงตาม spec แค่นั้นเอง

อ้าวแล้วถ้าคน implements ไม่ได้ implement method ที่ต้องการไว้ล่ะ

ก็เป็นหน้าที่ของฝั่งคนใช้ interface ในกรณีนี้คือ 3 ฟังก์ชันนี้ ต้องเขียน logic จัดการเอาไว้ว่าถ้า implement จะทำยังไง ถ้าไม่ implement จะทำยังไง ซึ่งก็ใช้ type assertion นั่นเอง

อาจจะดูแปลกๆเพราะคัดกับภาษาที่คน implement ต้องระบุชัดเจนว่าจะ implement interface ไหนบ้าง เช่น (Java, C#)

เพราะหลักการของ Go นั้น คนที่ต้องการใช้งาน interface ต้องเป็นคนระบุ spec เอง ในเคสนี้คือฟังก์ชัน Unwrap, Is และ As ทั้ง 3 ฟังก์ชันนี้ใช้ Interface เพื่อให้การทำงานของตัวเองยืดหยุ่นพอที่จะทำงานกับหลายๆ type ได้ ขอแค่ type นั้น implements method ตามที่ต้องการ

Encode / Decode Hexadecimal string to/from binary data

Weerasak Chongnguluam — Sat, 04 Sep 2021 04:50:34 +0000

ช่วงนี้ต้องจัดการข้อมูลที่เป็น binary ซึ่งบางครั้งข้อมูลอยู่ในรูปแบบ BCD ซึ่งถ้าให้เขียนเป็นเลขฐานสองโดยตรงก็จะยาว และยากต่อการอ่านเวลา debug เกินไป ดังนั้นก็เลยแปลงให้อยู่ในเลขฐานสิบหกดีกว่าเวลาต้อง debug หรือ log ข้อมูล

สำหรับ Go มี package encoding/hex ที่มีฟังก์ชันให้เราใช้แปลงไปมาระหว่าง binary data ([]byte) ไปเป็น hexadecimal string ได้ง่ายๆอยู่ คือฟังก์ชัน

func EncodeToString(src []byte) string

func DecodeString(s string) ([]byte, error)

ตัวอย่างการใช้งานเช่น เมื่อเราต้องการแปลงจาก Hex ที่เป็น string กลับไปเป็น binary data

package main

import (
    "encoding/hex"
    "fmt"
    "log"
)

func main() {
    bcdNumberHex := "1234"
    bcdNumberBytes, err := hex.DecodeString(bcdNumberHex)
    if err != nil {
        log.Fatal(err)
    }
    for _, b := range bcdNumberBytes {
        fmt.Printf("0x%x ", b)
    }
// Output:
// 0x12 0x34
}

ตัวอย่างการใช้งานเช่น เมื่อเราต้องการแปลงจาก binary data กลับไปเป็น Hex string

package main

import (
    "encoding/hex"
    "fmt"
)

func main() {
    bcdNumberBytes := []byte{0x12, 0x34}
    bcdNumberHex := hex.EncodeToString(bcdNumberBytes)
    fmt.Println(bcdNumberHex)

// Output:
// 1234
}

Go program start from main function and stop when main function exit

Weerasak Chongnguluam — Thu, 15 Jul 2021 01:07:30 +0000

โปรแกรมที่เราเขียน ไม่ว่าจะเขียนด้วยภาษาอะไร มันจะมีวงจรชีวิต (life cycle) ของมันว่าจะเริ่มทำงานที่จุดไหน และ สิ้นสุดที่ตรงไหน เสมอ

ถ้าเราเข้าใจ life cycle ของโปรแกรม ของภาษาที่เราใช้ หรือ เข้าใจ life cycle ของ runtime ที่เราใช้ เราก็จะไล่การทำงานของโปรแกรมได้ง่ายขึ้นเยอะเลย

อย่างโปรแกรมที่เขียนด้วย Go นั้นจะเริ่มทำงานที่ฟังก์ชัน main ใน package main และจะหยุดทำงานเมื่อ main ฟังก์ชันจบการทำงาน ไม่ว่าจะด้วยการ return ปกติ, การเรียก os.Exit ฟังก์ชัน หรือโดน signal จาก OS ให้หยุดทำงาน

ตัวอย่างเช่นโค้ดแบบนี้

package main

import (
    "fmt"
)

func main() {
    fmt.Println("Hello, playground")
}

เมื่อเรารันก็ได้ข้อความ Hello, playground ในออกไปที่ standard output แต่ถ้าเราเปลี่ยนตรง fmt.Println ให้ไปไปรันในอีก goroutine ล่ะ แบบนี้

package main

import (
    "fmt"
)

func main() {
    go func() {
        fmt.Println("Hello, playground")
    }()
}

เวลารันกลับไปเห็นเกิดอะไรขึ้นเลย นั่นเพราะว่า พอ main ฟังก์ชันเริ่มทำงาน มันสร้าง goroutine ใหม่ เสร็จแล้วมันก็จบการทำงานของตัวเองโดยไม่รอให้ฟังก์ชันของ goroutine อีกอันที่สร้างใหม่ได้ทำงานเลย เมื่อ main จบการทำงาน ถือว่าจบโปรแกรม goroutine ที่เหลือก็จบการทำงานด้วยไปโดยอัตโนมัติ

ถ้าอยากให้ main รอให้ goroutine ที่แยกไปทำงานเสร็จก่อนก็ทำได้แบบนี้

package main

import (
    "fmt"
)

func main() {
    done := make(chan struct{})
    go func() {
        fmt.Println("Hello, playground")
        close(done)
    }()
    <-done
}

ใช้ channel ช่วย โดยให้ main รอรับค่า ส่วนใน goroutine เมื่อทำงานเสร็จก็ close channel ซะทำให้ตรงส่วนที่รอรับค่าไม่ block เลยทำให้ main จบการทำงานต่อไปได้

ทีนี้ตัวอย่างถัดไป โค้ด HTTP server ง่ายๆแบบนี้

package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "Hello, World")
    })

    http.ListenAndServe(":8000", nil)
}

จะเห็นว่า โปรแกรมเรามันรันแล้วค้างไว้ รอรับ request มาที่ port 8000 แล้วตอบกลับไปด้วยข้อความ Hello, World โดยที่จบการทำงานเมื่อเราสั่ง ctrl+c เพื่อให้ OS ส่ง signal ไปจบ process

แสดงว่าโค้ดที่เราเรียก http.ListenAndServe มันเป็นฟังก์ชันที่รันนานๆเลยไม่จบจนกว่าจะมี signal มาหยุดมันนั่นเอง มันเลย block main ฟังก์ชันเอาไว้ให้ยังรันอยู่ไม่ไปไหน

ถ้าเราไล่โค้ดใน http.ListenAndServe เราจะไต่ไปถึงจุดที่เรียก method (srv *Server) Serve(l net.Listener) error ที่มีโค้ด for loop แบบนี้อยู่

for {
        rw, err := l.Accept()
        if err != nil {
            select {
            case <-srv.getDoneChan():
                return ErrServerClosed
            default:
            }
            if ne, ok := err.(net.Error); ok && ne.Temporary() {
                if tempDelay == 0 {
                    tempDelay = 5 * time.Millisecond
                } else {
                    tempDelay *= 2
                }
                if max := 1 * time.Second; tempDelay > max {
                    tempDelay = max
                }
                srv.logf("http: Accept error: %v; retrying in %v", err, tempDelay)
                time.Sleep(tempDelay)
                continue
            }
            return err
        }
        connCtx := ctx
        if cc := srv.ConnContext; cc != nil {
            connCtx = cc(connCtx, rw)
            if connCtx == nil {
                panic("ConnContext returned nil")
            }
        }
        tempDelay = 0
        c := srv.newConn(rw)
        c.setState(c.rwc, StateNew, runHooks) // before Serve can return
        go c.serve(connCtx)
    }

มันคือ infinity loop ที่ทำงานรอรับ request แล้วส่งไปโปรเซสต่อเพื่อทำงานตาม handler ที่เรา register เอาไว้ใน main ฟังก์ชันนั่นเอง

การที่เรารู้ว่าทุกอย่างเริ่มที่ main ฟังก์ชัน แต่ก็ไม่จำเป็นว่าเราต้องไล่โค้ดเริ่มที่ main ฟังก์ชันเสมอไป เพราะโค้ดใน main ฟังก์ชันจะเป็นการ initialize ค่าเริ่มต้นของสิ่งต่างๆมากกว่าเป็น business logic จริงๆแล้วเราเป็นคนออกแบบ life cycle ของโปรแกรมเราอีกทีว่า จะทำงานอะไร เมื่อมีเงื่อนไขแบบไหน เช่นถ้าเราทำ Web API เราสนใจแค่การทำงานของ endpoint หนึ่ง เราก็ไม่จำเป็นต้องเริ่มที่ main ฟังก์ชันก็ได้ แต่ขอให้เรารู้ว่าสิ่งต่างๆถูก setup เริ่มต้นมาจาก main ก่อน ก่อนที่จะเริ่ม life cycle ในการรับ request แล้ว process response นั่นเอง

asdf install Erlang with docs

Weerasak Chongnguluam — Wed, 09 Jun 2021 15:27:35 +0000

Erlang เป็นอีกภาษาที่ทีมพัฒนาเขียน document เอาไว้ดีมากๆ มีให้ทั้งเป็น manpage, html, pdf และ chunks ที่เรียกดูได้จาก erl

ทีนี้ผมใช้ asdf เป็นเครื่องมือในการติดตั้ง Erlang ซึ่งจะไปใช้ kerl อีกที แล้วถ้าอยากให้มันติดตั้ง document ให้ด้วยต้องใส่ env ให้ถูกต้อง

แต่ว่าในหน้า README ของ asdf erlang plugin กับ kerl ดันบอกว่าให้ใส่แค่ env ตัวเดึยวคือตัวนี้

export KERL_BUILD_DOCS=yes

แต่ลองแล้วก็ไม่เห็นจะได้ document แบบ manpage, html, pdf มาเลย แต่เจอว่าใช้งานผ่าน erl ได้

สุดท้ายไล่ดูโค้ดของ asdf erlang plugin กับ kerl จนเจอว่ามันต้องระบุประเภทของ format ของ document ด้วยผ่านอีก env คือ

export KERL_DOC_TARGETS="man html pdf chunks"

ซึ่งใส่หลาย format ได้

เท่านี้ก็ลง Erlang ผ่าน asdf แล้วได้ document ครบทุกประเภทแล้ว

ใช้ Dev.to API ถึงข้อมูลของบทความที่เขียนออกมา

Weerasak Chongnguluam — Tue, 08 Jun 2021 02:34:35 +0000

เว็บ Dev.to ที่เขียนอยู่นี้มี API ให้ใช้ด้วย ตัวอย่างเช่นถ้าเราอยากลิสต์บทความของ user คนไหนออกมาดูก็เรียก http GET ที่ endpoint นี้ แล้วใส่ query string username กับกำหนดชื่อ username ที่ต้องการลิสต์บทความ

https://dev.to/api/articles?username=iporsut

ซึ่งปกติจะได้ 30 บทความล่าสุด แต่ตัว API support pagination ด้วยก็ใส่ option ดึง page ต่อไปมาได้

ทีนี้ถ้าอยากดูข้อมูลเฉพาะของบทความใดๆ ก็เรียก GET ไปที่ endpoint เดิม แต่ใส่ path param เป็น ID ของบทความที่ต้องการ แบบนี้

https://dev.to/api/articles/719722

ซึ่งก็จะมีข้อมูลของบทความหมายเลข 719722 ออกมาซึ่งรวมทั้ง HTML ของหน้าบทความนี้ด้วย

นอกจากนั้นยังมี API อื่นๆอีกลองเราไปดูได้ที่นี่ครับ https://docs.forem.com/api/

มีประโยชน์มากๆเพราะเราสามารถเขียนบทความที่ dev.to แล้วไปสร้าง page ของเราเองที่ดึงข้อมูลจาก dev.to ไปแสดงเพื่อ custom การแสดงผลเองได้ด้วย

ขอฝาก Buy Me a Coffee

สำหรับท่านใดที่อ่านแล้วชอบโพสต์ต่างๆของผมที่นี่ ต้องการสนับสนุนค่ากาแฟเล็กๆน้อยๆ สามารถสนับสนุนผมได้ผ่านทาง Buy Me a Coffee คลิ๊กที่รูปด้านล่างนี้ได้เลยครับ

Go time Sleep with cancellable with Context

Weerasak Chongnguluam — Sun, 06 Jun 2021 15:06:11 +0000

ฟังก์ชัน time.Sleep ใน Go เราใช้เพื่อหน่วงเวลาให้ goroutine ที่ฟังก์ชันนี้รันหยุดทำงานไปเป็นจำนวนเวลาเท่าที่เราใส่ให้ฟังก์ชันตอนเรียกใช้งาน

แต่ถ้าเกิดเราต้องการให้ time.Sleep นั้นถูกยกเลิกการ Sleep ก่อนเวลาที่เราส่งให้มัน เราต้องสร้าง Sleep ฟังก์ชันขึ้นมาเองแบบที่ยกเลิกได้

สิ่งที่ช่วยได้ก็คือ type Timer ซึ่งเรากำหนดค่า duration ให้กับมันแล้วมันก็จะส่ง signal ออกมาที่ channel C ซึ่งเป็น field นึงของ type Timer นั่นเอง

ดังนั้น ถ้าเวลาผ่านไปยังไม่ถึง duration ที่กำหนด แล้วเราไปพยายามเอาค่าออกมาจาก C มันก็จะหยุดเหมือน time.Sleep นั่นเอง

โค้ดแบบนี้ ทำหน้าที่เหมือน time.Sleep

func mySleep(d time.Duration) {
        timer := time.NewTimer(d)
        <-timer.C
}

สิ่งที่ Timer มีมากกว่า Sleep คือมันมี method Stop ให้ยกเลิก Timer ก่อนเวลาที่กำหนดได้

ต่อไปเราจะทำให้ฟังก์ชัน SleepContext ของเรานั้นรับ context.Context เข้ามาด้วย เพื่อใช้เป็น signal ว่าเมื่อ context นั้นทำงานเสร็จ หรือยกเลิกแล้ว นั้นเราก็จะเรียก timer.Stop ด้วยนั่นเอง

โค้ดของ SleepContext ที่จะ Sleep และยกเลิกถ้า ctx นั้นถูกยกเลิกหรือ Done เรียบร้อยแล้ว

func SleepContext(ctx context.Context, d time.Duration) {
        timer := time.NewTimer(d)
        select {
        case <-ctx.Done():
                timer.Stop()
        case <- timer.C:
        }
}

เราใช้ select statment เพื่อรอรับค่าจากทั้ง ctx.Done() หรือ timer.C อะไรมีค่ามาก่อนก็จบการทำงานของฟังก์ชัน แต่ถ้า ctx.Done() ก่อนก็ไม่ลืมที่จะยกเลิก timer ไปด้วย เพื่อไม่ให้มันยังทำงานทำให้เกิด memory leak อยู่จนกว่าจะหมดเวลา

ขอฝาก Buy Me a Coffee

Regular Expression for match empty string

Weerasak Chongnguluam — Wed, 02 Jun 2021 15:05:17 +0000

วันนี้มีโจทย์ให้ต้อง validate query string ของ API ให้รับแค่ string ที่มี A-Za-z0-9 ที่ต้องมี 3 ตัวอักษร เช่น "ABC", "A9C" หรือ empty string "" เท่านั้น สิ่งที่ช่วยได้นั่นคือ Regular Expression นั่นเอง

สำหรับ RegEx ที่ match A-Za-z0-9 จำนวน 3 ตัวอักษรนั้นไม่ยาก เขียนได้แบบนี้

[A-Za-z0-9]{3}

โดยที่ [] ใช้กำหนดว่าจะรองรับ character แบบไหนบ้าง และ {3} เป็นการกำหนดจำนวนว่าต้องมีขนาด 3 ตัวอักษร

สำหรับ RegEx ที่ match empty string นั้นง่ายกว่าที่คิด เพราะเขียนแค่นี้

^$

^ เป็นสัญลักษณ์กำหนดอักษรขึ้นต้น และ $ กำหนดอักษรสุดท้าย พอเอาสองตัวนี้มาติดกันแล้วไม่มีอักษรอะไรคั่น ก็ทำให้มันรองรับ empty string ได้นั่นเอง

สุดท้าย เราต้องการรองรับทั้งสองแบบนี้อย่างใดอย่างหนึ่ง RegEx นั้นใช้สัญลักษณ์ | แทน or เพื่อบอกว่าจะ match pattern ทางซ้ายหรือขวาก็ได้เช่นกัน กลายเป็น RegEx ที่ต้องการมีหน้าตาแบบนี้

^$|[A-Za-z0-9]{3}

DEV Community: Weerasak Chongnguluam

ดู document ของ Bash builtin commands ผ่านคำสั่ง help

ใช้คำสั่ง docker บน Ubuntu โดยไม่ต้องใช้ sudo

ใช้ SSH config ช่วยจำ option เวลาจะ remote ด้วย SSH

หา process id ที่เปิด port อยู่ด้วย lsof -i

ประกอบ slice ของ byte ด้วย bytes.Buffer

Interface type literal

Type Literal

ประกาศตัวแปรโดยใช้ Interface type literal

ตัวอย่างจาก standard package errors

ทำไมเขาถึงเลือกใช้ท่านี้กันนะ 🤔

Encode / Decode Hexadecimal string to/from binary data

Go program start from main function and stop when main function exit

asdf install Erlang with docs

ใช้ Dev.to API ถึงข้อมูลของบทความที่เขียนออกมา

ขอฝาก Buy Me a Coffee

Go time Sleep with cancellable with Context

ขอฝาก Buy Me a Coffee

Regular Expression for match empty string

ขอฝาก Buy Me a Coffee

ตัวอย่างจาก standard package `errors`