Go ରେ ପଏଣ୍ଟରକୁ ବୁଝିବା

ପ୍ରଥମେ ପଏଣ୍ଟର ଟିକେ ଭୟଭୀତ କରିପାରେ, ବିଶେଷକରି ଯଦି ଆପଣ JavaScript, Python, କିମ୍ବା Java ପରି ଭାଷାରୁ ଆସୁଛନ୍ତି, ଯେଉଁଠାରେ ମେମୋରୀ ପରିଚାଳନା ସ୍ୱୟଂଚାଳିତ। କିନ୍ତୁ ବ୍ୟସ୍ତ ହୁଅନ୍ତୁ ନାହିଁ! Go ରେ ପଏଣ୍ଟରକୁ ବୁଝିବା ଯେତିକି କଷ୍ଟ ଲାଗେ ତା'ଠାରୁ ଅଧିକ ସହଜ ଅଟେ।

ପଏଣ୍ଟର ସହିତ କିପରି କାମ କରାଯାଏ ତାହା ଜାଣିବା ଗୁରୁତ୍ୱପୂର୍ଣ୍ଣ କାରଣ ଡେଭେଲପରମାନେ ବ୍ୟାକ୍‌ଏଣ୍ଡ୍ ଡେଭେଲପମେଣ୍ଟ୍ ପାଇଁ ଅଧିକରୁ ଅଧିକ Go ର ବ୍ୟବହାର କରୁଛନ୍ତି। ଆସନ୍ତୁ ମୌଳିକ ବିଷୟଗୁଡ଼ିକ ଉପରେ ନଜର ପକାଇବା।

ପଏଣ୍ଟରଗୁଡ଼ିକ କ'ଣ?

Go ରେ, ଏକ ପଏଣ୍ଟର ହେଉଛି ଏକ ସ୍ୱତନ୍ତ୍ର ପ୍ରକାରର ଭେରିଏବଲ୍। ଏକ ମୂଲ୍ୟକୁ ସିଧାସଳଖ ଷ୍ଟୋର୍ କରିବା ପରିବର୍ତ୍ତେ, ଏକ ପଏଣ୍ଟର ଅନ୍ୟ ଏକ ଭେରିଏବଲ୍ ର ମେମୋରୀ ଠିକଣା ଧରିଥାଏ। ଏକ ପ୍ରୋଗ୍ରାମରେ ଥିବା ପ୍ରତ୍ୟେକ ଭେରିଏବଲ୍ ମେମୋରୀରେ ଏକ ସ୍ଥାନ ଦଖଲ କରିଥାଏ, ଏବଂ ସେହି ସ୍ଥାନର ଏକ ସ୍ୱତନ୍ତ୍ର ଠିକଣା ଥାଏ।

ଉଦାହରଣ ସ୍ୱରୂପ, ଯଦି ଆପଣଙ୍କର ଏକ ଭେରିଏବଲ୍ ଅଛି x ଯାହା ମୂଲ୍ୟ ଧାରଣ କରେ 10, ଆପଣ ଏକ ପଏଣ୍ଟର ତିଆରି କରିପାରିବେ p ଯାହା ସୂଚାଇଥାଏ xର ଠିକଣାକୁ। ଏହା କିପରି କାମ କରେ ଏଠାରେ ଦିଆଯାଇଛି:

x := 10
p := &x
fmt.Println(*p) // Outputs: 10

ଏହି କୋଡ୍ ରେ:

• x ମୂଲ୍ୟ ଧାରଣ କରେ 10.
• p ହେଉଛି ଏକ ପଏଣ୍ଟର ଯାହା ଠିକଣା ସଞ୍ଚୟ କରେ x (ବ୍ୟବହାର କରି & ଅପରେଟର୍)।
• *p ପଏଣ୍ଟରକୁ ଡିରେଫରେନ୍ସ କରେ, ଯାହାଦ୍ୱାରା ଆପଣ ସେହି ଠିକଣାରେ ସଞ୍ଚୟ ହୋଇଥିବା ମୂଲ୍ୟକୁ ଆକ୍ସେସ୍ କରିପାରିବେ, ଯାହା ହେଉଛି 10.

ମୁଖ୍ୟ ଅପରେଟର୍ ଗୁଡ଼ିକ

ପଏଣ୍ଟର ସହିତ କାମ କରିବା ସମୟରେ, ମନେ ରଖିବା ପାଇଁ ଦୁଇଟି ଗୁରୁତ୍ୱପୂର୍ଣ୍ଣ ଅପରେଟର୍ ଅଛି:

