Mastering Go: آزادسازی پتانسیل روش ها، رابط ها، ژنریک ها و همزمانی | قسمت – 3

package main

import (
    "fmt"
    "math"
)

type Vertex struct {
    X, Y float64
}

// Remember: a method is just a function with a receiver argument.
// Here's Abs written as a regular function with no change in functionality.

func Abs_func(v Vertex) float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func (v Vertex) Abs() float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func main() {
    v := Vertex{3, 4}
    fmt.Println(v.Abs())

    f := Vertex{12, 5}
    fmt.Println(Abs_func(f))
}

5
13

package main

import (
    "fmt"
    "math"
)

type MyFloat float64

func (f MyFloat) Abs() float64 {
    if f < 0 {
        return float64(-f)
    }
    return float64(f)
}

func main() {
    f := MyFloat(-math.Sqrt(2))
    fmt.Println(f)
    fmt.Println(f.Abs())
}

-1.4142135623730951
1.4142135623730951

package main 

import (
    "fmt"
    "math"
)

type Vertex struct {
    X, Y float64
}

func (v Vertex) Abs() float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

// Method With Pointer Receiver
func (v *Vertex) Scale(f float64) {
    v.X = v.X * f
    v.Y = v.Y * f
    fmt.Println(v.X,v.Y)
}

// Scale Function
func (v Vertex) Scale_(f float64) {
    v.X = v.X * f
    v.Y = v.Y * f
    fmt.Println(v.X,v.Y)
}

func main() {
    v := Vertex{3, 4}
    v.Scale(10)
    fmt.Println(v.X, v.Y)
    fmt.Println(v.Abs(),"\n")

    f := Vertex{3, 4}
    f.Scale_(10)
    fmt.Println(f.X, f.Y)
    fmt.Println(f.Abs())
}

30 40
30 40
50 

30 40
3 4
5

var v Vertex
ScaleFunc(v, 5)  // Compile error!
ScaleFunc(&v, 5) // OK

var v Vertex
v.Scale(5)  // OK
p := &v
p.Scale(10) // OK

package main

import "fmt"

type Vertex struct {
    X, Y float64
}

func (v *Vertex) Scale(f float64) {
    v.X = v.X * f
    v.Y = v.Y * f
}

func ScaleFunc(v *Vertex, f float64) {
    v.X = v.X * f
    v.Y = v.Y * f
}

func main() {
    v := Vertex{3, 4}
    v.Scale(2)
    fmt.Println(v)
    ScaleFunc(&v, 10)
    fmt.Println(v,"\n")

    p := &Vertex{3, 4}
    p.Scale(2)
    fmt.Println(p)
    ScaleFunc(p,10)
    fmt.Println(p)
}

{6 8}
{60 80} 

&{6 8}
&{60 80}

var v Vertex
fmt.Println(AbsFunc(v))  // OK
fmt.Println(AbsFunc(&v)) // Compile error!

var v Vertex
fmt.Println(v.Abs()) // OK
p := &v
fmt.Println(p.Abs()) // OK

package main

import (
    "fmt"
    "math"
)

type Vertex struct {
    X, Y float64
}

func (v Vertex) Abs() float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func AbsFunc(v Vertex) float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func main() {
    v := Vertex{3, 4}
    fmt.Println(v.Abs())
    fmt.Println(AbsFunc(v),"\n")

    p := &Vertex{3, 4}
    fmt.Println(p.Abs())
    fmt.Println(AbsFunc(*p))
}

5
5 

5
5

package main

import (
    "fmt"
    "math"
)

type Vertex struct {
    X, Y float64
}

func (v *Vertex) Scale(f float64) {
    v.X = v.X * f
    v.Y = v.Y * f
}

func (v *Vertex) Abs() float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func main() {
    v := &Vertex{3, 4}
    fmt.Printf("Before scaling: %+v, Abs: %v\n", v, v.Abs())
    v.Scale(5)
    fmt.Printf("After scaling: %+v, Abs: %v\n", v, v.Abs())
}

