Explore topic-wise InterviewSolutions in Current Affairs.

Go programming provides another data TYPE CALLED interfaces which represents a set of method signatures. STRUCT data type IMPLEMENTS these interfaces to have method definitions for the method signature of the interfaces.

Go programming provides another data type called interfaces which represents a set of method signatures. struct data type implements these interfaces to have method definitions for the method signature of the interfaces.

Type casting is a way to convert a variable from one data type to another data type. For EXAMPLE, if you want to store a long value into a simple INTEGER then you can type cast long to int. You can convert VALUES from one type to another using the cast OPERATOR as following:

type_name(expression)

Type casting is a way to convert a variable from one data type to another data type. For example, if you want to store a long value into a simple integer then you can type cast long to int. You can convert values from one type to another using the cast operator as following:

type_name(expression)

DELETE() function is used to delete an ENTRY from the map. It requires map and corresponding KEY which is to be DELETED.

delete() function is used to delete an entry from the map. It requires map and corresponding key which is to be deleted.

You MUST use MAKE function to create a map.

/* declare a variable, by default map will be nil*/
VAR map_variable map[key_data_type]value_data_type
/* define the map as nil map can not be assigned any VALUE*/
map_variable = make(map[key_data_type]value_data_type)

You must use make function to create a map.

/* declare a variable, by default map will be nil*/
var map_variable map[key_data_type]value_data_type
/* define the map as nil map can not be assigned any value*/
map_variable = make(map[key_data_type]value_data_type)

GO provides another important data type map which maps UNIQUE KEYS to values. A key is an object that you use to retrieve a value at a later date. Given a key and a value, you can strore the value in a Map object. After value is STORED, you can retrieve it by using its key.

Go provides another important data type map which maps unique keys to values. A key is an object that you use to retrieve a value at a later date. Given a key and a value, you can strore the value in a Map object. After value is stored, you can retrieve it by using its key.

The range KEYWORD is used in for loop to iterate over items of an array, SLICE, channel or MAP. With array and slices, it returns the index of the item as integer. With maps, it returns the key of the NEXT key-value pair.

The range keyword is used in for loop to iterate over items of an array, slice, channel or map. With array and slices, it returns the index of the item as integer. With maps, it returns the key of the next key-value pair.

SLICE allows lower-bound and UPPER bound to be SPECIFIED to GET the subslice of it using[lower-bound:upper-bound].

Slice allows lower-bound and upper bound to be specified to get the subslice of it using[lower-bound:upper-bound].

LEN() FUNCTION returns the ELEMENTS presents in the slice where CAP() function returns the capacity of slice as how many elements it can be accomodate.

len() function returns the elements presents in the slice where cap() function returns the capacity of slice as how many elements it can be accomodate.

LEN() function returns the elements presents in the SLICE.

len() function returns the elements presents in the slice.

To DEFINE a slice, you can DECLARE it as an array without specifying SIZE or use make function to CREATE the one.

var numbers []int /* a slice of unspecified size */
/* numbers == []int{0,0,0,0,0}*/
numbers = make([]int,5,5) /* a slice of LENGTH 5 and capacity 5*/

To define a slice, you can declare it as an array without specifying size or use make function to create the one.

var numbers []int /* a slice of unspecified size */
/* numbers == []int{0,0,0,0,0}*/
numbers = make([]int,5,5) /* a slice of length 5 and capacity 5*/

GO Slice is an abstraction over Go Array. As Go Array allows you to define type of variables that can hold several data items of the same kind but it do not PROVIDE any inbuilt METHOD to increase size of it DYNAMICALLY or get a sub-array of its own. Slices covers this limitation. It provides many utility functions required on Array and is widely used in Go PROGRAMMING.

Go Slice is an abstraction over Go Array. As Go Array allows you to define type of variables that can hold several data items of the same kind but it do not provide any inbuilt method to increase size of it dynamically or get a sub-array of its own. Slices covers this limitation. It provides many utility functions required on Array and is widely used in Go programming.

