Go மொழி ஒரு பார்வை

 

அறிமுகம்.

 

Go மொழியானது 2007-ல் கூகிளால் உருவாக்கப்பட்டது.இது ஸ்டேட்டிக்களி டைப்டு மொழியாகும்.

சி மொழியின் சிண்டாக்சை ஒத்தது.இது உயர்ந்த செயல் திறன் மற்றும் விரைவான உருவாக்கம் ஆகியவற்றிகாக உருவாக்கப்பட்டது.இது டைப் சேஃப்டி,, கார்பேஜ் கலக்சன் ,டைனமின் டைப்பிங்க் திறன் போன்ற அம்சங்களை கொண்டது. மேலும் இது வேரியபிள் லெங்க்த் அர்ரே, கீ வேயூ மேப் போன்ற வற்றையும் கொண்டது.

இது நவீனமானது

வேகமானது

இது இன்டெர்ஃபேசஸை கோட் ரியூசபிளிட்டிக்காக பயன்படுத்துகின்றது.

Go மொழியின் அடிப்படை அமைப்பு பின் வருவனவற்றை கொண்டுள்ளது.

1.      பேக்கேஜ் அறிவிப்பு

2.      பேக்கேஜ் இம்போர்ட்

3.      வேரியபிள்கள்

4.      ஃபங்க்சன்கள்

5.      ஸ்டேட்மெண்டுகள் மற்றும் எக்ஸ்பிரசன்கள்

6.      குறிப்புகள்

சான்று நிரல்.

package main  

import "fmt"  

func main() {  

   fmt.Println("Hello, World")  

}  

வெளியீடு:

Hello, World

மேலே உள்ள மொழியில் முதல் வரியானது பேக்கேஜ் அறிவிப்பாகும். இங்கே பேக்கேஜ் ஆனது main ஆகும்.

ஒவ்வொரு நிரலும் க ண்டிப்பாக பேக்கேஜ் அறிவிப்பை கொண்டிருக்க வேண்டும்.

அடுத்து வருன் வரி பேக்கேஜ் இம்போர்ட் ஆகும். இங்கு fmt என்ற லைப்ரேரி பேக்கேஜை இம்போர்ட் செய்கின்றோம்.

அடுத்து main() ஃபங்க்சன். ஒரு நிரலின் இயக்கம் main() ஃபங்க்சனில் தான் தொடங்கும்.

அடுத்து வரும் வரி fmt.Println() ஆனது go மொழியின் ஃபங்க்சன் ஆகும் இது ‘Hello ,world’ என்பதை பிரிண்ட் செய்கின்றது.

இதை சான்றாக Hello.go என்ற பெயரில் சேவ் செய்கின்றோம்

இதை இயக்க கமாண்ட் பிராம்ப்டில் பின் வருமாறு டைப் செய்தல் வேண்டும்.

go run Hello.go  

 

டேட்டா டைப்கள்>

Go மொழியில் நிறைய விதமான டேட்டா டைப்கள் உள்ளது.

உதாரணமாக intm float, struct மற்றும் இன்டெர்ஃபேஸ் போன்றவையாகும்.

ஒரு வேரியபிளை கோ மொழியில் அறிவித்தல் சிண்டாக்ஸ்.

 

Var identifier type

 

சான்று

 

Var a int

Var x float

\var b bool

Var s string

 

Var என்ற கீவேர்டுடன் அறிவிக்கப்படும் வேரியபிள் ஆனது அதன் மதிப்பை ஆட்டோமேட்டிக் ஆக 0 விற்கு தொடக்க மதிப்பிருத்துகின்றது.

Type ஆனது அந்த வேரியபிளில் எந்த மதிப்புப் இருத்த முடியும். அதன் மேல் என்ன செயற்பாடுகள் செய்ய முடியும் என்பதை குறிக்கின்றது.

Go Datatype சான்று நிரல்.

package main  

import "fmt"  

func main() {  

   var i int  

   var f float64  

   var b bool  

   var s string  

   fmt.Printf("%T %T %T %T\n",i,f,b,s) // Prints type of the variable  

   fmt.Printf("%v   %v      %v  %q     \n", i, f, b, s) //prints initial value of the variable  

}  

