go lang -1

원종서·2021년 8월 29일

go언어

목록 보기

1/2

part1

package main

// go lang must write a pacage name
// 컴파일 하기 위해서는 pacage main  을 적어주어야 한다.

import "fmt"
//fmt : fommatting
// 함수를 import 하기 위해선 해당 함수 첫 글자를 대문자로 써야한다.


//  func main 이 entry point
func main(){
fmt.Println("Hello world")
}

part 2

package main

import (
	"fmt"
)

// fmt : fommatting
// 함수를 import 하기 위해선 해당 함수 첫 글자를 대문자로 써야한다.

func main(){

	// const name string = "jongseo" // 상수 선언

	name := "jongseo" // 같은 것, var name string ="jongseo"  
	// 함수 내에서만 축약이 가능함


	fmt.Println(name) ;
	name= "jjongseo";
	fmt.Println(name) ;

	
}

part 3


package main

import (
	"fmt"
	"strings"
)


func mutifly ( a int ,b int ) int { 
	return a* b
}

func add ( a, b int)  int {
	return a + b
}

// Go lang's func can have muti Return value
func lenAndUpper (name string) (int, string ){
	return len(name), strings.ToUpper(name)
	// 반환 값이 두개인데 한개만 받을 경우 Go에서 에러를 발생시킴,]
	// totalLength, _ = lenAndUpper("jonsgeo")
	// _는  컴파일러가 value값을 무시함
}


func repeatMe(words ...string){
	// ...string 은 인자를 원하는 대로 받겠다를 의미

	fmt.Println(words)
}

func main(){
fmt.Println(mutifly(2,2))
	totalLength , upperName := lenAndUpper("jongseo")
	// 선언하고 사용하지 않으면 GO 에서 에러를 발생시킴
	fmt.Println(totalLength,upperName)

	repeatMe("jong", "duck", "byun", "chan")  //[jong duck byun chan]

	
}

part 4


package main

import (
	"fmt"
	"strings"
)

// naked retrun 이란
// 반환할 변수를 굳이 명시하지 않아도 됨.
func lenAndUpper (name string) (lenght int, uppercase string ){
	//defer : func이 끝났을대 추가적인 동작을 할 수 있게 도와줌 
	defer fmt.Println("Im done!")

	// 함수가 호출되는 동시 stirng name을 받고 
	// 빈환값으로 int length, 와 stirng uppercase을 자동적으로 만들어준다.
	lenght = len(name)
	uppercase = strings.ToUpper(name)

	return 
}


func main(){
	totalLength, upperCase := lenAndUpper("wonjongseo")

	fmt.Println(totalLength,upperCase)
	
}

part (for)

package main

import (
	"fmt"
)


func rangedFor(numbers ...int) int{
	
	for index, number := range numbers {
		fmt.Println(index, number)
	}
	fmt.Println("------")

	for i:= 0 ; i< len(numbers) ; i++ {
		fmt.Println(i)		
	}
	return 1
}

func superAdd(numbers ...int) int{
	total := 0
	for _, number := range numbers {
		total += number
	}
	return total
}


func main(){
	result := superAdd(1,2,3,4,5,6,7,8,9,10)

	fmt.Println(result)
}

part (if)

package main

import (
	"fmt"
)

func canIDring(age int) bool{
	// go 에서는 조건문을 들어가기전에 변수를 설정할 수 있다.
	if koreanAge := age +2 ; koreanAge < 18 {
		return false
	} else {
		return true
	}
}

func main(){

	fmt.Println(canIDring(18))
}

part (switch)


package main

import (
	"fmt"
)

func canIDring(age int) bool{
	switch koreanAge:=age+ 2; {
	case koreanAge < 18:
		return false
	case koreanAge == 18:
		return true

	}
}

func main(){

	fmt.Println(canIDring(18))
}

only go

pointer

package main

import (
	"fmt"
)

func main(){
	a :=2
	b := &a
	*b = 10

	fmt.Println(a, *b)

}

array & slice

 package main

import (
	"fmt"
)

func main(){
	array :=[5]string{"jong", "duck", "byun", "chan"}
	array[4] ="Anon";
	fmt.Println(array)
	
	//배열의 크기 제한없이 요소를 추가 하는 방법
	// data type Slice를 사용
	unlimitedArray :=[]string{"a", "b", "c"}

	// append 는 새오누 slice 를 반환함
	unlimitedArray = append(unlimitedArray, "ASD") 
	fmt.Println(unlimitedArray)
}

package main

import (
	"fmt"
)

func main(){
	// map[key's type] value's type {defineKey, defineValue}
	jongseo :=map[string] string{"name": "jongseo", "age": "25"}
	
	for key, value := range jongseo {
		fmt.Println(key, value)
	}
}

