[ā§§.ā§Ē] āĻĄāĻžāĻāĻž āĻāĻžāĻāĻĒ (Data Type)
āĻĄāĻžāĻāĻž āĻāĻžāĻāĻĒ āĻĒā§āϰā§āĻā§āϰāĻžāĻŽāĻŋāĻ āĻāϰ āĻāĻāĻāĻŋ āĻā§āϰā§āϤā§āĻŦāĻĒā§āϰā§āĻŖ āĻŦāĻŋāώā§āĨ¤ āĻĄāĻžāĻāĻž āĻāĻžāĻāĻĒ āĻā§āϝāĻžāϰāĻŋā§ā§āĻŦāϞ āĻŽāĻžāύāĻā§āϞā§āϰ āĻāĻāĻžāϰ āĻāĻŦāĻ āĻĒā§āϰāĻāĻžāϰ āύāĻŋāϰā§āĻĻāĻŋāώā§āĻ āĻāϰā§āĨ¤
Go-āϤ⧠āĻĄāĻžāĻāĻž āĻāĻžāĻāĻĒāĻā§āϞā§āĻā§ āĻĻā§āĻāĻŋ āĻļā§āϰā§āĻŖā§āϤ⧠āĻŦāĻŋāĻāĻā§āϤ āĻāϰāĻž āϝā§āϤ⧠āĻĒāĻžāϰā§āĻ
- āĻŦā§āϏāĻŋāĻ āĻāĻžāĻāĻĒ (Basic type)
- āĻāĻŽā§āĻĒā§āĻāĻŋāĻ āĻāĻžāĻāĻĒ(Composite type)
[ā§§.ā§Ē.ā§§] āĻŦā§āϏāĻŋāĻ āĻāĻžāĻāĻĒ (Basic type)
āĻāĻ āĻĒāĻžāĻāĻāĻāĻŋ āĻĄāĻžāĻāĻž āĻāĻžāĻāĻĒāĻā§ āĻŦā§āϏāĻŋāĻ āĻāĻžāĻāĻĒ āĻšāĻŋāϏā§āĻŦā§ āĻŦāĻŋāĻŦā§āĻāύāĻž āĻāϰāĻž āĻšā§ :
- āϏāĻāĻā§āϝāĻžāϏā§āĻāĻ (Numeric type)
- āϏā§āĻā§āϰāĻŋāĻ(String )
- āĻŦāĻžāĻāĻ (Byte)
- Rune
- Boolean
āĻĢāϰāĻŽā§āϝāĻžāĻ āϏā§āĻĒā§āϏāĻŋāĻĢāĻžā§āĻžāϰ
āĻŦā§āϏāĻŋāĻ āĻāĻžāĻāĻĒāĻā§āϞ⧠āύāĻŋā§ā§ āĻāϰ⧠āĻŦāĻŋāϏā§āϤāĻžāϰāĻŋāϤ āĻŦāϞāĻžāϰ āĻāĻā§Â āĻāϞā§āύ āĻāĻŽāϰāĻžÂ fmt.printf() āĻĢāĻžāĻāĻļāύā§āϰ āϏāĻžāĻšāĻžāϝā§āϝ⧠āĻāĻŋāĻāĻžāĻŦā§ String āĻĢāϰāĻŽā§āϝāĻžāĻ āĻāϰ⧠āĻĒā§āϰāĻŋāύā§āĻ āĻāϰāĻž āϝāĻžā§ āϏ⧠āϏāĻŽā§āĻĒāϰā§āĻā§ āĻā§āύ⧠āύā§āĻāĨ¤
Go āϤā§Â fmt.printf() āĻĢāĻžāĻāĻļāύ āĻāϰ āϏāĻžāĻšāĻžāϝā§āϝ⧠āĻāĻŽāϰāĻž āĻĄāĻžāĻāĻžāĻā§ āĻĢāϰāĻŽā§āϝāĻžāĻ āĻāϰ⧠āĻĒā§āϰāĻŋāύā§āĻ āĻāϰāϤ⧠āĻĒāĻžāϰāĻŋāĨ¤ āĻĢāĻžāĻāĻļāύāĻāĻŋ āĻāĻāĻāĻŋ āĻā§āĻŽāĻĒā§āϞā§āĻ String āύā§āϝāĻŧ āϝāĻž āĻāĻŽāϰāĻž āĻĢāϰāĻŽā§āϝāĻžāĻ āĻāϰāϤ⧠āĻāĻžāĻ, āĻāĻŦāĻ āĻāĻŋāĻā§ verb āĻĨāĻžāĻā§ āϝāĻž fmt āĻĢāĻžāĻāĻļāύāĻā§ āĻŦāϞ⧠āϝ⧠āĻā§āĻāĻžāĻŦā§ āĻļā§āώā§āϰ āĻāϰā§āĻā§āĻŽā§āύā§āĻāĻā§āϞā§āĻā§ āĻĢāϰāĻŽā§āϝāĻžāĻ āĻāϰāϤ⧠āĻšāĻŦā§ā§ˇ
fmt.printf(âsample template string %sâ,object arg(s))
- āĻā§āĻŽāĻĒā§āϞā§āĻ string – āĻĢāϰāĻŽā§āϝāĻžāĻ āĻāϰāĻžāϰ āĻāύā§āϝ āĻĢāĻžāĻāĻļāύ⧠āϝ⧠String āĻāĻŋ āĻĒāĻžāϏ āĻāϰāĻž āĻšāĻā§āĻā§ āϏā§āĻāĻžāĻ āĻā§āĻŽāĻĒā§āϞā§āĻ stringāĨ¤ % āϏāĻžāĻāύā§āϰ āĻĒāϰ⧠āĻāύāĻāĻžāϰāĻļāύ āĻā§āϝāĻžāϰā§āĻā§āĻāĻžāϰ āĻā§āϞ⧠āĻĻāĻŋā§ā§ āĻāĻŽāϰāĻž āĻĒā§āϰā§ā§āĻāύāĻŽāϤ String āĻāĻŋāĻā§ āĻĢāϰāĻŽā§āϝāĻžāĻ āĻāϰāϤ⧠āĻĒāĻžāϰāĻŋāĨ¤
- āĻ āĻŦāĻā§āĻā§āĻ āĻāϰā§āĻā§āĻŽā§āύā§āĻ – āĻā§āĻŽāĻĒā§āϞā§āĻ string āĻā§ āϝā§āϏāĻŦ āĻā§āϝāĻžāϞ⧠āĻĻāĻŋā§ā§ āĻĢāϰāĻŽā§āϝāĻžāĻ āĻāϰāĻž āĻšā§ āϏā§āĻā§āϞā§āĻ āĻ āĻŦāĻā§āĻā§āĻ āĻāϰāĻā§āĻŽā§āύā§āĻāĨ¤
package main
import "fmt"
func main() {
str := "Hello, world!"
num1 := 42
num2 := 3.14159
num3 := 1234567890
boolean := true
char := 'A'
// %T: print type of the value
fmt.Printf("%T\n", str)
// %v: print default format for each type
fmt.Printf("%v\n", str)
// String format specifiers
fmt.Printf("%s\n", str) // %s: print string
fmt.Printf("%q\n", str) // %q: print quoted string
fmt.Printf("%x\n", []byte(str)) // %x: print hex encoding of bytes
fmt.Printf("%X\n", []byte(str)) // %X: print uppercase hex encoding of bytes
// Integer format specifiers
fmt.Printf("%d\n", num1) // %d: print decimal integer
fmt.Printf("%b\n", num1) // %b: print binary integer
fmt.Printf("%o\n", num1) // %o: print octal integer
fmt.Printf("%x\n", num1) // %x: print hex encoding of integer
fmt.Printf("%X\n", num1) // %X: print uppercase hex encoding of integer
fmt.Printf("%c\n", char) // %c: print character
// Floating-point format specifiers
fmt.Printf("%f\n", num2) // %f: print floating-point number
fmt.Printf("%e\n", num2) // %e: print scientific notation of floating-point number
fmt.Printf("%E\n", num2) // %E: print scientific notation of floating-point number with uppercase E
fmt.Printf("%g\n", num2) // %g: print floating-point number in decimal or scientific notation, depending on the value
fmt.Printf("%G\n", num2) // %G: print floating-point number in decimal or scientific notation, depending on the value with uppercase E
// Width and precision
fmt.Printf("|%5d|\n", num1) // %5d: print decimal integer with minimum width of 5 characters
fmt.Printf("|%-5d|\n", num1) // %-5d: print decimal integer with minimum width of 5 characters, left-justified
fmt.Printf("|%5.2f|\n", num2) // %5.2f: print floating-point number with minimum width of 5 characters and 2 digits after the decimal point
fmt.Printf("|%-5.2f|\n", num2) // %-5.2f: print floating-point number with minimum width of 5 characters and 2 digits after the decimal point, left-justified
// Boolean format specifiers
fmt.Printf("%t\n", boolean) // %t: print boolean value
// Pointer format specifier
fmt.Printf("%p\n", &num3) // %p: print pointer address
}
āĻāĻāĻāĻĒā§āĻāĻ
string
Hello, world!
Hello, world!
"Hello, world!"
48656c6c6f2c20776f726c6421
48656C6C6F2C20776F726C6421
42
101010
52
2a
2A
A
3.141590
3.141590e+00
3.141590E+00
3.14159
3.14159
| 42|
42 |
| 3.14|
3.14 |
true
0x488b30
[ā§§.ā§Ē.ā§§.ā§§] āϏāĻāĻā§āϝāĻžāϏā§āĻāĻ āĻāĻžāĻāĻĒ(Numeric type)
āύāĻŋāĻāĻŽā§āϰāĻŋāĻ āĻĄāĻžāĻāĻž āĻāĻžāĻāĻĒ āĻŽā§āϞāϤ āϏāĻāĻā§āϝāĻžāĻā§āϞā§āϰ āĻĒā§āϰāϤāĻŋāύāĻŋāϧāĻŋāϤā§āĻŦ āĻāϰā§, āϝāĻž āĻšāϤ⧠āĻĒāĻžāϰ⧠āĻĒā§āϰā§āĻŖ āϏāĻāĻā§āϝāĻž , āĻāĻā§āύāĻžāĻāĻļ āϏāĻāĻā§āϝāĻž āĻ āĻĨāĻŦāĻž āĻāĻāĻŋāϞ āϏāĻāĻā§āϝāĻžāĨ¤ āϏāĻāĻā§āϝāĻžāϏā§āĻāĻ āĻĄāĻžāĻāĻžāϰ āĻĒā§āϰāĻāĻžāϰāĻā§āϞ⧠āĻĒā§āϰā§āĻā§āϰāĻžāĻŽāĻŋāĻ āĻāĻžāώāĻž, āĻĄāĻžāĻāĻžāĻŦā§āϏ⧠āĻĒāϰāĻŋāĻŽāĻžāĻŖ āĻ āĻĒāϰāĻŋāĻŽāĻžāĻĒ āĻāĻŦāĻ āĻ āύā§āϝāĻžāύā§āϝ āϏāĻžāĻāĻā§āϝāĻŋāĻ āĻŽāĻžāύāĻā§āϞ⧠āĻāĻĒāϏā§āĻĨāĻžāĻĒāύ āĻāϰāϤ⧠āĻŦā§āϝāĻŦāĻšā§āϤ āĻšāϝāĻŧāĨ¤
āϤāĻŋāύāĻāĻŋ āϏāĻāĻā§āϝāĻžāϏā§āĻāĻ āĻĄāĻžāĻāĻž āĻāĻžāĻāĻĒ āĻšāϞ –Â
- Integers
- Floats
- Complex Numbers
[ā§§.ā§Ē.ā§§.ā§§.ā§§] Integers
Go āϤ⧠āĻ āύā§āϝāϤāĻŽ āύāĻŋāĻāĻŽā§āϰāĻŋāĻ āĻĄāĻžāĻāĻž āĻāĻžāĻāĻĒ āĻšāϞ⧠āĻāύā§āĻāĻŋāĻāĻžāϰ āĨ¤ āĻāύā§āĻāĻŋāĻāĻžāϰ āĻāϰ āĻĒā§āϞā§āϝāĻžāĻāĻĢāϰā§āĻŽ āύāĻŋāϰā§āĻāϰ āϏāĻžāĻāĻ āϰā§ā§āĻā§ āĨ¤ āĻāĻāĻāĻŋ āĻāύā§āĻāĻŋāĻāĻžāϰ āĻĄāĻžāĻāĻž āĻāĻžāĻāĻĒā§āϰ āĻā§āϝāĻžāϰāĻŋā§ā§āĻŦāϞ⧠āĻļā§āϧā§āĻŽāĻžāϤā§āϰ āĻĒā§āϰā§āĻŖ āϏāĻāĻā§āϝāĻž āϰāĻžāĻāĻž āϝāĻžāϝāĻŧ āĨ¤Â āĻāύā§āĻāĻŋāĻāĻžāϰ āĻāĻŦāĻžāϰ āĻĻā§āĻ āϧāϰāύā§āϰ āĻšāϤ⧠āĻĒāĻžāϰā§:Â
- Signed Integers (āϧāύāĻžāϤā§āĻŽāĻ āĻ āĻāĻŖāĻžāϤā§āĻŦāĻ)
- int
- int8
- int16Â
- int32Â
- int64
- Unsigned Integers (āĻļā§āϧ⧠āϧāύāĻžāϤā§āĻŽāĻ)
- uint
- uint8
- uint16
- uint32
- uint64
- uintptr
package main
import (
"fmt"
)
func main() {
// Signed integers
var a int8 = 127
var b int16 = 32767
var c int32 = 2147483647
var d int64 = 9223372036854775807
// Unsigned integers
var e uint8 = 255
var f uint16 = 65535
var g uint32 = 4294967295
var h uint64 = 18446744073709551615
// Print the values
fmt.Println("Signed Integers:")
fmt.Printf("int8: %d\n", a)
fmt.Printf("int16: %d\n", b)
fmt.Printf("int32: %d\n", c)
fmt.Printf("int64: %d\n", d)
fmt.Println("Unsigned Integers:")
fmt.Printf("uint8: %d\n", e)
fmt.Printf("uint16: %d\n", f)
fmt.Printf("uint32: %d\n", g)
fmt.Printf("uint64: %d\n", h)
}
[ā§§.ā§Ē.ā§§.ā§§.⧍] Floats
āĻāĻāĻāĻŋ āĻĢā§āϞā§āĻ āĻĄāĻžāĻāĻž āĻāĻžāĻāĻĒā§āϰ āĻā§āϝāĻžāϰāĻŋā§ā§āĻŦāϞ⧠āĻļā§āϧā§āĻŽāĻžāϤā§āϰ āĻĄā§āϏāĻŋāĻŽāĻžāϞ āĻĄāĻžāĻāĻž āϰāĻžāĻāĻž āϝāĻžāϝāĻŧāĨ¤ āĻĢā§āϞā§āĻ āĻ āĻĻā§āĻ āϧāϰāύā§āϰ āĻĄāĻžāĻāĻž āĻāĻžāĻāĻĒ āϰā§ā§āĻā§ :
- float32
- float64
package main
import "fmt"
func main() {
// float32 example
var myFloat32 float32 = 3.14
fmt.Printf("myFloat32 = %f, type = %T\n", myFloat32, myFloat32)
// float64 example
var myFloat64 float64 = 3.141592653589793238462643383279502
fmt.Printf("myFloat64 = %f, type = %T\n", myFloat64, myFloat64)
}
āĻāĻāĻāĻĒā§āĻ –
myFloat32 = 3.140000, type = float32
myFloat64 = 3.141593, type = float64
[ā§§.ā§Ē.ā§§.ā§§.ā§Š] Complex Numbers
Go āϤ⧠āĻĻā§āĻ āĻĒā§āϰāĻāĻžāϰā§āϰ āĻāĻŽāĻĒā§āϞā§āĻā§āϏ āύāĻžāĻŽā§āĻŦāĻžāϰ āϰāϝāĻŧā§āĻā§ āĨ¤
- Complex64
- Complex128
Â
āĻāĻāĻāĻŋ Complex Numbers āĻāϰ āĻĻā§āĻāĻāĻŋ āĻ āĻāĻļ āĻĨāĻžāĻā§ āĨ¤Â
- Real
- Imaginary
Â
āĻāĻĻāĻžāĻšāϰāĻŖ – Â
package main
import "fmt"
func main() {
c1 := complex(2, 3)
c2 := 4 + 5i // complex initializer syntax a + ib
c3 := c1 + c2 // addition just like other variables
fmt.Println("Add: ", c3) // prints "Add: (6+8i)"
re := real(c3) // get real part
im := imag(c3) // get imaginary part
fmt.Println(re, im) // prints 6 8
}
[ā§§.ā§Ē.ā§§.⧍] Byte
āĻā§-āϤ⧠āĻŦāĻžāĻāĻ āĻšāϞ⧠āĻāĻāĻāĻŋ unsigned 8-bit āĻāύā§āĻāĻŋāĻāĻžāϰāĨ¤ āĻāϰ āĻŽāĻžāύā§āϰ āϏā§āĻŽāĻž 0-255āĨ¤ āϏāĻžāϧāĻžāϰāύāϤ ASCII āĻ āĻā§āώāϰ āϏāĻāϰāĻā§āώāĻŖ āĻāϰāϤ⧠āĻŦāĻžāĻāĻ āĻāĻžāĻāĻĒ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻāϰāĻž āĻšā§ā§ āĻĨāĻžāĻā§āĨ¤ āĻāĻĻāĻžāĻšāϰāĻŖāϏā§āĻŦāϰā§āĻĒ, āύāĻŋāĻā§āϰ āĻāĻŋāϤā§āϰāĻāĻŋ āĻāĻāĻāĻŋ āĻŦāĻžāĻāĻ āĻā§āϝāĻžāϰāĻŋā§ā§āĻŦāϞā§āϰ Z āĻ āĻā§āώāϰāĻāĻŋāĻā§ āĻāĻĒāϏā§āĻĨāĻžāĻĒāύ āĻāϰāĻž āĻšā§ā§āĻā§ –