வெளியீடு:

int float64 bool string

0   0           false  ""   

 

Go ஸ்ட்ரக்சர்

 

கோ நிரலானது . go என்ற எக்ஸ்டன்சனுடன் சேவ் செய்யப்படுகின்றது.

இதன் பெயர் சிறிய எழுத்துகளிலும் ஒன்றுக்கு மேற்பட்ட வார்த்தை இருந்தால்’ _’ ஆல் இணைக்கப்படுகின்றது.

இதன் பெயர் மற்றும் ஐடென்டிஃபையர் சி மொழி போன்று கேஸ் சென்ஸ்டிவ் ஆகும்.

 

இதில் _ ஐடென்டிஃபையர் சிறப்பானது இது வெற்று ஐடெண்டிஃபையராக கருதப்படுகின்றது. இதன் மதிப்பு துண்டிக்கப்பட்டதாகும், எனவே இதை மேலும் நிரலில் பயன்படுத்த முடியாது.

ஃபங்க்சன்களும் பெயரில்லாமல் அனானிமஸ் ஆக இருக்கலாம்.

இது break,default, func போன்று மொத்தம் 25 கீவேர்டுகள் இருக்கின்றன.

 

ஒரு நிரலானது வேரியபிள், ஃபுங்க்சன் , கீ வேர்டு, ஆபரேட்டர் ,மற்றும் டைப் ஆகியவற்றை கொண்டிருக்கும்.

இதில் பயன்படுத்தப்படும் டிலிமிட்டர்கள்

(),[],{} ஆகியவை.

:; போன்றவையும் இதில் பயன்படுகின்றது.

 

 

பேக்கேஜ்கள்.

பேக்கேஜ்கள் ஒரு நிரலை நிர்வாகிக்க எளிதாக்குகின்றது.

ஒவ்வொரு go ஃபைலும் ஒரு பேக்கேஜை கொண்டிருக்கும்.

ஒவ்வொரு கோ பயன்பாடும் main பேக்கேஜை கொண்டிருக்க வேண்டும்.

ஒவ்வொரு மெயின் பேக்கேஜும் வெவ்வேறான கோ ஃபைலை கொண்டிருக்கும்.

ஒவ்வொரு கோ நிரலும் வெவ்வேறு பேக்கேஜ் உடன் இம்போர்ட் கீவேர்டை பயன்படுத்தி இணைக்கப்படுகின்றது.

பேக்கேஜ் பெயரானது “”” க்குள் குறிப்பிடப்படுகின்றது.

ஒன்றுக்கு மேற்பட்ட பேக்கேஜுகளை ஒன்றுக்கு மேற்பட்ட வரிகளிலோ

Import “fmt”

Import “os”

அல்லது

Import “fmt”;import “os”

என்ற் ஒற்றை வரியிலோ அல்லது சுருக்கமாக

Import(

“fmt”,

“os”

)

என்றோ இம்போர்ட் செய்யலாம்.

ஒரு ஐடெண்டிஃபையரை  சிறிய எழுத்துகளிலோ அல்லது கேபிடல் எழுத்துகளிலோ குறிப்பியடலாம்.

சிறிய எழுத்துகளில் எழுதப்படும் ஐடென்டிஃபையர் அந்த பேக்கேஜில் மட்டும் அணுகும் விதமாக இருக்கும்.

கேப்பிடல் எழுத்துகளில் எழுதப்படும் ஐடென்டிஃபையர் மற்ற பேக்கேஜுகளும் அணுகலாம்.

Go if

If ஆனது ஒரு கண்டிசனை ட்ரூ அல்லது ஃபால்சா என பரொய்சோதிக்கின்றது. ட்ரூ எனில் அந்த நிரல் வரிகள் இயக்கப்படும்.இல்லையெனில் இயக்கப்படாது.

சிண்டாக்ஸ்

1.     if(boolean_expression) {  

2.        /* statement(s) got executed only if the expression results in true */  

3.     }  

சான்று நிரல்.

package main  

import "fmt"  