To DEFINE a structure, you must use type and struct statements. The struct statement defines a NEW data type, with more than one MEMBER for your program. type statement BINDS a name with the type which is struct in our CASE.

The format of the struct statement is this −

type struct_variable_type struct {
member definition;
member definition;
...
member definition;
}

To define a structure, you must use type and struct statements. The struct statement defines a new data type, with more than one member for your program. type statement binds a name with the type which is struct in our case.

The format of the struct statement is this −

type struct_variable_type struct {
member definition;
member definition;
...
member definition;
}

STRUCTURE is another user defined data type AVAILABLE in GO programming, which allows you to COMBINE data items of different kinds.

Structure is another user defined data type available in Go programming, which allows you to combine data items of different kinds.

It's a pointer variable which can HOLD the address of another pointer variable. It de-refers twice to point to the data held by the DESIGNATED pointer variable.

var a int
var ptr *int
var pptr **int
a = 3000
ptr = &a
pptr = &ptr
fmt.Printf("Value AVAILABLE at **pptr = %dn", **pptr)
Therefore 'a' can be accessed by **pptr.

It's a pointer variable which can hold the address of another pointer variable. It de-refers twice to point to the data held by the designated pointer variable.

var a int
var ptr *int
var pptr **int
a = 3000
ptr = &a
pptr = &ptr
fmt.Printf("Value available at **pptr = %dn", **pptr)
Therefore 'a' can be accessed by **pptr.

GO compiler assign a Nil value to a pointer variable in case you do not have exact ADDRESS to be assigned. This is DONE at the time of variable declaration. A pointer that is assigned nil is called a nil pointer. The nil pointer is a constant with a value of zero defined in several standard LIBRARIES.

Go compiler assign a Nil value to a pointer variable in case you do not have exact address to be assigned. This is done at the time of variable declaration. A pointer that is assigned nil is called a nil pointer. The nil pointer is a constant with a value of zero defined in several standard libraries.

ARRAY is collection of SIMILAR data ITEMS under a COMMON name.

Array is collection of similar data items under a common name.

goto

goto

A Go program CONSISTS of VARIOUS TOKENS and a token is either a keyword, an identifier, a CONSTANT, a string literal, or a symbol.

A Go program consists of various tokens and a token is either a keyword, an identifier, a constant, a string literal, or a symbol.

Dividing the program in to sub programs (modules/function) to achieve the given task is modular APPROACH. More GENERIC functions definition GIVES the ability to re-use the functions, such as built-in LIBRARY functions.

Dividing the program in to sub programs (modules/function) to achieve the given task is modular approach. More generic functions definition gives the ability to re-use the functions, such as built-in library functions.

DECLARATION associates TYPE to the variable WHEREAS definition gives the value to the variable.

Declaration associates type to the variable whereas definition gives the value to the variable.

The parameters SENT to the FUNCTION at CALLING end are CALLED as actual parameters while at the receiving of the function definition called as FORMAL parameters.

The parameters sent to the function at calling end are called as actual parameters while at the receiving of the function definition called as formal parameters.

The expression appearing on RIGHT side of the assignment operator is called as RVALUE. Rvalue is assigned to LVALUE, which APPEARS on LEFT side of the assignment operator. The lvalue should designate to a variable not a constant.

The expression appearing on right side of the assignment operator is called as rvalue. Rvalue is assigned to lvalue, which appears on left side of the assignment operator. The lvalue should designate to a variable not a constant.

PRINTS the FORMATTED OUTPUT.

Prints the formatted output.

POINTER is INITIALIZED to NIL.

Pointer is initialized to nil.

A GLOBAL variable has DEFAULT VALUE as it corresponding 0 value.

A global variable has default value as it corresponding 0 value.

A LOCAL VARIABLE has DEFAULT value as it corresponding 0 value.

A local variable has default value as it corresponding 0 value.

Go programming language supports SPECIAL TYPES of FUNCTIONS called methods. In method declaration syntax, a "RECEIVER" is present to represent the container of the function. This receiver can be used to call function using "." OPERATOR.