Before scaling: &{X:3 Y:4}, Abs: 5
After scaling: &{X:15 Y:20}, Abs: 25

package main

import (
    "fmt"
    "math"
)

// Shape is an interface for geometric shapes
type Shape interface {
    Area() float64
    Perimeter() float64
}

// Rectangle represents a rectangle shape
type Rectangle struct {
    Width  float64
    Height float64
}

// Area calculates the area of the rectangle
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// Perimeter calculates the perimeter of the rectangle
func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

// Circle represents a circle shape
type Circle struct {
    Radius float64
}

// Area calculates the area of the circle
func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}

// Perimeter calculates the circumference of the circle
func (c Circle) Perimeter() float64 {
    return 2 * math.Pi * c.Radius
}

func main() {
    rect := Rectangle{Width: 5, Height: 3}
    circle := Circle{Radius: 2.5}

    shapes := []Shape{rect, circle}

    for _, shape := range shapes {
        fmt.Printf("Area: %f\n", shape.Area())
        fmt.Printf("Perimeter: %f\n", shape.Perimeter())
        fmt.Println("------------------")
    }
}

Area: 15.000000
Perimeter: 16.000000
------------------
Area: 19.634954
Perimeter: 15.707963
------------------

package main

import "fmt"

type Person struct {
    Name string
    other string
}

func (p Person) String() string {
    return fmt.Sprintf("%v %v", p.Name, p.other)
}

func main() {
    a := Person{"Jay!", "Shiya Ram"}
    z := Person{"Jay Shree!", "Radhe Krishna"}
    fmt.Println(a, z)
}

Jay! Shiya Ram Jay Shree! Radhe Krishna

func Index[T comparable](s []T, x T) int

package main

import "fmt"

// Index returns the index of x in s, or -1 if not found.
func Index[T comparable](s []T, x T) int {
    for i, v := range s {
        // v and x are type T, which has the comparable
        // constraint, so we can use == here.
        if v == x {
            return i
        }
    }
    return -1
}

func main() {
    // Index works on a slice of ints
    si := []int{10, 20, 15, -10}
    fmt.Println(Index(si, 15))

    // Index also works on a slice of strings
    ss := []string{"foo", "bar", "baz"}
    fmt.Println(Index(ss, "hello"))
}

2
-1

go f(x, y, z)

f(x, y, z)

package main

import (
    "fmt"
    "time"
)

func say(s string) {
    for i := 0; i < 5; i++ {
        time.Sleep(100 * time.Millisecond)
        fmt.Println(s)
    }
}

func main() {
    go say("world")
    say("hello")
}

hello
world
world
hello
world
hello
hello
world
world
hello

ch := make(chan int) // Creates an unbuffered channel of type int

ch <- 177 // Sends the value 177 into the channel 

value := <-ch // Receives a value from the channel and assigns it to the variable "value"

package main

import "fmt"

func sum(s []int, c chan int) {
    sum := 0
    for _, v := range s {
        sum += v
    }
    c <- sum // send sum to c
}

func main() {
    s := []int{7, 2, 8, -9, 4, 0}

    c := make(chan int)
    go sum(s[:len(s)/2], c)
    go sum(s[len(s)/2:], c)
    x, y := <-c, <-c // receive from c

    fmt.Println(x, y, x+y)
}

-5 17 12

ch := make(chan int, 100)

package main

import (
    "fmt"
)

func main() {
    // Create a buffered channel with a capacity of 3
    ch := make(chan int, 3)

    // Send values to the channel
    ch <- 1
    ch <- 2
    ch <- 3

    // Attempting to send another value to the channel would block since the buffer is full

    // Receive values from the channel
    fmt.Println(<-ch)
    fmt.Println(<-ch)
    fmt.Println(<-ch)

    // Attempting to receive another value from the channel would block since the buffer is empty
}

1
2
3