func main() {  

   /* local variable definition */  

   var a int = 10  

   /* check the boolean condition using if statement */  

   if( a % 2==0 ) {      /* if condition is true then print the following 

*/ fmt.Printf("a is even number" )  

   }  

}  

 

வெளியீடு:

a is even number

 

 

Go if else.

இது ஒரு கண்டிசன் ட்ரூ ஆக இருந்தால் இஃப் பகுதியையும் ஃபால்ஸ் ஆக இருந்தால் எல்ஸ் பகுதியையும் இயக்குகின்றது.

சிண்டாக்ஸ்.

1.     if(boolean_expression) {  

2.        /* statement(s) got executed only if the expression results in true */  

3.     } else {  

4.        /* statement(s) got executed only if the expression results in false */  

5.     }  

சான்று நிரல்.

func main() {  

   fmt.Print("Enter number: ")  

   var input int  

  fmt.Scanln(&input)  

   fmt.Print(input)  

   /* check the boolean condition */  

   if( input % 2==0 ) {  

      /* if condition is true then print the following */  

      fmt.Printf(" is even\n" );  

   } else {  

      /* if condition is false then print the following */  

      fmt.Printf(" is odd\n" );  

   }  

}  

வெளியீடு:

Enter number: 10

10 is even

If else if

இது ஒரு கண்டிசன் ஃபால்ஸ் எனில் இன்னொரு கண்டிசனை பரிசோதிக்கின்றது. இது போல் ஒன்றுக்கு மேற்பட்ட எல்ஸ் இஃபை பயன்படுத்தலாம் .எல்லாமே ஃபால்ஸ் எனில் எல்ஸ் பகுதி இயக்கபடுகின்றது.

package main  

import "fmt"  

func main() {  

   fmt.Print("Enter text: ")  

   var input int  

   fmt.Scanln(&input)  

   if (input < 0 || input > 100) {  

      fmt.Print("Please enter valid no")  

   } else if (input >= 0 && input < 50  ) {  

      fmt.Print(" Fail")  

   } else if (input >= 50 && input < 60) {  

      fmt.Print(" D Grade")  

   } else if (input >= 60 && input < 70  ) {  

      fmt.Print(" C Grade")  

   } else if (input >= 70 && input < 80) {  

      fmt.Print(" B Grade")  

   } else if (input >= 80 && input < 90  ) {  

      fmt.Print(" A Grade")  

   } else if (input >= 90 && input <= 100) {  

      fmt.Print(" A+ Grade")  

   }  

}  

வெளியீடு:

Enter text: 84

 A Grade

 

Go switch.

இது ஒரு வேரியபிளின் மதிப்பை பரிசோதிக்கின்றது. அதன் ஒவ்வொரு மதிப்புக்கும் வெவ்வேறு விதமான ஸ்டேட்மெண்டுகள் இயக்கப்படுகின்றது.

switch  var1 {  

case val1:  

.....  

case val2  

.....  

default:  

.....  

}                         

சான்று நிரல்.

package main  

import "fmt"  

func main() {  

   fmt.Print("Enter Number: ")  

  var input int  

  fmt.Scanln(&input)  

   switch (input) {  

  case 10:  

      fmt.Print("the value is 10")  

    case 20:  

      fmt.Print("the value is 20")  

    case 30:  

      fmt.Print("the value is 30")  

    case 40:  

      fmt.Print("the value is 40")  

    default:  

      fmt.Print(" It is not 10,20,30,40 ")  

   }  

}  

வெளியீடு

Enter Number: 20

the value is 20

 

go for loop.

இது ஒரு கண்டிசன் ட்ரூ ஆக இருக்குக் வரை அதனை திரும்ப திரும்ப இயக்குகின்றது.

கோ மொழியில் இந்த ஒரு லூப் தான் இருக்கின்றது.

 

1.     package main  

2.     import "fmt"  

3.     func main() {  

4.        for a := 0; a < 11; a++ {  

5.           fmt.Print(a,"\n")  

6.        }  

7.     }  

Output:

0

1

2

-

10.

 

நன்றி

முத்து கார்த்திகேயன்,மதுரை.