Go programming language supports special types of functions called methods. In method declaration syntax, a "receiver" is present to represent the container of the function. This receiver can be used to call function using "." operator.

FUNCTIONS closure are ANONYMOUS functions and can be USED in DYNAMIC PROGRAMMING.

Functions closure are anonymous functions and can be used in dynamic programming.

GO programming language provides flexibility to CREATE FUNCTIONS on the fly and use them as values. We can SET a variable with a function DEFINITION and use it as parameter to a function.

Go programming language provides flexibility to create functions on the fly and use them as values. We can set a variable with a function definition and use it as parameter to a function.

By default, Go uses call by value to pass arguments. In GENERAL, this means that CODE within a function cannot ALTER the arguments used to call the function while calling max() function used the same METHOD.

By default, Go uses call by value to pass arguments. In general, this means that code within a function cannot alter the arguments used to call the function while calling max() function used the same method.

While calling a function, there are two WAYS that arguments can be PASSED to a function:

• Call by value: This METHOD copies the actual value of an argument into the FORMAL parameter of the function. In this case, changes made to the parameter inside the function have no effect on the argument.
• Call by reference: This method copies the address of an argument into the formal parameter. Inside the function, the address is used to access the actual argument used in the call. This MEANS that changes made to the parameter affect the argument.

While calling a function, there are two ways that arguments can be passed to a function:

A GO function can return MULTIPLE VALUES. For example −

package MAIN
import "fmt"
func SWAP(x, y string) (string, string) {
return y, x
}
func main() {
a, b := swap("Mahesh", "Kumar")
fmt.Println(a, b)
}

A Go function can return multiple values. For example −

package main
import "fmt"
func swap(x, y string) (string, string) {
return y, x
}
func main() {
a, b := swap("Mahesh", "Kumar")
fmt.Println(a, b)
}

The general FORM of a function definition in Go programming language is as follows −

func function_name( [parameter list] ) [return_types]
{
body of the function
}

A function definition in Go programming language consists of a function header and a function body. Here are all the parts of a function −

• func func starts the declaration of a function.
• Function Name − This is the actual name of the function. The function name and the parameter list together constitute the function signature.
• Parameters − A parameter is LIKE a placeholder. When a function is invoked, you pass a value to the parameter. This value is referred to as actual parameter or argument. The parameter list refers to the type, order, and number of the parameters of a function. Parameters are optional; that is, a function may contain no parameters.
• RETURN Type − A function may return a list of values. The return_types is the list of data types of the values the function returns. Some functions PERFORM the desired operations without returning a value. In this case, the return_type is the not required.
• Function Body − The function body contains a collection of statements that define what the function does.

The general form of a function definition in Go programming language is as follows −

func function_name( [parameter list] ) [return_types]
{
body of the function
}

A function definition in Go programming language consists of a function header and a function body. Here are all the parts of a function −

The syntax of a for loop in Go programming language is −

for [CONDITION | ( init; condition; increment ) | RANGE]
{
statement(s);
}

Here is the flow of control in a for loop −

1. if condition is available, then for loop executes as long as condition is true.
2. if for clause that is ( init; condition; increment ) is present then
   
   The init step is executed first, and only once. This step allows you to declare and initialize any loop control variables. You are not required to PUT a statement here, as long as a semicolon appears.
   
   Next, the condition is evaluated. If it is true, the body of the loop is executed. If it is false, the body of the loop does not execute and flow of control JUMPS to the next statement just after the for loop.
   
   After the body of the for loop executes, the flow of control jumps back up to the increment statement. This statement allows you to update any loop control variables. This statement can be LEFT blank, as long as a semicolon appears after the condition.
   
   The condition is now evaluated again. If it is true, the loop executes and the process repeats itself (body of loop, then increment step, and then again condition). After the condition becomes false, the for loop terminates.
   
   
3. if range is available, then for loop executes for each item in the range.

The syntax of a for loop in Go programming language is −

for [condition | ( init; condition; increment ) | Range]
{
statement(s);
}