āĻāĻāĻāĻŋ āĻŦāĻžāĻāĻ āĻā§āϝāĻžāϰāĻŋā§ā§āĻŦāϞ āĻĄāĻŋāĻā§āϞā§ā§āĻžāϰ āĻāϰāĻžāϰ āĻāύā§āϝ, āϤāĻŋāύāĻāĻŋ āĻāĻŋāύā§āύ āĻāĻŋāύā§āύ āĻāĻĒāĻžāϝāĻŧ āĻāĻā§:
- 0 āĻāĻŦāĻ 255 āĻāϰ āĻŽāϧā§āϝ⧠āĻāĻāĻāĻŋ āĻĻāĻļāĻŽāĻŋāĻ āĻĒā§āϰā§āĻŖāϏāĻāĻā§āϝāĻž āĻ ā§āϝāĻžāϏāĻžāĻāύ āĻāϰā§
- āĻāĻāĻāĻŋ ASCII āĻ āĻā§āώāϰ āĻ ā§āϝāĻžāϏāĻžāĻāύ āĻāϰā§
- āĻŦāĻŋāĻāĻŋāύā§āύ āĻŦā§āϏā§āϰ āĻĒā§āϰā§āĻŖāϏāĻāĻā§āϝāĻž āĻ ā§āϝāĻžāϏāĻžāĻāύ āĻāϰ⧠(āĻŦāĻžāĻāύāĻžāϰā§, āĻ āĻā§āĻāĻžāϞ, āĻšā§āĻā§āϏ)
package main
import (
"fmt"
)
func main() {
// assign by decimal integer (base 10)
var ch byte = 90
fmt.Printf("%08b %02x %v\n", ch, ch, ch)
// assign an ASCII character
var ch0 byte = 'Z'
fmt.Printf("%08b %02x %v\n", ch0, ch0, ch0)
// assign by different bases:
var ch1 byte = 0b01011010 // Binary
var ch2 byte = 0o132 // Octal
var ch3 byte = 0x5a // heX
fmt.Printf("%08b %02x %v\n", ch2, ch2, ch2)
fmt.Printf("%08b %02x %v\n", ch1, ch1, ch1)
fmt.Printf("%08b %02x %v\n", ch3, ch3, ch3)
}
// Result
// 01011010 5a 90
// 01011010 5a 90
// 01011010 5a 90
// 01011010 5a 90
// 01011010 5a 90
[ā§§.ā§Ē.ā§§.ā§Š] Rune
Go āϤ⧠Rune āĻšāϞ āĻāĻāĻāĻŋ āĻĄāĻžāĻāĻž āĻāĻžāĻāĻĒ āϝāĻž āĻĻā§āĻŦāĻžāϰāĻž āĻāĻāύāĻŋāĻā§āĻĄ character āĻā§āϞā§āĻā§ āĻĒā§āϰāĻāĻžāĻļ āĻāϰāĻž āĻšā§āĨ¤ āĻāĻāύāĻŋāĻā§āĻĄ āĻšāϞ⧠āϏāĻŽāĻā§āϰ āĻŦāĻŋāĻļā§āĻŦā§ āĻāĻĒāϏā§āĻĨāĻŋāϤ āϏāĻŽā§āĻāĻžāĻŦā§āϝ āϏāĻāϞ character āĻāϰ āϏāĻāĻā§āϰāĻšāĨ¤
// Simple Go program to illustrate
// how to create a rune
package main
import (
"fmt"
"reflect"
)
func main() {
// Creating a rune
rune1 := 'B'
rune2 := 'g'
rune3 := '\a'
// Displaying rune and its type
fmt.Printf("Rune 1: %c; Unicode: %U; Type: %s", rune1, rune1, reflect.TypeOf(rune1))
fmt.Printf("\nRune 2: %c; Unicode: %U; Type: %s", rune2, rune2, reflect.TypeOf(rune2))
fmt.Printf("\nRune 3: Unicode: %U; Type: %s", rune3, reflect.TypeOf(rune3))
}
āĻāĻāĻāĻĒā§āĻ –Â
Rune 1: B; Unicode: U+0042; Type: int32
Rune 2: g; Unicode: U+0067; Type: int32
Rune 3: Unicode: U+0007; Type: int32
[ā§§.ā§Ē.ā§§.ā§Ē] String
Go-āϤ⧠string āĻšāĻā§āĻā§ character āĻāϰ āĻ ā§āϝāĻžāϰ⧠āϝāĻžāϰāĻž āĻāĻāϏāĻžāĻĨā§ āĻšāϝāĻŧā§ āĻļāĻŦā§āĻĻ āĻāĻŦāĻ āĻŦāĻžāĻā§āϝ āĻāĻ āύ āĻāϰ⧠āĨ¤ String āϏāĻŦ āϏāĻŽāϝāĻŧ āĻĻā§āĻāĻāĻž āĻĄāĻžāĻŦāϞ āĻā§āĻā§āĻļāύā§āϰ āĻŽāϧā§āϝ⧠āĻĨāĻžāĻā§āĨ¤ āĻāĻĻāĻžāĻšāϰāĻŖ :”Hello, World!”
package main
import (
"fmt"
"strings"
)
func main() {
// string example
var myString string = "Hello, World!"
fmt.Println(myString)
// concatenation
str1 := "Hello, "
str2 := "World!"
result := str1 + str2
fmt.Println(result) // Output: Hello, World!
// slicing
myString = "Hello, World!"
fmt.Println(myString[0:5]) // Output: Hello
// indexing
fmt.Println(myString[7]) // Output: W
// length of a string
fmt.Println(len(myString)) // Output: 13
// converting a string to uppercase
fmt.Println(strings.ToUpper(myString)) // Output: HELLO, WORLD!
// converting a string to lowercase
fmt.Println(strings.ToLower(myString)) // Output: hello, world!
// splitting a string
str := "one,two,three,four,five"
splitStr := strings.Split(str, ",")
fmt.Println(splitStr) // Output: [one two three four five]
}
[ā§§.ā§Ē.ā§§.ā§Ģ] Booleans
Boolean āĻāĻžāĻāĻĒ āĻšāϞ⧠āĻāĻ āϧāϰāύā§āϰ āĻĄāĻžāĻāĻž āĻāĻžāĻāĻĒ āϝ⧠āĻāĻžāĻāĻĒā§āϰ āĻļā§āϧā§āĻŽāĻžāϤā§āϰ āĻĻā§āĻāĻāĻŋ āĻŽāĻžāύ āĻĨāĻžāĻā§ true āĻ āĻĨāĻŦāĻž false āĨ¤ Go āϤ⧠Boolean-type āĻā§āϝāĻžāϰāĻŋā§ā§āĻŦāϞ āϤā§āϰāĻŋ āĻāϰāϤ⧠bool āĻāĻŋāĻā§āĻžāϰā§āĻĄ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻāϰāĻž āĻšā§ āĨ¤
āĻāĻĻāĻžāĻšāϰāĻŖ –
package main
import (
"fmt"
)
func main() {
var bVal bool // default is false
fmt.Printf("bVal: %v\n", bVal)
}
[ā§§.ā§Ē.⧍] āĻāĻŽā§āĻĒā§āĻāĻŋāĻ āĻāĻžāĻāĻĒ (Composite type)
Go- āϤ⧠āĻāĻŽā§āĻĒā§āĻāĻŋāĻ āĻāĻžāĻāĻĒ āϏāĻžāĻĒā§āϰā§āĻ āĻāϰā§āĨ¤ āϏāĻžāϧāĻžāϰāύāϤ āϤāĻŋāύ āϧāϰāύā§āϰ āĻāĻŽā§āĻĒā§āĻāĻŋāĻ āĻāĻžāĻāĻĒ āϰā§ā§āĻā§ –Â
- āϏāĻŽāώā§āĻāĻŋ āĻāĻžāĻāĻĒ āĻŦāĻž āύāύ-āϰā§āĻĢāĻžāϰā§āύā§āϏ āĻāĻžāĻāĻĒ (Aggregate type/Non-Reference type)
- āϰā§āĻĢāĻžāϰā§āύā§āϏ āĻāĻžāĻāĻĒ (Reference type)
- āĻāύā§āĻāĻžāϰāĻĢā§āϏ āĻāĻžāĻāĻĒ (Interface type)
[ā§§.ā§Ē.⧍.ā§§] āϏāĻŽāώā§āĻāĻŋ āĻāĻžāĻāĻĒ āĻŦāĻž āύāύ-āϰā§āĻĢāĻžāϰā§āύā§āϏ āĻāĻžāĻāĻĒ (Aggregate type/Non-Reference type)
āϏāĻŽāώā§āĻāĻŋ āĻāĻžāĻāĻĒ āĻŦāĻž āύāύ-āϰā§āĻĢāĻžāϰā§āύā§āϏ āĻāĻžāĻāĻĒāĻā§ āĻāĻŦāĻžāϰ āĻĻā§āĻ āϧāϰāύā§āϰ :Â
- āĻ ā§āϝāĻžāϰā§( Array) Â
- āϏā§āĻā§āϰāĻžāĻāĻāĻžāϰ(Structure)
[ā§§.ā§Ē.⧍.ā§§.ā§§] āĻ ā§āϝāĻžāϰ⧠(Array)
Go āϤ⧠āĻ ā§āϝāĻžāϰ⧠āĻšāϞ⧠āĻāĻāĻ āĻāĻžāĻāĻĒā§āϰ āĻāĻāĻžāϧāĻŋāĻ āĻā§āϝāĻžāϰāĻŋā§ā§āĻŦāϞ āĻāϰ āϏāĻāĻā§āϰāĻš āϝāĻžāϰ āĻĻā§āϰā§āĻā§āϝ āĻāĻāĻŋ āĻĄāĻŋāĻā§āϞā§ā§āĻžāϰ āĻāϰāĻžāϰ āϏāĻŽā§āĻ āύāĻŋāϰā§āĻĻāĻŋāώā§āĻ āĻāϰ⧠āĻĻāĻŋāϤ⧠āĻšā§ āĻāĻŦāĻ āĻĒāϰāĻŦāϰā§āϤā§āϤ⧠āĻāϰ āĻŦāĻĻāϞāĻžāύ⧠āϝāĻžā§ āύāĻžāĨ¤Â
āĻāĻāĻāĻŋ āĻ ā§āϝāĻžāϰā§āϰ āĻĒā§āϰāϤā§āϝā§āĻ āĻāĻĒāĻžāĻĻāĻžāύ āύāĻŋāĻāϏā§āĻŦ āĻāĻāĻāĻŋ āĻāύāĻĄā§āĻā§āϏ āĻĻā§āĻŦāĻžāϰāĻž āĻāϞāĻžāĻĻāĻžāĻāĻžāĻŦā§ āĻāĻŋāĻšā§āύāĻŋāϤ āĻāϰāĻž āϝāĻžā§āĨ¤ āĻāĻ āĻāύāĻĄā§āĻā§āϏāĻāĻŋ āĻšāϞ⧠āĻāĻāĻāĻŋ āĻāύā§āĻāĻŋāĻāĻžāϰ āĻā§āϝāĻžāϞā§, āϝāĻž 0 āĻĨā§āĻā§ āĻļā§āϰ⧠āĨ¤ āĻ ā§āϝāĻžāϰ⧠āĻĄāĻŋāĻā§āϞā§ā§āĻžāϰ āĻāϰāĻžāϰ āĻĒāĻĻā§āϧāϤāĻŋ āύāĻŋāĻŽā§āύāϰā§āĻĒ –Â
var array [size]type
āύāĻŋāĻā§āϰ āĻāĻĻāĻžāĻšāϰāĻŖā§ āĻ ā§āϝāĻžāϰā§āϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻāϰā§āĻāĻā§ āĻĒāϰāĻŋāώā§āĻāĻžāϰ āĻšāĻŦā§ –
func main() {
var a [5]int
a[4] = 100
fmt.Println("set:", a)
fmt.Println("get:", a[4])
}
āĻāĻāĻāĻĒā§āĻ-Â
set: [0 0 0 0 100]
get: 100
āĻāĻŽāϰāĻž āĻāĻžāĻāϞ⧠āĻāĻā§āϰ āĻ āϧāĻŋāĻ āĻĄāĻžāĻāĻŽā§āύāĻļāύ āϏāĻŽā§āĻŦāϞāĻŋāϤ āĻ ā§āϝāĻžāϰ⧠āϤā§āϰāĻŋ āĻāϰāϤ⧠āĻĒāĻžāϰāĻŋ –
func main() {
var twoD [2][3]int
for i := 0; i < 2; i++ {
for j := 0; j < 3; j++ {
twoD[i][j] = i + j
}
}
fmt.Println("2d: ", twoD)
}
āĻāĻāĻāĻĒā§āĻ-Â
2d: [[0 1 2] [1 2 3]]
āϞāĻā§āώā§āϝ āĻāϰāϞ⧠āĻĻā§āĻāϤ⧠āĻĒāĻžāĻŦā§, fmt.Println() āĻĻāĻŋāϝāĻŧā§ āĻĒā§āϰāĻŋāύā§āĻ āĻāϰāĻž āĻšāϞ⧠āĻ ā§āϝāĻžāϰā§āĻā§āϞ⧠[ [v1] [v2] [v3] … ] āĻāĻāĻžāϰ⧠āĻĒā§āϰāĻĻāϰā§āĻļāĻŋāϤ āĻšāϝāĻŧāĨ¤ āĻ āϰā§āĻĨāĻžā§ āĻāĻŽāĻžāĻĻā§āϰ āĻĻā§āĻ āĻĄāĻžāĻāĻŽā§āύāĻļāύā§āϰ āĻ ā§āϝāĻžāϰ⧠āĻāϏāϞ⧠āĻāĻāĻāĻŋ āĻ ā§āϝāĻžāϰā§āϰ āĻ ā§āϝāĻžāϰā§āĨ¤Â
āĻāĻāĻžā§āĻžāĻ āĻ ā§āϝāĻžāϰā§āϰ āĻ āύā§āĻ āύāĻŋāĻāϏā§āĻŦ āĻĢāĻžāĻāĻļāύ āϰā§ā§āĻā§, āϝā§āĻŽāύ, len(), cap(), copy(), append() āĻāϤā§āϝāĻžāĻĻāĻŋ, āϝā§āĻā§āϞ⧠āĻĒā§āϰā§ā§āĻāύ āĻ āύā§āϏāĻžāϰ⧠āĻŦāĻŋāĻāĻŋāύā§āύ āϏāĻŽā§ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻāϰāĻŦ āĻāĻŽāϰāĻžāĨ¤Â
[ā§§.ā§Ē.⧍.⧍.⧍] āϏā§āĻā§āϰāĻžāĻāĻāĻžāϰ (struct)
Struct, Go āĻĒā§āϰā§āĻā§āϰāĻžāĻŽāĻŋāĻ āĻ āĻā§āĻŦāĻ āĻā§āϰā§āϤā§āĻŦāĻĒā§āϰā§āĻŖÂ āĻāĻāĻāĻž āĻŦāĻŋāώā§āĨ¤ āĻāĻŽāϰāĻž āĻĄāĻžāĻāĻž āĻāĻžāĻāĻĒ āϏāĻŽā§āĻĒāϰā§āĻā§ āĻāĻžāύāĻŋ, āĻāύā§āĻāĻŋāĻāĻžāϰ, string, āĻĢā§āϞā§āĻ āĻāϤā§āϝāĻžāĻĻāĻŋāĨ¤ Struct āĻšāϞ⧠āĻāĻāĻāĻžāϰā§āϰ āύāĻŋāĻ āĻĒā§āϰā§ā§āĻāύ āĻ āύā§āϏāĻžāϰ⧠āĻŦāĻžāύāĻŋā§ā§ āύā§ā§āĻž āĻāĻāĻāĻž āĻāĻžāϏā§āĻāĻŽ āĻĄāĻžāĻāĻž āĻāĻžāĻāĻĒ āϝā§āĻāĻžāύ⧠āĻāĻŋāύā§āύ āĻāĻŋāύā§āύ āĻĄāĻžāĻāĻž āĻāĻžāĻāĻĒāĻā§ āĻāĻāĻāĻž āĻāύāĻāĻŋāĻāĻŋāϰ āĻā§āϤāϰ⧠āĻāĻāϤā§āϰ āĻāϰāĻž āϝāĻžā§āĨ¤Â
āĻ ā§āϝāĻžāϰ⧠āĻšāĻā§āĻā§ āĻāĻāĻāĻž āĻĄāĻžāĻāĻž āϏā§āĻā§āϰā§āϝāĻžāĻāĻāĻžāϰāĨ¤ āϝā§āĻāĻžāύ⧠āĻāĻŽāϰāĻž āĻļā§āϧā§Â āĻāĻāĻ āĻĄāĻžāĻāĻž āĻāĻžāĻāĻĒ āĻāϰ āĻĄāĻžāĻāĻž āϰāĻžāĻāϤ⧠āĻĒāĻžāϰāĻŋāĨ¤ āĻāĻŋāύā§āϤ⧠Struct āϤā§āϰāĻŋ āĻāϰ⧠āĻāĻŽāϰāĻž āĻāĻ āϏāĻžāĻĨā§ āĻāύā§āĻāĻŋāĻāĻžāϰ, āĻā§āϝāĻžāϰā§āĻā§āĻāĻžāϰ, āĻĢā§āϞā§āĻ āĻāϤā§āϝāĻžāĻĻāĻŋ āĻāĻŋāύā§āύ āĻāĻŋāύā§āύ āĻĄāĻžāĻāĻž āĻāĻ āϏāĻžāĻĨā§ āϰāĻžāĻāϤ⧠āĻĒāĻžāϰāĻŋāĨ¤
āĻāĻāĻāĻŋ Struct āĻāĻ āύ āĻāϰāĻž āĻšā§ āύāĻŋāĻŽā§āύāϞāĻŋāĻāĻŋāϤ āϏāĻŋāύāĻā§āϝāĻžāĻā§āϏā§āϰ āĻŽāĻžāϧā§āϝāĻŽā§ –
type StructName struct {
Field1 datatype
Field2 datatype
//................
}
āĻāĻāĻžāύ⧠person struct āĻāϰ āĻā§āϤāϰ⧠name(string) āĻāĻŦāĻ age(int) āĻĢāĻŋāϞā§āĻĄ āĻāĻā§ –
type person struct {
name string
age int
}
Struct āĻĄāĻŋāĻā§āϞā§ā§āĻžāϰ āĻāϰāĻžāϰ āĻāĻŋāύā§āύ āĻāĻŋāύā§āύ āĻĒāĻĻā§āϧāϤāĻŋ, Struct āϞāĻŋāĻā§āϰāĻžāϞā§āϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ, āύā§āϏā§āĻā§āĻĄ Struct, Struct āĻāϰ āĻĒā§ā§āύā§āĻāĻžāϰ āĻāϤā§āϝāĻžāĻĻāĻŋ āĻŦāĻŋāώā§ā§ āĻŦāĻŋāϏā§āϤāĻžāϰāĻŋāϤ āĻĒāϰāĻŦāϰā§āϤāĻŋāϤ⧠“Structs and Interfaces” āĻā§āϝāĻžāĻĒā§āĻāĻžāϰ⧠āĻāĻžāύāϤ⧠āĻĒāĻžāϰāĻŦāĨ¤
[ā§§.ā§Ē.⧍.⧍] āϰā§āĻĢāĻžāϰā§āύā§āϏ āĻāĻžāĻāĻĒ (Reference type)
[ā§§.ā§Ē.⧍.⧍.ā§§] āĻĒā§ā§āύā§āĻāĻžāϰāϏ (Pointers)
Go āĻĒāϝāĻŧā§āύā§āĻāĻžāϰ āϏāĻžāĻĒā§āϰā§āĻ āĻāϰā§, āϝāĻž āĻĒā§āϰā§āĻā§āϰāĻžāĻŽā§āϰ āĻŽāϧā§āϝ⧠āĻā§āύ āĻāĻžāϰāĻŋā§ā§āĻŦāϞā§āϰ āĻŽāĻžāύ āĻāĻŦāĻ āϤāĻžāϰ āϰā§āĻĢāĻžāϰā§āύā§āϏ āĻĒāĻžāϏ āĻāϰāĻžāϰ āĻ āύā§āĻŽāϤāĻŋ āĻĻā§āϝāĻŧāĨ¤
āĻāĻŽāϰāĻž āĻĻā§āĻāĻžāĻŦ āĻāĻŋāĻāĻžāĻŦā§ āĻĢāĻžāĻāĻļāύ, āĻĒā§ā§āύā§āĻāĻžāϰ āύāĻŋā§ā§ āĻāĻžāĻ āĻāϰ⧠āĨ¤ āĻāĻŽāϰāĻž āĻĻā§āĻāĻāĻŋ āĻĢāĻžāĻāĻļāύ āĻĄāĻŋāĻĢāĻžāĻāύ āĻāϰā§āĻāĻŋ āϝāĻž āĻšāĻ˛Â zeroval() āĻāĻŦāĻ zeroptr()āĨ¤ zeroval() āĻĢāĻžāĻāĻļāύ⧠āĻāĻāĻāĻŋ āĻāύā§āĻāĻŋāĻāĻžāϰ āĻĒā§āϝāĻžāϰāĻžāĻŽāĻŋāĻāĻžāϰ āϰāϝāĻŧā§āĻā§ āĻāĻŦāĻ zeroptr() āĻĢāĻžāĻāĻļāύ⧠āĻāĻāĻāĻŋ āĻāύā§āĻāĻŋāĻāĻžāϰ āĻĒāϝāĻŧā§āύā§āĻāĻžāϰ āĻĒā§āϝāĻžāϰāĻžāĻŽāĻŋāĻāĻžāϰ āϰā§ā§āĻā§āĨ¤ āĻāĻŽāϰāĻž main() āĻĢāĻžāĻāĻļāύ āĻĨā§āĻā§ āϝāĻĻāĻŋ āĻā§āύ⧠āĻŽāĻžāύ āĻĒāĻžāĻ āĻžāĻ āϤāĻžāĻšāϞ⧠zeroval āĻĢāĻžāĻāĻļāύāĻāĻŋ āϏā§āĻ āĻā§āϝāĻžāϞā§āϰ āĻāĻāĻāĻŋ āĻāĻĒāĻŋ āϰāĻŋāϏāĻŋāĻ āĻāϰāĻŦā§ ival āĻā§āϝāĻžāϰāĻŋā§ā§āĻŦāϞā§āϰ āϏāĻžāĻšāĻžāϝā§āϝ⧠āĻāĻŦāĻ zeroptr āĻĢāĻžāĻāĻļāύāĻāĻŋ āϏā§āĻ āĻā§āϝāĻžāϞā§āϰ āĻāĻāĻāĻŋ āϰā§āĻĢāĻžāϰā§āύā§āϏ āϰāĻŋāϏāĻŋāĻ āĻāϰāĻŦā§ iptr āĻĒāϝāĻŧā§āύā§āĻāĻžāϰ āĻā§āϝāĻžāϰāĻŋā§ā§āĻŦāϞā§āϰ āϏāĻžāĻšāĻžāϝā§āϝ⧠–
func zeroval(ival int) {
ival = 0
}
func zeroptr(iptr *int) {
*iptr = 0
}
āĻ āϰā§āĻĨāĻžā§ ival āĻāĻžāϰāĻŋā§āĻžāĻŦāϞā§āϰ āĻŽāĻžāύā§āϰ āĻā§āύ āĻĒāϰāĻŋāĻŦāϰā§āϤāύ āĻāϰāϞ⧠āϏā§āĻāĻžāϰ main() āĻĢāĻžāĻāĻļāύ⧠āĻĨāĻžāĻāĻž āĻāĻĒāĻŋāϰ āĻā§āύ āĻĒāϰāĻŋāĻŦāϰā§āϤāύ āĻšāĻŦā§ āύāĻž āĻāĻžāϰāĻŖ āϏ⧠āĻļā§āϧ⧠āϤāĻžāϰ āĻŽāĻžāύā§āϰ āĻāĻāĻāĻž āĻāĻĒāĻŋ āĻĒāĻžāĻ āĻŋā§ā§ āĻĻāĻŋā§ā§āĻā§āĨ¤Â
āĻ āύā§āϝ āĻĻāĻŋāĻā§Â *iptr āĻāĻžāϰāĻŋā§āĻžāĻŦāϞā§āϰ āĻŽāĻžāύā§āϰ āĻā§āύ āĻĒāϰāĻŋāĻŦāϰā§āϤāύ āĻāϰāϞ⧠main() āĻĢāĻžāĻāĻļāύ⧠āĻĨāĻžāĻāĻž āĻāĻ āĻā§āϝāĻžāϰāĻŋā§ā§āĻŦāϞā§āϰ āĻŽāĻžāύā§āϰāĻ āĻĒāϰāĻŋāĻŦāϰā§āϤāύ āĻšā§ā§ āϝāĻžāĻŦā§ āĻāĻžāϰāĻŖ āĻĒā§ā§āύā§āĻāĻžāϰ āĻā§āϝāĻžāϰāĻŋā§ā§āĻŦāϞāĻāĻŋāϰ āĻ ā§āϝāĻžāĻĄā§āϰā§āϏ āĻĒāĻžāĻ āĻŋā§ā§ āĻĻā§ā§ āĻāĻŦāĻ āĻĒāϰāĻŋāĻŦāϰā§āϤāύāϤāĻžāĻ āĻāĻā§āϤ āĻŽā§āĻŽā§āϰāĻŋ āĻ ā§āϝāĻžāĻĄā§āϰā§āϏ⧠āϏāϰāĻžāϏāϰāĻŋ āĻšā§ –
func main() {
i := 1
fmt.Println("initial:", i)
zeroval(i)
fmt.Println("zeroval:", i)
zeroptr(&i)
fmt.Println("zeroptr:", i)
fmt.Println("pointer:", &i) // i āĻāϰ āĻ
ā§āϝāĻžāĻĄā§āϰā§āϏ āĻĒā§āϰāĻŋāύā§āĻ āĻšāĻŦā§
}
// Output :
// initial: 1
// zeroval: 1
// zeroptr: 0
// pointer: 0x42131100
[ā§§.ā§Ē.⧍.⧍.⧍] āϏā§āϞāĻžāĻāϏ (slices)
āϏā§āϞāĻžāĻāϏ Go-āϤ⧠āĻāĻāĻāĻŋ āĻā§āϰā§āϤā§āĻŦāĻĒā§āϰā§āĻŖ āĻĄāĻžāĻāĻž āĻāĻžāĻāĻĒāĨ¤ āĻāĻŽāϰāĻž āĻāĻžāĻāϞā§āĻ āĻ ā§āϝāĻžāϰā§āϤ⧠āĻāĻāĻ āϧāϰāĻŖā§āĻ°Â āĻĄā§āĻāĻž āĻāĻāĻā§āĻŽ āϏā§āĻā§āϰ āĻāϰāϤ⧠āĻĒāĻžāϰāĻŋ, āϤāĻŦā§ āĻāĻŽāϰāĻž āĻāĻžāĻāϞā§āĻ āĻ ā§āϝāĻžāϰā§āϰ āĻāĻāĻžāϰ āĻĄāĻžāĻāύā§āϝāĻžāĻŽāĻŋāĻā§āϝāĻžāϞāĻŋ āĻŦāĻžāĻĄāĻŧāĻžāϤ⧠āĻĒāĻžāϰāĻŋ āύāĻžāĨ¤ āϏā§āϞāĻžāĻāϏ āĻāĻ āϏā§āĻŽāĻžāĻŦāĻĻā§āϧāϤāĻž āĻĻā§āϰ āĻāϰā§, āϝāĻžāϰ āϏāĻžāĻšāĻžāϝā§āϝ⧠āĻāϰ āĻāĻāĻžāϰ āĻĄāĻžāĻāύā§āϝāĻžāĻŽāĻŋāĻā§āϝāĻžāϞāĻŋ āĻŦāĻžāĻĄāĻŧāĻžāύ⧠āϝāĻžā§āĨ¤ āĻāĻāύā§āϝāĻ āϏā§āϞāĻžāĻāϏāĻā§ āĻŦāϞāĻž āĻšā§ āϝ⧠āĻ ā§āϝāĻžāϰā§āϰ āϤā§āϞāύāĻžāϝāĻŧ āĻāϰāĻ āĻŦā§āĻļāĻŋ āĻļāĻā§āϤāĻŋāĻļāĻžāϞā§, āĻĢā§āϞā§āĻā§āϏāĻŋāĻŦāϞ āĻāĻŦāĻ āĻāύāĻā§āύāĻŋā§ā§āύā§āĻāĨ¤ āϏā§āϞāĻžāĻāϏ āϤāĻžāϰ āĻā§āϝāĻžāϰāĻŋā§ā§āĻŦāϞ āϞā§āύā§āĻĨā§āϰ āϏāĻŋāĻā§ā§ā§āύā§āϏ⧠āĻāĻāĻ āĻāĻžāĻāĻĒā§āϰ āĻĄāĻžāĻāĻž āϏā§āĻā§āϰā§āϰ āĻāϰāϤ⧠āĻĒāĻžāϰ⧠āĻāĻŋāύā§āϤ⧠āĻ āύā§āϝ āĻāĻžāĻāĻĒā§āϰ āĻĄāĻžāĻāĻž āĻ ā§āϝāĻžāϞāĻžāĻ āĻāϰ⧠āύāĻžāĨ¤ āĻāĻāĻāĻŋ āϏā§āϞāĻžāĻāϏā§āϰ āĻĒā§āϰāĻĨāĻŽ āĻāύāĻĄā§āĻā§āϏā§āϰ āĻŽāĻžāύ āϏāϰā§āĻŦāĻĻāĻž āĻļā§āύā§āϝ āĻāĻŦāĻ āĻļā§āώ āĻāύā§āĻĄā§āĻā§āϏā§āϰ āĻŽāĻžāύ āĻšāĻŦā§ (āϏā§āϞāĻžāĻāϏā§āϰ āĻĻā§āϰā§āĻā§āϝ – 1) –
package main
import "fmt"
func main() {
array := [5]int{1, 2, 3, 4, 5}
slice := array[1:4]
fmt.Println("Array: ", array)
fmt.Println("Slice: ", slice)
}
// Output :
// Array: [1 2 3 4 5]
// Slice: [2 3 4]
āĻāĻŽāϰāĻž āĻāĻžāĻāϞ⧠āĻ ā§āϝāĻžāϰā§āϰ āĻŽāϤ āĻāĻāĻžāύā§āĻ āĻā§āϝāĻžāϞ⧠āϏā§āĻ āĻāϰāϤ⧠āĻĒāĻžāϰāĻŋ –Â
āϏā§āϞāĻžāĻāϏ āύāĻŋā§ā§ āĻāĻžāĻ āĻāϰāĻžāϰ āĻā§āώā§āϤā§āϰ⧠āĻļā§āϰā§āϤ⧠āĻāĻĻā§āϰ āϏāĻžāĻāĻ, āĻā§āϝāĻžāĻĒāĻžāϏāĻŋāĻāĻŋ āĻāϤ āĻšāĻŦā§ āϤāĻž āĻāĻŽāϰāĻž āĻāĻžāύāϞā§āĻ, āĻĒāϰ⧠āϤāĻž āĻĒāϰāĻŋāĻŦāϰā§āϤāύ āĻšāϤ⧠āĻĒāĻžāϰ⧠(āĻ āϰā§āĻĨāĻžā§ āĻāĻĻā§āϰ āϏāĻžāĻāĻ, āĻā§āϝāĻžāĻĒāĻžāϏāĻŋāĻāĻŋ āĻĄāĻžāĻāύāĻžāĻŽāĻŋāĻā§āϝāĻžāϞāĻŋ āĻĒāϰāĻŋāϰā§āϤāύ āĻšāϤ⧠āĻĒāĻžāϰā§) āĻāϰāĻāĻŽ āĻ āĻŦāϏā§āĻĨāĻžā§ āĻāĻŽāϰāĻž āĻŦāĻŋāϞā§āĻ āĻāύ make() āĻĢāĻžāĻāĻļāύ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻāϰ⧠āϏā§āϞāĻžāĻāϏ āĻĄāĻŋāĻā§āϞā§ā§āĻžāϰ āĻāϰāϤ⧠āĻĒāĻžāϰāĻŋ, make() āĻĢāĻžāĻāĻļāύ āϏāĻŽā§āĻĒāϰā§āĻā§ āĻāĻŽāϰāĻž āĻŦāĻŋāϏā§āϤāĻžāϰāĻŋāϤ  āĻĄāĻžāĻāĻž āĻ āĻĢāĻžāĻāϞ āύāĻŋā§ā§ āĻāĻžāĻ āĻ āϧā§āϝāĻžā§ā§ āĻāĻžāύāϤ⧠āĻĒāĻžāϰāĻŦā§āĨ¤
package main
import "fmt"
func main() {
s := make([]string, 3)
s[0] = "a"
s[1] = "b"
s[2] = "c"
fmt.Println("set:", s)
fmt.Println("get:", s[2])
}
// Output :
// set: [a b c]
// get: c
len() āĻĢāĻžāĻāĻļāύā§āϰ āϏāĻžāĻšāĻžāϝā§āϝā§Â āĻāĻŽāϰāĻž āϏā§āϞāĻžāĻāϏā§āϰ āĻĻā§āϰā§āĻā§āϝ āĻĒā§āϤ⧠āĻĒāĻžāϰāĻŋ –
fmt.Println("len:", len(s))
Output : 3
āĻāĻŋāĻā§ āĻŽā§āϞāĻŋāĻ āĻāĻžāĻ āĻāĻžāĻĄāĻŧāĻžāĻ, āϏā§āϞāĻžāĻāϏ āĻāϰāĻ āĻ āύā§āĻāĻāĻŋāĻā§ āϏāĻŽāϰā§āĻĨāύ āĻāϰ⧠āϝāĻž āĻāĻā§ āĻ ā§āϝāĻžāϰā§āϰ āĻā§āϝāĻŧā§āĻ āĻŦā§āĻļāĻŋ āĻĄāĻžāĻāύā§āϝāĻžāĻŽāĻŋāĻ āĻāϰ⧠āϤā§āϞā§āĨ¤ append() āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻāϰ⧠āĻāĻ āĻŦāĻž āĻāĻāĻžāϧāĻŋāĻ āύāϤā§āύ āĻŽāĻžāύ āϏāĻŽā§āĻŦāϞāĻŋāϤ āĻāĻāĻāĻŋ āύāϤā§āύ āϏā§āϞāĻžāĻāϏ āϤā§āϰāĻŋ āĻāϰāϤ⧠āĻĒāĻžāϰāĻŋāĨ¤
s = append(s, "d")
s = append(s, "e", "f")
fmt.Println("apd:", s)
// Output : apd: [a b c d e f]
āĻāĻŽāϰāĻž āĻāĻžāĻāϞ⧠āϏā§āϞāĻžāĻāϏāĻā§ āĻāĻĒāĻŋ āĻāϰāϤ⧠āĻĒāĻžāϰāĻŋ āϤāĻžāϰ āĻāύā§āϝ āĻāĻŽāĻžāĻĻā§āϰ āĻŽā§āĻāύ āϏā§āϞāĻžāĻāϏā§āϰ āĻĻā§āϰā§āĻā§āϝā§āϰ āϏāĻŽāĻžāύ āĻāĻāĻāĻž āĻāĻŽā§āĻĒāĻāĻŋ āϏā§āϞāĻžāĻāϏ āϤā§āϰāĻŋ āĻāϰāϤ⧠āĻšāĻŦā§āĨ¤Â
āĻāĻĻāĻžāĻšāϰāĻŖā§ āĻāĻŽāϰāĻž s āĻāϰ āϏāĻŽāĻžāύ āĻĻā§āϰā§āĻā§āϝā§āϰ āĻāĻāĻāĻŋ āĻāĻžāϞāĻŋ āϏā§āϞāĻžāĻāϏ c āϤā§āϰāĻŋ āĻāϰā§āĻāĻŋ āĻāĻŦāĻ s āϏā§āϞāĻžāĻāϏ c āϤ⧠āĻāĻĒāĻŋ āĻāϰā§ā§āĻāĻŋ –Â
func main() {
s := make([]string, 3)
s[0] = "a"
s[1] = "b"
s[2] = "c"
s = append(s, "d")
s = append(s, "e", "f")
c := make([]string, len(s))
copy(c, s)
fmt.Println("cpy:", c)
}
// Output : cpy: [a b c d e f]
āϏā§āϞāĻžāĻāϏ⧠āύāĻŋāĻŽā§āύā§āϰ āĻ āĻĒāĻžāϰā§āĻļāύāĻā§āϞā§āĻ āĻāϰāĻž āϝāĻžā§Â –
copySlice:= s[2:5] // copying the value from array index 2 to 4
fmt.Println("s1:",copySlice)
copySlice = s[:5] // copying the value from array index 0 to 4
fmt.Println("s2:", copySlice)
copySlice = s[2:] // copying the value from array index 2 to 5
fmt.Println("s3:", copySlice)
Output :
s1: [c d e]
s2: [a b c d e]
s3: [c d e f]
āĻ ā§āϝāĻžāϰā§āϰ āĻŽāϤ⧠āϏā§āϞāĻžāĻāϏāĻ āĻāĻāĻžāϧāĻŋāĻ āĻĄāĻžāĻāĻŽā§āύāĻļāύā§āϰ āĻšāϤ⧠āĻĒāĻžāϰ⧠–
func main() {
twoD := make([][]int, 3)
for i := 0; i < 3; i++ {
innerLen := i + 1
twoD[i] = make([]int, innerLen)
for j := 0; j < innerLen; j++ {
twoD[i][j] = i + j
}
}
fmt.Println(twoD)
}
// Output :
// [[0] [1 2] [2 3 4]]
[ā§§.ā§Ē.⧍.⧍.ā§Š] āĻŽā§āϝāĻžāĻĒāϏ (maps)
Go-āϤ⧠Map āĻšāϞ⧠āĻāĻāĻāĻŋ āĻāĻžāϞā§āĻāĻļāύā§āϰ āĻŽāϤ⧠āϝā§āĻāĻžāύ⧠āĻ āύā§āĻāĻā§āϞ⧠unordered āĻĄāĻžāĻāĻž āĻāĻŋ-āĻā§āϝāĻžāϞ⧠āĻā§ā§āĻž āĻšāĻŋāϏā§āĻŦā§ āĻĨāĻžāĻā§āĨ¤ āĻāĻŽāϰāĻž āĻĻā§āĻāĻāĻžāĻŦā§ āĻŽā§āϝāĻžāĻĒ āϤā§āϰāĻŋ āĻāϰāϤ⧠āĻĒāĻžāϰāĻŋ, make() āĻĢāĻžāĻāĻļāύ āĻāĻžā§āĻž āĻāĻŦāĻ make() āĻĢāĻžāĻāĻļāύ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻāϰā§āĨ¤Â Â
āϏāĻŋāύā§āĻā§āϝāĻžāĻā§āϏ-
// make() āĻĢāĻžāĻāĻļāύ āĻāĻžā§āĻž
map[Key_Type]Value_Type{} // An Empty map
map[Key_Type]Value_Type{key1: value1, ..., keyN: valueN} // Map with key-value pair
// make() āĻĢāĻžāĻāĻļāύ⧠āϏāĻžāĻšāĻžāϝā§āϝā§
make(map[Key_Type]Value_Type, initial_Capacity)
make(map[Key_Type]Value_Type)
āĻāĻĻāĻžāĻšāϰāĻŖ –
package main
import "fmt"
func main() {
var map1 map[int]int
if map1 == nil {
fmt.Println("True")
} else {
fmt.Println("False")
}
map2 := map[int]string{
90: "Dog",
91: "Cat",
92: "Cow",
93: "Bird",
94: "Rabbit",
}
fmt.Println("Map-2: ", map2)
}
// Output :
// True
// Map-2: map[90:Dog 91:Cat 92:Cow 93:Bird 94:Rabbit]
fmt.Println() āĻāϰ āϏāĻžāĻšāĻžāϝā§āϝ⧠āĻāĻāĻāĻŋ map āĻĒā§āϰāĻŋāύā§āĻ āĻāϰāϞ⧠āĻāĻŋ-āĻā§āϝāĻžāϞā§āϰ āĻā§āĻĄāĻŧāĻž āĻšāĻŋāϏā§āĻŦā§ āĻĻā§āĻāĻžāĻŦā§āĨ¤ āϝāĻž āĻāĻŽāϰāĻž āĻāĻĒāϰā§āϰ āĻāĻāĻāĻĒā§āĻā§ āĻĻā§āĻāϤ⧠āĻĒāĻžāĻā§āĻāĻŋāĨ¤
Maps_name[key] āĻĻāĻŋā§ā§ āĻāĻŽāϰāĻž āĻāĻāĻāĻŋ key āĻāϰ āĻāύā§āϝ āĻāĻāĻāĻŋ āĻā§āϝāĻžāϞ⧠āĻĒāĻžāĻŦā§ –
fmt.Println( map2[90])
Output : Dog
len() āĻĢāĻžāĻāĻļāύ āĻŦā§āϝāĻžāĻŦāĻšāĻžāϰ āĻāϰ⧠āĻāĻŽāϰāĻž āĻāĻāĻāĻŋ āĻŽā§āϝāĻžāĻĒā§āϰ āĻā§/āĻā§āϝāĻžāϞā§āϰ āĻā§āĻĄāĻŧāĻžāϰ āϏāĻāĻā§āϝāĻž āĻĒā§āϤ⧠āĻĒāĻžāϰāĻŋ –
fmt.Println("len:", len(map2))
Output : 5
delete() āĻĢāĻžāĻāĻļāύ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻāϰ⧠map āĻĨā§āĻā§ āĻāĻāĻāĻŋ āĻāĻŋ-āĻā§āϝāĻžāϞā§āϰ āĻā§āĻĄāĻŧāĻž āϏāϰāĻŋāϝāĻŧā§ āĻĻāĻŋāϤ⧠āĻĒāĻžāϰāĻŋ –
delete(map2,91)
fmt.Println("Map-2 : ", map2)
Output : Map-2 : map[90:Dog 92:Cow 93:Bird 94:Rabbit
āĻāĻŽāϰāĻž āĻāĻžāĻāϞ⧠āύāĻŋāĻā§āϰ āĻāĻ āϏāĻŋāύāĻā§āϝāĻžāĻā§āϏā§āϰ āϏāĻžāĻšāĻžāϝā§āϝ⧠āĻāĻāĻ āϞāĻžāĻāύ⧠āĻāĻāĻāĻŋ āύāϤā§āύ Map āĻĄāĻŋāĻā§āϞā§ā§āĻžāϰ āĻāĻŦāĻ āĻāύāĻŋāĻļāĻŋā§āĻžāϞāĻžāĻāĻ āĻ āĻāϰāϤ⧠āĻĒāĻžāϰāĻŋ –
func main() {
n := map[string]int{"foo": 1, "bar": 2}
fmt.Println("map:", n)
}
Output : map[bar:2 foo:1]
<āύā§āĻ: āĻāĻŽāĻžāĻĻā§āϰ āĻŽāύ⧠āϰāĻžāĻāϤ⧠āĻšāĻŦā§Â āϝ⧠fmt.Println āĻĻāĻŋāϝāĻŧā§ āĻĒā§āϰāĻŋāύā§āĻ āĻāϰāĻž āĻšāϞ⧠āĻŽā§āϝāĻžāĻĒ map[k:v k:v] āĻāĻāĻžāϰ⧠āĻĒā§āϰāĻĻāϰā§āĻļāĻŋāϤ āĻšāϝāĻŧ>
āϰāϤ⧠āĻĒāĻžāϰāĻŋ –
[ā§§.ā§Ē.⧍.⧍.ā§Ē] āĻĢāĻžāĻāĻļāύāϏ (functions)
āϏāĻšāĻ āĻāĻžāώāĻžāϝāĻŧ āĻĢāĻžāĻāĻļāύ āĻšāϞ āĻāĻŋāĻā§ āĻā§āĻĄ āĻŦāĻž āĻ āĻĒāĻžāϰā§āĻļāύā§āϰ āϏāĻŽāώā§āĻāĻŋ, āϝāĻž āĻā§āύ āύāĻŋāϰā§āĻĻāĻŋāώā§āĻ āĻāĻžāĻ āϏāĻŽā§āĻĒāύā§āύ āĻāϰ⧠āĻāĻžāĻšāĻŋāĻĻāĻžāĻŽāϤ⧠āϰā§āĻāĻžāϞā§āĻ āϰāĻŋāĻāĻžāϰā§āύ āĻāϰ⧠āĻāĻŦāĻ āĻāĻ āĻā§āĻĄ āĻŦā§āϞāĻāĻāĻŋ āĻĒā§āϰā§āĻā§āϰāĻžāĻŽā§āϰ āĻāϰ āĻŦāĻŋāĻāĻŋāύā§āύ āĻāĻžāϝāĻŧāĻāĻž āĻĨā§āĻā§ āĻāϞ āĻāϰāĻž āϝāĻžā§.
Â
āĻĢāĻžāĻāĻļāύā§āϰ āϏāĻŋāύāĻā§āϝāĻžāĻā§āϏ āĻšāϞ –
func function_name(Parameter-list)(Return_type){
// function body.....
}
āύāĻŋāĻā§āϰ āĻāĻĻāĻžāĻšāϰāĻŖā§āϰ āĻĻāĻŋāĻā§ āϞāĻā§āώ āĻāϰāĻŋ, āĻāĻŽāϰāĻž plus āύāĻžāĻŽā§ āĻāĻāĻāĻž āĻĢāĻžāĻāĻļāύ āϤā§āϰāĻŋ āĻāϰā§āĻāĻŋ āϝāĻžāϤ⧠āĻĻā§āĻāĻāĻŋ āĻĒā§āϝāĻžāϰāĻžāĻŽāĻŋāĻāĻžāϰ a āĻāĻŦāĻ b āĻāύā§āĻāĻŋāĻāĻžāϰ āύā§āĻā§āĻž āĻšā§ā§āĻā§ āϝāĻžāϰ āϰāĻŋāĻāĻžāϰā§āύ āĻāĻžāĻāĻĒāĻ āĻāύā§āĻāĻŋāĻāĻžāϰāĨ¤ āĻāĻ āĻĢāĻžāĻāĻļāύāĻāĻŋāϰ āĻāĻžāĻ āĻšāϞ āĻĻā§āĻāĻāĻŋ āύāĻžāĻŽā§āĻŦāĻžāϰ āϝā§āĻ āĻāϰ⧠āϰāĻŋāĻāĻžāϰā§āύ āĻāϰāĻžāĨ¤
func plus(a int, b int) int {
return a + b
}
āϝāĻāύ āĻāĻāĻ āĻāĻžāĻāĻĒā§āϰ āĻāĻāĻžāϧāĻŋāĻ āĻĒā§āϝāĻžāϰāĻžāĻŽāĻŋāĻāĻžāϰ āĻĨāĻžāĻā§, āϤāĻāύ āĻāĻŽāϰāĻž āϏāĻŦāĻā§āϞ⧠āĻĒā§āϝāĻžāϰāĻžāĻŽāĻŋāĻāĻžāϰā§āϰ āĻāύā§āϝ āĻāĻāĻāĻŋ āĻāĻžāĻāĻĒ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻāϰāϤ⧠āĻĒāĻžāϰāĻŋ-
func plusPlus(a, b, c int) int {
return a + b + c
}
package main
import "fmt"
func main() {
res := plus(1, 2)
fmt.Println("1+2 =", res)
res = plusPlus(1, 2, 3)
fmt.Println("1+2+3 =", res)
}
// Output :
// 1+2 = 3
// 1+2+3 = 6
Go-āϤā§Â āĻāĻāĻāĻŋ āĻĢāĻžāĻāĻļāύ āĻāĻāĻžāϧāĻŋāĻ āĻā§āϝāĻžāϞ⧠āϰāĻŋāĻāĻžāϰā§āύ āĻāϰāϤ⧠āĻĒāĻžāϰ⧠–
func vals() (int, string) {
return 3, "Another variable"
}
āĻāĻāĻžāύ⧠āĻāĻŽāϰāĻž āĻĻā§āĻāĻŋ āĻāĻŋāύā§āύ āϰāĻŋāĻāĻžāϰā§āύ āĻŽāĻžāύ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻāϰā§āĻāĻŋ-
func main() {
val, str := vals()
fmt.Println(val)
fmt.Println(str)
}
āĻāĻŦāĻžāϰ, āϝāĻĻāĻŋ āĻāĻŽāϰāĻž āĻā§āύ āĻā§āϝāĻžāϞ⧠āύāĻž āύāĻŋāϤ⧠āĻāĻžāĻ āϏā§āĻāĻžāĻ āĻĒāĻžāϰāĻŦāĨ¤ āĻļā§āϧ⧠āĻāĻŽāĻžāĻĻā§āϰ āĻā§āϝāĻžāϰāĻŋā§ā§āĻŦāϞā§āϰ āĻāĻžā§āĻāĻžā§ ( _ ) āĻāĻ āĻāĻŋāĻšā§āύ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻāϰāϤ⧠āĻšāĻŦā§āĨ¤ āĻāĻā§ āĻ ā§āϝāĻžāύā§āύāĻŋāĻŽāĻžāϏ āĻā§āϝāĻžāϰāĻŋā§ā§āĻŦāϞ āĻ āĻŦāϞāĻž āĻšā§āĨ¤
func main() {
_, str := vals()
fmt.Println(str)
}
Output : Another variable
Go āĻĢāĻžāĻāĻļāύāĻā§āϞā§āϰ āĻāϰāĻ āĻāϝāĻŧā§āĻāĻāĻŋ āĻŦā§āĻļāĻŋāώā§āĻā§āϝ āϰāϝāĻŧā§āĻā§āĨ¤ āϝā§āĻŽāύ, āĻāĻāĻāĻŋ āĻ āύāĻŋāϰā§āĻĻāĻŋāώā§āĻ āϏāĻāĻā§āϝāĻ āĻāϰā§āĻā§āĻŽā§āύā§āĻ āĻā§āϰāĻšāĻŖ āĻāϰāĻž Go āĻĢāĻžāĻāĻļāύā§āϰ āĻāϰā§āĻāĻāĻŋ āĻāĻŽā§āĻāĻžāϰ āĻŦā§āĻļāĻŋāώā§āĻā§āϝāĨ¤ āĻāĻŽāϰāĻž āĻĒāϰāĻŦāϰā§āϤ⧠āĻ āϧā§āϝāĻžā§ā§ āĻāĻā§āϞ⧠āĻŦāĻŋāϏā§āϤāĻžāϰāĻŋāϤ āĻĻā§āĻāĻŦāĨ¤
[ā§§.ā§Ē.⧍.⧍.ā§Ģ] āĻā§āϝāĻžāύā§āϞāϏ (channels)
Go āϤ⧠āĻā§āϝāĻžāύā§āϞ āĻšāϞ āĻĒāĻžāĻāĻĒ āϞāĻžāĻāύā§āϰ āĻŽāϤ⧠āϝāĻžāĻā§ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻāϰ⧠āĻĄāĻžāĻāĻž āϏā§āύā§āĻĄ āĻāĻŦāĻ āϰāĻŋāϏāĻŋāĻ āĻāϰāĻž āĻšā§āĨ¤ āĻŦāĻžāϏā§āϤāĻŦā§ āϝāĻĻāĻŋ āĻāĻŽāϰāĻž āĻĒāĻžāĻāĻĒ āϞāĻžāĻāύā§āϰ āĻĻāĻŋāĻā§ āϤāĻžāĻāĻžāĻ āϤāĻžāĻšāϞ⧠āĻĻā§āĻāϤ⧠āĻĒāĻžāĻŦā§ āĻĒāĻžāĻāĻĒ āϞāĻžāĻāύā§āϰ āĻŽāĻžāϧā§āϝāĻŽā§ āĻĒāĻžāύāĻŋ āĻāĻ āĻĒā§āϰāĻžāύā§āϤ āĻĨā§āĻā§ āĻ āύā§āϝ āĻĒā§āϰāĻžāύā§āϤ⧠āĻĒā§āϰāĻŦāĻžāĻšāĻŋāϤ āĻšāĻā§āĻā§, āĻāĻāĻāĻāĻžāĻŦā§ āĻā§āϝāĻžāύā§āϞ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻāϰ⧠āĻāĻ āĻĒā§āϰāĻžāύā§āϤ āĻĨā§āĻā§ āĻĄāĻžāĻāĻž āĻĒāĻžāĻ āĻžāύ⧠āĻšā§ āĻāĻŦāĻ āĻ āύā§āϝ āĻĒā§āϰāĻžāύā§āϤ āĻĨā§āĻā§ āĻĄāĻžāĻāĻž āĻā§āϰāĻšāĻŖ āĻāϰāĻž āĻšā§āĨ¤ āĻā§āϝāĻžāύā§āϞāϏ āϏāĻŽā§āĻĒāϰā§āĻā§ āĻāĻŽāϰāĻž āĻāύāĻāĻžāϰā§āύā§āϏāĻŋ āϏā§āĻāĻļāύ āĻĨā§āĻā§ āĻāϰāĻ āĻŦāĻŋāϏā§āϤāĻžāϰāĻŋāϤ āĻāĻžāύāĻŦāĨ¤ “<-” āĻ āĻĒāĻžāϰā§āĻāϰā§āϰ āϏāĻžāĻšāĻžāϝā§āϝ⧠āĻā§āϝāĻžāύā§āϞ āĻĄāĻžāĻāĻž āϏā§āύā§āĻĄ āĻāĻŦāĻ āϰāĻŋāϏāĻŋāĻ āĻāϰ⧠–
ch <- v // Send v to channel ch.
v := <-ch // Receive from ch, and assign value to v.
Map āĻāĻŦāĻ āϏā§āϞāĻžāĻāϏ-āĻāĻ°Â āĻŽāϤā§, āĻŦā§āϝāĻŦāĻšāĻžāϰā§āϰ āĻāĻā§ āĻā§āϝāĻžāύā§āϞāĻā§āϞ⧠āĻĄāĻŋāĻā§āϞā§ā§āĻžāϰ āĻāϰāϤ⧠āĻšāĻŦā§ – āĻŦāĻŋāϏā§āϤāĻžāϰāĻŋāϤ āĻĻā§āĻāĻŦāĨ¤
ch := make(chan int)
āύāĻŋāĻā§āϰ āĻāĻĻāĻžāĻšāϰāĻŖāĻāĻŋ āϞāĻā§āώ āĻāϰāĻŋ –
package main
import (
"fmt"
)
func main() {
numberCh := make(chan int, 10)
for i := 1; i <= 10; i++ {
numberCh <- i
}
for j := 1; j <= 10; j++ {
fmt.Println(<-numberCh)
}
}
āĻāĻāĻžāύ⧠numberCh <-i āĻŽāĻžāϧā§āϝāĻŽā§ āĻāĻŽāϰāĻž āĻā§āϝāĻžāύā§āϞ⧠āĻĄā§āĻāĻž āϏā§āύā§āĻĄ āĻāϰā§āĻāĻŋ āĻāĻŦāĻ <- numberCh āĻāϰ āĻŽāĻžāϧā§āϝāĻŽā§ āĻĒāĻžāĻ āĻžāύ⧠āĻĄā§āĻāĻž āϰāĻŋāϏāĻŋāĻ āĻāϰā§āĻāĻŋāĨ¤ āĻāĻŽāϰāĻž āĻāĻžāĻāϞ⧠āĻĒāĻžāĻ āĻžāύ⧠āĻĄā§āĻāĻž āϰāĻŋāϏāĻŋāĻ āĻāϰ⧠āϝ⧠āĻā§āύ⧠āĻā§āϝāĻžāϰāĻŋā§ā§āĻŦāϞā§āĻ āϏā§āĻā§āϰ āĻāϰ⧠āϰāĻžāĻāϤ⧠āĻĒāĻžāϰāϤāĻžāĻŽ (newNumber := <- numberCh)āĨ¤
āĻāĻāĻāĻĒā§āĻ –
1
2
3
4
5
6
7
8
9
10
[ā§§.ā§Ē.⧍.ā§Š] āĻāύā§āĻāĻžāϰāĻĢā§āϏ āĻāĻžāĻāĻĒ (Interface type)
āĻāύā§āĻāĻžāϰāĻĢā§āϏ āĻšāϞ⧠āĻāĻžāϏā§āĻāĻŽ āĻĄāĻžāĻāĻž āĻāĻžāĻāĻĒ āϏā§āĻāĻžāύ⧠āĻ āύā§āĻāĻā§āϞ⧠āĻŽā§āĻĨāĻĄā§āϰ āϏāĻŋāĻāύā§āĻāĻžāϰ āĻĨāĻžāĻā§ āĻāĻŦāĻ āĻā§āύ⧠Struct āĻŦāĻž Non-struct āĻĄāĻžāĻāĻž āĻāĻžāĻāĻĒ āĻāĻā§āϞ⧠āĻŽā§āĻĨāĻĄ āĻšāĻŋāϏā§āĻŦā§ āĻāĻŽāĻĒā§āϞāĻŋāĻŽā§āύā§āĻ āĻāϰāϞ⧠āĻāύā§āĻāĻžāϰāĻĢā§āϏāĻāĻŋ āĻāĻŽāĻĒā§āϞāĻŋāĻŽā§āύā§āĻ āĻšā§ā§ āϝāĻžā§āĨ¤ –
type geometry interface {
area() float64
perim() float64
}
āĻāĻĻāĻžāĻšāϰāĻŖā§, āĻāϝāĻŧāϤāĻā§āώā§āϤā§āϰ āĻāĻŦāĻ āĻŦā§āϤā§āϤā§āϰ Struct āĻ āĻāύā§āĻāĻžāϰāĻĢā§āϏ geometry āĻāĻŽāĻĒā§āϞāĻŋāĻŽā§āύā§āĻ āĻāϰāĻž āĻšāϞ –
type rect struct {
width, height float64
}
type circle struct {
radius float64
}
func (r rect) area() float64 {
return r.width * r.height
}
func (r rect) perim() float64 {
return 2*r.width + 2*r.height
}
func (c circle) area() float64 {
return math.Pi * c.radius * c.radius
}
func (c circle) perim() float64 {
return 2 * math.Pi * c.radius
}
āϝāĻĻāĻŋ āĻāĻāĻāĻŋ āĻā§āϝāĻžāϰāĻŋā§ā§āĻŦāϞ āĻāĻāĻāĻŋ āĻāύā§āĻāĻžāϰāĻĢā§āϏ āĻāĻŽāĻĒā§āϞāĻŋāĻŽā§āύā§āĻ āĻāϰ⧠āĻĨāĻžāĻā§, āϤāĻžāĻšāϞ⧠āĻāĻŽāϰāĻž āĻāύā§āĻāĻžāϰāĻĢā§āϏ⧠āĻĨāĻžāĻāĻž āĻŽā§āĻĨāĻĄāĻā§āϞā§āĻā§ āĻāϞ āĻāϰāϤ⧠āĻĒāĻžāϰāĻŋāĨ¤ āϝā§āĻā§āύ geometry āĻāύā§āĻāĻžāϰāĻĢā§āϏ āĻāĻŽāĻĒā§āϞāĻŋāĻŽā§āύā§āĻāĻāĻžāϰā§āϰ āĻŽā§āĻĨāĻĄ āĻā§āϞ⧠āϰāĻžāύ āĻāϰāĻžāϰ āĻāύā§āϝ āĻāĻāĻžāύ⧠āĻāĻāĻāĻŋ measure() āĻĢāĻžāĻāĻļāύ āϰāϝāĻŧā§āĻā§āĨ¤
func measure(g geometry) {
fmt.Println(g)
fmt.Println(g.area())
fmt.Println(g.perim())
}
āĻāϝāĻŧāϤāĻā§āώā§āϤā§āϰ āĻāĻŦāĻ āĻŦā§āϤā§āϤ āĻāĻāϝāĻŧ struct , geometry āĻāύā§āĻāĻžāϰāĻĢā§āϏ āĻĒā§āϰāϝāĻŧā§āĻ āĻāϰā§āĻā§āĨ¤ āĻāĻāύ āĻāĻŽāϰāĻž āĻĒāϰāĻŋāĻŽāĻžāĻĒ āĻāϰāĻžāϰ āĻāύā§āϝ āĻāϰā§āĻā§āĻŽā§āύā§āĻ āĻšāĻŋāϏāĻžāĻŦā§ āĻāĻ Struct āĻā§āϞ⧠āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻāϰāϤ⧠āĻĒāĻžāϰāĻŋ –
func main() {
r := rect{width: 3, height: 4}
c := circle{radius: 5}
measure(r)
measure(c)
}
āĻāĻāĻāĻĒā§āĻ –
{3 4}
12
14
{5}
78.53981633974483
31.41592653589793