Vivasoft-logo

[ā§§.ā§Ē] āĻĄāĻžāϟāĻž āϟāĻžāχāĻĒ (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