Here is the flow of control in a for loop −

GOTO TRANSFERS CONTROL to the LABELED STATEMENT.

goto transfers control to the labeled statement.

Continue CAUSES the loop to skip the remainder of its BODY and IMMEDIATELY retest its CONDITION prior to reiterating.

Continue causes the loop to skip the remainder of its body and immediately retest its condition prior to reiterating.

Break TERMINATES the for loop or switch statement and TRANSFERS EXECUTION to the statement IMMEDIATELY following the for loop or switch.

Break terminates the for loop or switch statement and transfers execution to the statement immediately following the for loop or switch.

It's a POINTER variable which can hold the address of a variable.

For EXAMPLE −

var x = 5
var p *int
p = &x
fmt.Printf("x = %d", *p)
Here x can be accessed by *p.

It's a pointer variable which can hold the address of a variable.

For example −

var x = 5
var p *int
p = &x
fmt.Printf("x = %d", *p)
Here x can be accessed by *p.

Following code PRINTS the type of a VARIABLE −

var a, b, C = 3, 4, "FOO"
fmt.Printf("a is of type %Tn", a)

Following code prints the type of a variable −

var a, b, c = 3, 4, "foo"
fmt.Printf("a is of type %Tn", a)

Yes Variables of DIFFERENT types can be declared in one go using type INFERENCE.

var a, b, C = 3, 4, "FOO"

Yes Variables of different types can be declared in one go using type inference.

var a, b, c = 3, 4, "foo"

A DYNAMIC type VARIABLE declaration requires compiler to interpret the type of variable based on value passed to it. Compiler don't NEED a variable to have type STATICALLY as a necessary requirement.

A dynamic type variable declaration requires compiler to interpret the type of variable based on value passed to it. Compiler don't need a variable to have type statically as a necessary requirement.

Static type variable DECLARATION provides assurance to the compiler that there is one variable existing with the GIVEN type and name so that compiler proceed for further compilation WITHOUT needing complete detail about the variable. A variable declaration has its meaning at the time of compilation only, compiler NEEDS actual variable declaration at the time of LINKING of the program.

Static type variable declaration provides assurance to the compiler that there is one variable existing with the given type and name so that compiler proceed for further compilation without needing complete detail about the variable. A variable declaration has its meaning at the time of compilation only, compiler needs actual variable declaration at the time of linking of the program.

Yes! Go is a CASE SENSITIVE programming LANGUAGE.

Yes! Go is a case sensitive programming language.

No SUPPORT for GENERIC PROGRAMMING.

No support for generic programming.

No SUPPORT for POINTER ARITHMETIC.

No support for pointer arithmetic.

No SUPPORT for METHOD OVERLOADING.

No support for method overloading.

No SUPPORT for OPERATOR OVERLOADING.

No support for operator overloading.

No SUPPORT for TYPE INHERITANCE.

No support for type inheritance.

• Support for environment adopting patterns similar to dynamic LANGUAGES. For example type inference (x := 0 is valid declaration of a VARIABLE x of type int).
• Compilation time is fast.
• InBuilt concurrency support: light-weight processes (via GOROUTINES), channels, select statement.
• CONCISENESS, Simplicity, and Safety.
• Support for Interfaces and Type embdding.
• Production of statically linked native BINARIES without external dependencies.

Go is a general-purpose language designed with systems programming in mind.It was initially developed at Google in year 2007 by Robert Griesemer, Rob PIKE, and KEN Thompson. It is strongly and statically typed, provides INBUILT support for garbage collection and supports CONCURRENT programming. Programs are constructed using packages, for efficient management of dependencies. Go programming implementations use a traditional compile and link model to generate executable binaries.

Go is a general-purpose language designed with systems programming in mind.It was initially developed at Google in year 2007 by Robert Griesemer, Rob Pike, and Ken Thompson. It is strongly and statically typed, provides inbuilt support for garbage collection and supports concurrent programming. Programs are constructed using packages, for efficient management of dependencies. Go programming implementations use a traditional compile and link model to generate executable binaries.