• &: ଏକ ଭେରିଏବଲ୍ ର ଠିକଣା ପାଇବା ପାଇଁ ଏହି ଅପରେଟର୍ ବ୍ୟବହାର କରାଯାଏ। ଉଦାହରଣ ସ୍ୱରୂପ, &x ଆପଣଙ୍କୁ ସେହି ଠିକଣା ଦିଏ ଯେଉଁଠାରେ x ସଞ୍ଚୟ ହୋଇଛି।
• *: ଏହି ଅପରେଟର୍ ଏକ ପଏଣ୍ଟରକୁ ଡିରେଫରେନ୍ସ କରେ, ଅର୍ଥାତ୍ ଏହା ପଏଣ୍ଟର ସୂଚାଉଥିବା ଠିକଣାରେ ଥିବା ମୂଲ୍ୟକୁ ଆକ୍ସେସ୍ କିମ୍ବା ପରିବର୍ତ୍ତନ କରିଥାଏ। ଉଦାହରଣ ସ୍ୱରୂପ, *p ଆପଣଙ୍କୁ ମୂଲ୍ୟ ଦିଏ x.

ପଏଣ୍ଟର କାହିଁକି ବ୍ୟବହାର କରିବେ?

କେତେକ କ୍ଷେତ୍ରରେ ପଏଣ୍ଟରଗୁଡ଼ିକ ବିଶେଷ ଉପଯୋଗୀ ଅଟେ:

• ମୂଳ ମୂଲ୍ୟଗୁଡ଼ିକୁ ପରିବର୍ତ୍ତନ କରିବା: ଯେତେବେଳେ ଆପଣ ଏକ ଫଙ୍କସନ୍ ଭିତରେ ଥିବା ଏକ ଭେରିଏବଲ୍ ର ମୂଲ୍ୟ ପରିବର୍ତ୍ତନ କରିବାକୁ ଚାହାଁନ୍ତି, ସେତେବେଳେ ଆପଣ ସେହି ଭେରିଏବଲ୍ କୁ ଏକ ପଏଣ୍ଟର ପାସ୍ କରିପାରିବେ। ଏହିପରି, ଫଙ୍କସନ୍ ଏକ କପି ପରିବର୍ତ୍ତେ ମୂଳ ମୂଲ୍ୟକୁ ପରିବର୍ତ୍ତନ କରିପାରିବ।

ଉଦାହରଣ ସ୍ୱରୂପ:

func changeName(user *User) {
    user.Name = "João"
}

user := User{Name: "Lucas"}
changeName(&user)
fmt.Println(user.Name) // Outputs: João

ଏହି ଉଦାହରଣରେ, ଫଙ୍କସନ୍ changeName ପାଇଁ ଏକ ପଏଣ୍ଟର ଗ୍ରହଣ କରେ user, ଯାହାକି ଏହାକୁ ମୂଳ ବ୍ୟବହାରକାରୀଙ୍କ ନାମ ପରିବର୍ତ୍ତନ କରିବାକୁ ଅନୁମତି ଦିଏ।

• ବଡ଼ ଡାଟା ଷ୍ଟ୍ରକ୍ଚର୍ ଶେୟାର କରିବା: ଯଦି ଆପଣଙ୍କ ପାଖରେ ବଡ଼ ଡାଟା ଷ୍ଟ୍ରକ୍ଚର୍ ଅଛି, ତେବେ ପଏଣ୍ଟର ପାସ୍ କରିବା ଦ୍ୱାରା ମେମୋରୀ ସଞ୍ଚୟ ହୋଇପାରିବ ଏବଂ ପ୍ରଦର୍ଶନରେ ଉନ୍ନତି ଆସିପାରିବ। ସମ୍ପୂର୍ଣ୍ଣ ଷ୍ଟ୍ରକ୍ଚର୍ କପି କରିବା ପରିବର୍ତ୍ତେ, ଆପଣ କେବଳ ପଏଣ୍ଟର ପାସ୍ କରିପାରିବେ।

• ଡାଟା ଷ୍ଟ୍ରକ୍ଚର୍ କାର୍ଯ୍ୟକାରୀ କରିବା: ଲିଙ୍କ୍ ହୋଇଥିବା ଲିଷ୍ଟ୍ କିମ୍ବା ଟ୍ରି ପରି ଜଟିଳ ଡାଟା ଷ୍ଟ୍ରକ୍ଚର୍ ତିଆରି କରିବା ପାଇଁ ପଏଣ୍ଟର ଅତ୍ୟାବଶ୍ୟକ, ଯେଉଁଠାରେ ଉପାଦାନଗୁଡ଼ିକ ପରସ୍ପରକୁ ସୂଚାଇଥାନ୍ତି।

