30 줄의 이동으로 무엇을 할 수 있습니까? 기능을 보여주는 유용하고 완전한 프로그램을 만들 수 있습니까? [닫은

StackOverflow https://stackoverflow.com/questions/1735073

  •  20-09-2019
  •  | 
  •  

문제

그래서 지난 며칠 동안 큰 버즈는 가다, Google의 새로운 언어. 당신이 나와 같은 모든 강박적인 프로그래밍 언어 괴짜라고 가정하면, 당신은 모두 그것을 다운로드하고, 그것을 만들었고, 당신의 "Hello, 世界"프로그램을 실행했습니다 (UTF-8의 발명가가 쓴 언어를 사용하는 것은 좋지 않습니까?) . 당신은 모두 읽었습니다 튜토리얼, 효과적인 이동, 및 다른 문서 중 일부.

자, 당신은 그것으로 무엇을 할 건가요?

Go의 힘을 보여주는 데모를보고 싶습니다. 간단한 프로그램에서 무엇을 할 수 있습니까? 최상의 예제 코드를 보여줍니다. 요구 사항이 변경된 프로젝트를 통해 많은 프로그래머 팀과 함께 대형 코드베이스를 작성하고 유지 관리 할 때까지 언어의 실제 측정 값을 실제로 취할 수는 없습니다. 코드는 언어의 표현력을 입증하는 데 도움이됩니다. GO의 독특한 새로운 기능을 진정으로 행사하는 짧고 완전한 프로그램을보고 싶습니다. 스 니펫이나 "안녕하세요, 세계"뿐만 아니라.

그래서 당신이 쓴 멋진 코드를 게시하십시오. 동시성을위한 Goroutines 및 채널 및 인터페이스 기반 유형 시스템과 같은 고유 한 기능을 활용하십시오. 원시 채팅 서버 또는 Cool IRC Bot을 쓸 수 있습니까? 많은 코어로 스케일링하는 병렬 만델 브로트 세트를 구현 하시겠습니까? 작은 언어에 대한 통역사를 작성 하시겠습니까? 그리고 30 줄로 할 수 있습니까?

나는 당신이 오버플레이션과 스크롤 막대를 얻지 않고 스택 오버 플로우 코드 블록에 맞을 수있는만큼 임의로 30을 선택했습니다. 골프를 너무 많이하지 않고 흥미로운 일을하기에 충분하지만 빠른 데모를 위해 모든 사람의 관심을 유지하기에 충분히 짧습니다. 예를 들어, 약간의 재구성만으로도 그 예는 웹 서버 적합 할 수 있어야합니다 (데이터 계산하지 않음).

GO 코드를 보여주세요!

도움이 되었습니까?

해결책

이것은 현재 시간을 보여주는 시계 얼굴의 PNG (stdout)를 만듭니다. 30 줄에 맞는 것은 간신히 골프적이므로 코드는 그다지 깨끗하지 않습니다.

package main
import ("image"; "image/png"; "math"; "bufio"; "os"; "time")
const clock_size = 200;
const radius = clock_size / 3;
var colour image.RGBAColor;
func circle (clock *image.RGBA) {
    for angle := float64(0); angle < 360; angle++ {
        radian_angle := math.Pi * 2 * angle / 360;
        x := radius * math.Sin (radian_angle) + clock_size/2;
        y := radius * math.Cos (radian_angle) + clock_size/2;
        clock.Set (int (x), int (y), colour);}}
func hand (clock *image.RGBA, angle float64, length float64) {
    radian_angle := math.Pi * 2 * angle;
    x_inc := math.Sin (radian_angle);
    y_inc := -math.Cos (radian_angle);
    for i := float64(0); i < length; i++ {
        x := i * x_inc + clock_size/2;
        y := i * y_inc + clock_size/2;
        clock.Set (int (x), int (y), colour);}}
func main () {
    clock := image.NewRGBA (clock_size, clock_size);
    colour.A = 255;
    circle (clock);
    time := time.LocalTime ();
    hand (clock, (float64(time.Hour) + float64(time.Minute)/60)/12, radius*0.6); // hour hand
    hand (clock, (float64(time.Minute) + float64(time.Second)/60)/60, radius*0.8); // minute hand
    out := bufio.NewWriter(os.Stdout);
    defer out.Flush();
    png.Encode(out, clock);
}

처럼 실행하십시오

8.out > clock.png

그 플로트 64 캐스트를 모두 주목하십니까? 나는 유형에 관한 것만 큼 엄격한 언어를 본 적이 없다.

이것은 고정 된 동일한 코드입니다 go fix (및 일부 수동 조정) 그런 다음 자동으로 포맷했습니다. go fmt. 수동으로 삽입 된 일부 신약.

package main

import (
    "bufio"
    "image"
    "image/color"
    "image/png"
    "math"
    "os"
    "time"
)

const clock_size = 200
const radius = clock_size / 3

var colour color.RGBA

func circle(clock *image.RGBA) {
    for angle := float64(0); angle < 360; angle++ {
        radian_angle := math.Pi * 2 * angle / 360
        x := radius*math.Sin(radian_angle) + clock_size/2
        y := radius*math.Cos(radian_angle) + clock_size/2
        clock.Set(int(x), int(y), colour)
    }
}

func hand(clock *image.RGBA, angle float64, length float64) {
    radian_angle := math.Pi * 2 * angle
    x_inc := math.Sin(radian_angle)
    y_inc := -math.Cos(radian_angle)
    for i := float64(0); i < length; i++ {
        x := i*x_inc + clock_size/2
        y := i*y_inc + clock_size/2
        clock.Set(int(x), int(y), colour)
    }
}

func main() {
    clock := image.NewRGBA(image.Rect(0, 0, clock_size, clock_size))
    colour.A = 255
    circle(clock)
    time := time.Now()
    hand(clock, (float64(time.Hour())+float64(time.Minute())/60)/12, radius*0.6)   // hour hand
    hand(clock, (float64(time.Minute())+float64(time.Second())/60)/60, radius*0.8) // minute hand
    out := bufio.NewWriter(os.Stdout)
    defer out.Flush()
    png.Encode(out, clock)
}

다른 팁

이것은 HTTP 기본 인증이 필요한 웹 서비스에 대한 무시 액세스를 제공하기 위해 쓴 웹 프록시입니다. 나는 내부 사물에 그것을 필요로했다.

package main

import (
    "flag"
    "log"
    "net/http"
    "net/url"
)

var target = flag.String("target", "http://www.google.com/", "Where to go.")
var addr = flag.String("listen", ":12345", "Address/port on which to listen.")
var auth = flag.String("auth", "", "Authorization header to add (optional).")

func main() {
    flag.Parse()

    targetUrl, uerr := url.Parse(*target)
    if uerr != nil {
        log.Fatalf("Error parsing target ``%s'': ", target, uerr.String())
    }

    proxy := http.ReverseProxy{Director: func(req *http.Request) {
        req.URL.Scheme = targetUrl.Scheme
        req.URL.Host = targetUrl.Host
        req.Host = targetUrl.Host
        if *auth != "" {
            req.Header.Set("Authorization", *auth)
        }
    }}

    log.Fatal(http.ListenAndServe(*addr, &proxy))
}

좋아, 공을 굴릴게. 여기 내 첫 Go 프로그램이 있습니다. 매우 원시적 인 채팅 서버이며 약간 압축하면 80 자의 30 줄에 맞습니다. 형식 gofmt, 60 줄입니다. 하드 코딩 된 포트 (4242)를 듣고 기본적으로 오류 처리가 없으며 클라이언트가 오류가 발생하면 클라이언트를 읽는 것을 중지하는 것 외에는 클라이언트 단절을 처리하지 않습니다.

package main
import ("net";"container/vector";"bufio";"strings")
type client struct { conn net.Conn; send chan string; receive chan string }
func main() {
    if listener, err := net.Listen("tcp", "0.0.0.0:4242"); err == nil {
        master := make(chan string, 100);
        clients := vector.New(0);
        go runServer(master, clients);
        for {
            if conn, err := listener.Accept(); err == nil {
                c := client{ conn, master, make(chan string, 100) };
                clients.Push(c);
                go runClient(c);
            } else { break } } } }
func runServer(master chan string, clients *vector.Vector) {
    for { 
        message := <-master;
        clients.Do(func (c interface{}) { c.(client).receive <- message }); } }
func runClient(c client) {
    input := make(chan string, 10);
    go readLines(c, input);
    for {
        select {
        case inMessage := <-input: c.send <- inMessage;
        case outMessage := <-c.receive: c.conn.Write(strings.Bytes(outMessage));
        } } }
func readLines(c client, input chan string) {
    reader := bufio.NewReader(c.conn);
    for { if line, err := reader.ReadString('\n'); err == nil 
            { input <- line; } else { break } } }

다음과 같이 빌드하고 실행합니다.

$ 6g server.go
$ 6l -o server server.6
$ ./server

그리고 다른 터미널에서

$ nc localhost 4242

나는 Go의 채널과 The를 정말 좋아합니다 select 진술, 여기에 "특정 시간 내에 가능한 한 많은 것을 얻고"개념을 표현하는 것이 얼마나 쉬운 지 보여주는 것이 있습니다.

이것은 300 밀리 초 이내에 가능한 많은 임의의 숫자를 생성하고 그 당시 생성 된 가장 큰 것을 반환합니다.

package main

import (
  "fmt"
  "math/rand"
  "time"
)

func main() {
  timeout := time.After(300 * time.Millisecond)
  numbers := make(chan int) // This channel will be used 
  var numberCount int = 0
  var maxNumber int = 0

  // Start putting random numbers on the numbers channel
  go func() {
    for {
      numbers <- rand.Int()
    }
  }()

  for {
    select {
    case <- timeout:
      fmt.Printf("%v numbers generated. Max number found: %v.\n", numberCount, maxNumber)
      return

    case number := <- numbers:
      numberCount++
      if number > maxNumber {
        maxNumber = number
      }
    }
  }
}

나는 이것을 어딘가에서 복사했다. 상당히 간단하지만 몇 가지 기능을 보여줍니다.

package main
import ("fmt"; "os" ;"bufio";"io")
func main() {
        if len(os.Args) < 2 {
                fmt.Printf("usage: catfile \n")
        } else if pFile, err := os.OpenFile(os.Args[1], os.O_RDONLY, 0); err != nil {
                fmt.Printf("error opening file : %s\n", err)
        } else {
            defer pFile.Close()
        displayFile(pFile)
    }
}

func displayFile(pFile *os.File) {
        oReader := bufio.NewReader(pFile);
        for {
                if sLine, err := oReader.ReadString('\n'); err == nil {
            fmt.Printf("%s", sLine)
        } else {
            if err != io.EOF {fmt.Printf("error reading file : %s\n", err)}
                    break
        } 
        }
}
라이센스 : CC-BY-SA ~와 함께 속성
제휴하지 않습니다 StackOverflow
scroll top