struct

package main

import (
	"fmt"
)

type Person struct {
	name string
	age int
	favFood []string

}

// go 는 class, object, constructor method 가 없다
func main(){
	favFood :=[] string{"kimchi", "raman"}
	jongseo := Person{name:"jongseo", age:25,favFood:favFood}

	fmt.Println(jongseo)

	
}

accounts/accounts.go

package accounts

import "errors"

// 모듈은 첫글자가 대문자면 public
//  소문자면 private

// Account struct
type Account struct {
	owner string
	balance int
}

// constructor가 없기에 별도의 함수를 만들어야 한다

// NewAccount creates Accunt
func NewAccount (owner string) *Account {
	account := Account{owner:owner,balance: 0}
	
	return &account
}

// creating method

 //func (struct's method's name  struct's name) <-  method Deposit는 receiver theAccount를 갖고 있다 라고 말함 (theAccount의 Type 은 account 다)
 // constructor 와 같은 것
 // reveiver 의 컨벤션은  theAccount가 아니라  struct 의 맨 앞 문자다. 즉 theAccount -> a 로 바꿔줘야함
// func (theAccount Account) Deposit(amount int){

// }


// Deposit x amount on your account
func (a *Account) Deposit(amount int){
	a.balance += amount
	
}

// Balance of your account
func (a Account) Balance() int {
	return a.balance
}

var errNoMoney = errors.New("Can't withdraw.")

// Withdraw x amount from your account
func (a *Account) Withdraw (amount int)  error{
	// error type 에는 error 와 nil(null) 이 있따. 
	if a.balance < amount{
		return errNoMoney
	}
 	 a.balance-= amount

	  return nil
}

main.go

package main

import (
	"fmt"
	"log"

	)
func main(){
	account := accounts.NewAccount("jongseo")

	account.Deposit(10)
	fmt.Println(account.Balance())
	err := account.Withdraw(20)

	if err != nil{
		log.Println(err)
	}
		


	fmt.Println(account.Balance())
}

dont use concurrency on url Check

package main

import (
	"errors"
	"fmt"
	"net/http"
)


func main(){
	// 초기화 되지 않은 map은  nil 이다
	// make() Map 을 만들어주는 함수
	var results = make(map[string]string)
	urls := []string{
		"https://www.airbnb.com/",
		"https://www.google.com/",
		"https://www.amazon.com/",
		"https://www.reddit.com/",
		"https://www.google.com/",
		"https://soundcloud.com/",
		"https://www.facebook.com/",
		"https://www.instagram.com/",
		"https://academy.nomadcoders.co/",
		"http://localhost:3000",
	}
	for _, url := range(urls){
		result := "Ok"
		err := hitUrl(url)
		if err != nil{
			result = "FAILED"
		}
	
		results[url] = result
	}
	
	for url, result := range(results){

		fmt.Println(url, result)
	}
	 
}  	

var errRequestFailed = errors.New("Request Fail")

func hitUrl(url string) error {
	fmt.Println("Checking: ", url)
	resp, err := http.Get(url)
	if err != nil || resp.StatusCode >= 400 {
		return errRequestFailed
	}

	return nil
	
}

use goRoutine & Channel

package main

import (
	"fmt"
	"time"
)

// Go routines 란 다른 함수와 동시에 실행시키는 함수
// Goroutine 의 제약 main 함수가 동작 중일 때만 가능

// Channel 이란 goRoutine 과 메인함수(다른 함수) 사이에서 정보를 전달하기 위한 방법
func main(){

	// How to make channel?
	// variable's name = make(chan return's Type)
	c := make(chan string)
	people := []string{"jong", "Anon","jong1", "Anon1","jong2", "Anon2","jong3", "Anon4",}

	for _,person := range people{
		// Go routine에 채널 보내기
		go isSexy(person, c)
	}
	for i:=0 ; i<len(people) ;i++{
		// isSexy에서   채널로 리턴값을 보낸 것을 main에서 채널을 통해 받는 방법
		result := <-c
		fmt.Println(result)// 여기가 js의 await 랑 비슷, ( <- === await)
		// <- : blocking operation , 채널로부터 값을 가져온다
	}
}

func isSexy(person string, c chan string) {
	time.Sleep(time.Second *2)
	//  goroutine 이 channel을 이용해서 메세지를 보내는 방법,
	 c <- person + "is sexy"  // 5초 뒤에 메인의 채널로 리턴값이 보내짐
}

go module 다운로드

go env -w GO111MODULE=on

원종서

다음 포스트

go lang -1

go언어

only go

use goRoutine & Channel

go module 다운로드

[Go언어]

0개의 댓글