ବ୍ୟାବହାରିକ ଉଦାହରଣ

ଧରିନିଅନ୍ତୁ ଆପଣ ଏକ API ତିଆରି କରୁଛନ୍ତି। ଆପଣ ଏକ ଡାଟାବେସ୍ ସଂଯୋଗର ଏକକ ଇନଷ୍ଟାନ୍ସ ତିଆରି କରିପାରିବେ ଯାହାକୁ ଏକାଧିକ ରିପୋଜିଟୋରୀ ଶେୟାର କରିପାରିବେ:

db, _ := sql.Open("postgres", dsn)
userRepo := NewUserRepository(db)
orderRepo := NewOrderRepository(db)

ଏହି କ୍ଷେତ୍ରରେ, ଉଭୟ userRepo ଏବଂ orderRepo ସମାନ ଡାଟାବେସ୍ ସଂଯୋଗ ବ୍ୟବହାର କରିପାରିବେ, ଯାହା ଦକ୍ଷ ଅଟେ ଏବଂ ଅନାବଶ୍ୟକ କପିକୁ ଏଡ଼ାଇଥାଏ।

ଉତ୍ତମ ଅଭ୍ୟାସ

ଏକ ସାଧାରଣ ନିୟମ ହେଉଛି ଡିଫଲ୍ଟ ଭାବରେ ମୂଲ୍ୟଗୁଡ଼ିକ ବ୍ୟବହାର କରିବା। ଯେତେବେଳେ ଆପଣଙ୍କୁ ନିମ୍ନଲିଖିତ ଦରକାର ହୁଏ ସେତେବେଳେ ପଏଣ୍ଟର ବ୍ୟବହାର କରନ୍ତୁ:

• ଡାଟାର ସମାନ ଇନଷ୍ଟାନ୍ସକୁ ଶେୟାର୍ କିମ୍ବା ପରିବର୍ତ୍ତନ କରିବା।
• ଏକ ନଲ୍ (null) ମୂଲ୍ୟ ପ୍ରତିନିଧିତ୍ୱ କରିବା ପାଇଁ (nil)।
• ବଡ଼ କିମ୍ବା ଜଟିଳ ଡାଟା ଷ୍ଟ୍ରକ୍ଚର୍ କପି କରିବା ଏଡ଼ାନ୍ତୁ।

ଉପସଂହାର

Go ରେ ପଏଣ୍ଟରଗୁଡ଼ିକୁ ବୁଝିବା ଦକ୍ଷ ପ୍ରୋଗ୍ରାମିଂ ପାଇଁ ନୂତନ ସମ୍ଭାବନା ଖୋଲିଥାଏ। ଅନାବଶ୍ୟକ ନକଲ ବିନା ଡାଟା ପରିଚାଳନା କରିବାକୁ ସେଗୁଡ଼ିକ ଆପଣଙ୍କୁ ଅନୁମତି ଦିଅନ୍ତି, ଯାହା ଆପଣଙ୍କ ଆପ୍ଲିକେସନ୍ ଗୁଡ଼ିକୁ ଦ୍ରୁତ ଏବଂ ଅଧିକ ମେମୋରୀ-ଦକ୍ଷ କରିଥାଏ।

ସୁବିଧାଗୁଡ଼ିକ

• ଅନାବଶ୍ୟକ କପି ଏଡ଼ାଇବା ଦ୍ୱାରା ଦକ୍ଷ ମେମୋରୀ ବ୍ୟବହାର।
• ଫଙ୍କସନ୍ ଭିତରେ ମୂଳ ଭେରିଏବଲ୍ ପରିବର୍ତ୍ତନ କରିବାର କ୍ଷମତା।
• ଜଟିଳ ଡାଟା ଷ୍ଟ୍ରକ୍ଚର୍ କାର୍ଯ୍ୟକାରୀ କରିବା ପାଇଁ ଅତ୍ୟାବଶ୍ୟକ।

ଅସୁବିଧାଗୁଡ଼ିକ

• ଆରମ୍ଭକାରୀଙ୍କ ପାଇଁ ଦ୍ୱନ୍ଦ୍ୱାତ୍ମକ ହୋଇପାରେ।
• ତ୍ରୁଟି ଏଡ଼ାଇବା ପାଇଁ ଯତ୍ନଶୀଳ ପରିଚାଳନା ଆବଶ୍ୟକ କରେ, ଯେପରିକି ଏକ nil ପଏଣ୍ଟରକୁ ଡିରେଫରେନ୍ସ କରିବା।

ସତର୍କତା

ଏହି ଲେଖାଟି ଶିକ୍ଷଣ ଉଦ୍ଦେଶ୍ୟରେ ଉଦ୍ଦିଷ୍ଟ। ଆପଣଙ୍କ କୋଡ୍ ରେ ଥିବା କୌଣସି ପ୍ଲେସହୋଲ୍ଡର୍ ମୂଲ୍ୟକୁ ସର୍ବଦା ପ୍ରକୃତ ଡାଟା ସହିତ ବଦଳାନ୍ତୁ। ସେଗୁଡ଼ିକ ଉପରେ ନିର୍ଭର କରିବା ପୂର୍ବରୁ ମୂଳ ଉତ୍ସ ସହିତ କୌଣସି ଦାବି ଯାଞ୍ଚ କରିବାକୁ ନିଶ୍ଚିତ କରନ୍ତୁ।

ବାରମ୍ବାର ପଚରାଯାଉଥିବା ପ୍ରଶ୍ନଗୁଡ଼ିକ

• Go ରେ ପଏଣ୍ଟର କ'ଣ? — ଏକ ପଏଣ୍ଟର ହେଉଛି ଏକ ଭେରିଏବଲ୍ ଯାହା ଅନ୍ୟ ଏକ ଭେରିଏବଲ୍ ର ମୂଲ୍ୟ ବଦଳରେ ତାହାର ମେମୋରୀ ଠିକଣା ସଞ୍ଚୟ କରେ।
• Go ରେ ମୁଁ କିପରି ଏକ ପଏଣ୍ଟର ତିଆରି କରିବି? — ଆପଣ ଏକ ପଏଣ୍ଟର ତିଆରି କରିପାରିବେ & ଅପରେଟର୍ ବ୍ୟବହାର କରି ଏକ ଭେରିଏବଲ୍ ର ଠିକଣା ପାଇବା ପାଇଁ।
• ଏହି * ଅପରେଟର୍ କ'ଣ କରେ? — ଏହି * ଅପରେଟର୍ ଏକ ପଏଣ୍ଟରକୁ ଡିରେଫରେନ୍ସ କରେ, ଯାହା ଆପଣଙ୍କୁ ଏହା ସୂଚାଉଥିବା ଠିକଣାରେ ଥିବା ମୂଲ୍ୟକୁ ଆକ୍ସେସ୍ କରିବାକୁ କିମ୍ବା ପରିବର୍ତ୍ତନ କରିବାକୁ ଅନୁମତି ଦିଏ।
• ମୁଁ ପଏଣ୍ଟର କାହିଁକି ବ୍ୟବହାର କରିବି? — ପଏଣ୍ଟରଗୁଡ଼ିକ ଆପଣଙ୍କୁ ଫଙ୍କସନ୍ ଗୁଡ଼ିକରେ ମୂଳ ଭେରିଏବଲ୍ ପରିବର୍ତ୍ତନ କରିବାକୁ ଏବଂ ବଡ଼ ଡାଟା ଷ୍ଟ୍ରକ୍ଚର୍ କୁ କପି ନକରି ଶେୟାର କରିବାକୁ ଅନୁମତି ଦିଏ।
• ପଏଣ୍ଟରଗୁଡ଼ିକ nil ହୋଇପାରିବ କି? — ହଁ, ପଏଣ୍ଟରଗୁଡ଼ିକ nil ହୋଇପାରେ, ଯାହାର ଅର୍ଥ ହେଉଛି ସେଗୁଡ଼ିକ କୌଣସି ମେମୋରୀ ଠିକଣାକୁ ସୂଚାଉନାହାଁନ୍ତି।
• ପଏଣ୍ଟର ସହିତ କିଛି ସାଧାରଣ ଭୁଲ କ'ଣ? — ସାଧାରଣ ଭୁଲଗୁଡ଼ିକରେ nil ପଏଣ୍ଟରକୁ ଡିରେଫରେନ୍ସ କରିବା କିମ୍ବା ଆବଶ୍ୟକ ସମୟରେ ପଏଣ୍ଟର ବ୍ୟବହାର କରିବାକୁ ଭୁଲିଯିବା ଅନ୍ତର୍ଭୁକ୍ତ, ଯାହା ଅପ୍ରତ୍ୟାଶିତ ଆଚରଣର କାରଣ ହୋଇଥାଏ।

ଟ୍ୟାଗ୍

#go #programming #tutorial #backend #memorymanagement #pointers #coding #softwaredevelopment