Witamy w świecie I.T.
Motto
"Bądź skrybą! Oszczędza ci pracy i chroni przed wszelkimi pracami. Oszczędza ci używania motyki i kilofa … skryba, on kieruje wszystkimi pracami w tej krainie!" -
GoLang V
Operatory i struktury kontrolne
Operatory w Go
Operatory są budulcem każdego języka programowania. W efekcie bez użycia operatorów funkcjonalność języka Go jest niepełna. Operatory pozwalają nam wykonywać wiele działań na operandach. Operatory w języku programowania Go są klasyfikowane na podstawie ich funkcjonalności:
o Operatory arytmetyczne
o Operatorzy relacyjni
o Różni operatorzy
o Operatory bitowe
o Operatorzy przypisania
o Operatory logiczne
Operatory arytmetyczne
W Go są one używane do wykonywania operacji arytmetycznych/matematycznych na operandach:
o Dodawanie: Operator "+" łączy ze sobą dwa operandy. Na przykład x+y.
o Odejmowanie: Operator "-" bierze dwa operandy i odejmuje je. Na przykład x-y.
o Mnożenie: Znak "*" służy do mnożenia dwóch operandów. Na przykład, x*y.
o Dzielenie: Operator "/" dzieli pierwszy operand przez drugi operand. Jako przykład rozważmy x/y.
o Moduł: Kiedy pierwszy operand jest dzielony przez drugi, zwracana jest reszta operatora "%". Na przykład x procent y.
Nota bene: -, +, !, &, * i - są również znane jako operatory jednoargumentowe i mają wyższy priorytet. Ponieważ operatory ++ i -- pochodzą z instrukcji, a nie z wyrażeń; znajdują się poza hierarchią operatorów.
Przykład:
// Program to illustrate the
// use of the arithmetic operators
package main
import "fmt"
func main()
{
x:= 37
y:= 22
// Addition
result1:= x + y
fmt.Printf("Result of x + y = %d", result1)
// Subtraction
result2:= x - y
fmt.Printf("\nResult of x - y = %d", result2)
// Multiplication
result3:= x * y
fmt.Printf("\nResult of x * y = %d", result3)
// Division
result4:= x / y
fmt.Printf("\nResult of x / y = %d", result4)
// Modulus
result5:= x % y
fmt.Printf("\nResult of x %% y = %d", result5)
}
Operatory relacyjne>
Podczas porównywania dwóch wartości stosowane są operatory relacyjne. Przyjrzyjmy się im:
o Operator "==" (równy) określa, czy dwa operandy są równe. W takim przypadku zwraca wartość true. Jeśli nie, zwraca false. 6==6 zwróci na przykład prawdę.
o Operator "!=" określa, czy dwa podane operandy są równe, czy nie. Jeśli tak, zwraca wartość true. Jeśli nie, zwraca false. Jest to logiczny odpowiednik operatora "==". 6!=6 zwróci na przykład fałsz.
o Operator ">" (Większy niż) określa, czy pierwszym argumentem jest większy niż drugi. W takim przypadku zwraca wartość true. Jeśli nie, zwraca fałsz. 7>6 da na przykład prawdę.
o Operator "<" (Mniej niż) określa, czy pierwszy operand jest mniejszy niż drugi. W takim przypadku zwraca wartość true. Jeśli nie, zwraca false. Na przykład 6<4 zwróci fałsz.
o Operator "?" (Większy niż równy) określa, czy pierwszy operand jest większy lub równy drugiemu operandowi, a następnie zwraca prawdę. Jeśli nie, zwraca false. 6?6 zwróci na przykład prawdę. o Operator "?" (najmniejszy niż równy) określa, czy pierwszy operand jest mniejszy lub równy drugiemu operandowi, a następnie zwraca wartość true. Jeśli nie, zwraca false. Na przykład 6?6 również zwróci wartość true.
Przykład:
// Program to illustrate
// the use of relational operators
package main
import "fmt"
func main() {
x:= 38
y:= 25
// '=='(Equal To)
result1:= x == y
fmt.Println(result1)
// '!='(Not Equal To)
result2:= x != y
fmt.Println(result2)
// '<'(Less Than)
result3:= x < y
fmt.Println(result3)
// '>'(Greater Than)
result4:= x > y
fmt.Println(result4)
// '>='(Greater Than Equal To)
result5:= x >= y
fmt.Println(result5)
// '<='(Less Than Equal To)
result6:= x <= y
fmt.Println(result6)
}
Operatory logiczne
Służą do zintegrowania dwóch lub więcej warunków/ograniczeń lub uzupełnienia oceny pierwotnego warunku.
o Logiczne AND: Operator && zwraca wartość true, gdy spełnione są oba rozważane warunki. Jeśli nie, zwraca false. x && y, na przykład, zwraca wartość true, gdy zarówno x, jak i y są prawdziwe (tj. niezerowe).
o Logiczne LUB: Gdy spełniony jest jeden lub oba wymagania, operator "||" zwraca wartość true. Jeśli nie, zwraca false. Na przykład x || y zwraca true, jeśli x lub y jest prawdziwe (tj. niezerowe). Oczywiście zwraca wartość true, jeśli zarówno x, jak i y są prawdziwe.
o Logiczne NIE: Jeśli dany warunek jest spełniony, operator "!" zwraca prawdę. Jeśli nie, zwraca false. !x, na przykład, zwraca wartość true, jeśli a jest fałszywe, czyli gdy x=0.
Przykład:
// Program to illustrate
//the use of logical operators
package main
import "fmt"
func main() {
var x int = 26
var y int = 65
if(x!=y && x<=y){
fmt.Println("True")
}
if(x!=y || x<=y){
fmt.Println("True")
}
if(!(x==y)){
fmt.Println("True")
}
}
Operatory bitowe
W języku programowania Go 6 operatorów bitowych działa na poziomie bitowym lub wykonuje operacje bit po bicie. Operatory bitowe to:
o & (bitowe AND): Pobiera dwa operandy i wykonuje operację AND na każdym bicie dwóch liczb. AND zwraca 1 tylko wtedy, gdy oba bity są równe 1.
o | (bitowe LUB): Pobiera dwa operandy i wykonuje LUB na każdym bicie dwóch liczb całkowitych. LUB zwraca wartość 1, jeśli jeden z dwóch bitów ma wartość 1.
o ^ (bitowe XOR): Pobiera dwa operandy i wykonuje XOR na każdym bicie dwóch liczb. Jeśli dwa bity są różne, wynikiem operacji XOR jest 1.
o << (przesunięcie w lewo): przyjmuje dwie liczby całkowite, przesuwa w lewo bity pierwszego operandu, a drugi operand określa liczbę przesunąć pozycji.
o >> (przesunięcie w prawo): pobiera dwie liczby, przesuwa bity pierwszego operandu w prawo, a liczba miejsc do przesunięcia jest określana przez drugi operand.
o &^ (AND NOT): Jest to prosty operator.
Przykład:
// Program to illustrate
// the use of bitwise operators
package main
import "fmt"
func main() {
x:= 34
y:= 20
// & (bitwise AND)
result1:= x & y
fmt.Printf("Result of x & y = %d", result1)
// | (bitwise OR)
result2:= x | y
fmt.Printf("\nResult of p | q = %d", result2)
// ^ (bitwise XOR)
result3:= p ^ q
fmt.Printf("\nResult of x ^ y = %d", result3)
// << (left shift)
result4:= x << 1
fmt.Printf("\nResult of x << 1 = %d", result4)
// >> (right shift)
result5:= x >> 1
fmt.Printf("\nResult of x >> 1 = %d", result5)
// &^ (AND NOT)
result6:= x &^ y
fmt.Printf("\nResult of x &^ y = %d", result6)
}
Operatory przypisania
Podczas przypisywania wartości do zmiennej stosowane są operatory przypisania. Lewy operand operatora przypisania jest zmienną, a prawy operand operatora przypisania jest wartością. Wartość po prawej stronie musi mieć ten sam typ danych co zmienna po lewej stronie, w przeciwnym razie kompilator zgłosi błąd. Oto przykłady operatorów przypisania:
o "=" (Proste przypisanie): Najbardziej podstawowy operator przypisania. Wartość po prawej stronie jest przypisywana do zmiennej po lewej stronie za pomocą tego operatora.
o "+=" (Dodaj przypisanie): Kombinacja operatorów "+" i "=". Ten operator najpierw dodaje zmienną po lewej stronie bieżącej wartości do prawej, a następnie przypisuje wynik do zmiennej po lewej stronie.
o "-=" (odejmowanie przypisania): Kombinacja operatorów "?" i "=". Ten operator odejmuje bieżącą wartość zmiennej po lewej stronie od prawej, a następnie przypisuje wynik zmiennej po lewej stronie.
o "*=" (przypisanie mnożenia): Kombinacja operatorów "*" i "=". Ten operator najpierw mnoży zmienną po lewej przez prawą, a następnie przypisuje wynik do lewej zmiennej.
o "/=" (przypisanie dzielenia): Kombinacja operatorów "/" i "=". Ten operator dzieli zmienną po lewej stronie bieżącą wartość przez wartość po prawej stronie, a następnie przypisuje wynik zmiennej po lewej stronie.
o "%=" (przypisanie modułu): Ten operator łączy w sobie operatory "%" i "=". Operator ten mnoży aktualną wartość zmiennej po lewej przez prawą, a następnie przypisuje wynik do lewej zmiennej.
o "&=" (przypisanie bitowe AND): kombinacja "&" i "=" operatorzy. Ten operator "Bitwise AND" bieżąca wartość do lewej zmiennej do prawej przed przypisaniem wyniku do lewej zmiennej.
o "=" (bitowe wyłączne LUB): Kombinacja operatorów "=" i "=". Ten operator "Bitwise Exclusive OR" przestawia bieżącą wartość lewej zmiennej na prawą przed przypisaniem wyniku do lewej zmiennej.
o "|=" (bitowo włącznie OR): Kombinacja operatorów "|" i "=". Ten operator "Bitwise Inclusive OR" przestawia bieżącą wartość lewej zmiennej na prawą przed przypisaniem wyniku do lewej zmiennej.
Przykład:
// Program to illustrate
// the use of assignment operators
package main
import "fmt"
func main()
{
var x int = 49
var y int = 54
// "="(Simple Assignment)
x = y
fmt.Println(p)
// "+="(Add Assignment)
x += y
fmt.Println(x)
//"-="(Subtract Assignment)
x-=y
fmt.Println(x)
// "*="(Multiply Assignment)
x*= y
fmt.Println(x)
// "/="(Division Assignment)
x /= y
fmt.Println(x)
// "%="(Modulus Assignment)
x %= y
fmt.Println(x)
}
Różne operatorzy
o &: Ten operator zwraca adres zmiennej.
o *: Ten operator zwraca wskaźnik do zmiennej.
o <-: Otrzymano nazwę tego operatora. Służy do pobierania wartości z kanału.
Przykład:
// Program to illustrate
// the use of Misc Operators
package main
import "fmt"
func main() {
x := 6
// Using address of operator(&) and
// pointer indirection(*) operator
y := &x
fmt.Println(*y)
*y = 7
fmt.Println(x)
}
INSTRUKCJE STERUJĄCE
Programista musi zdefiniować jeden lub więcej warunków, które mają być ocenione lub przetestowane przez program, instrukcję lub instrukcje, które zostaną wykonane, jeśli warunek zostanie uznany za prawdziwy, oraz opcjonalnie dalsze instrukcje, które zostaną wykonane, jeśli warunek zostanie uznany za fałszywy. Poniżej przedstawiono ogólną formę wspólnych ram podejmowania decyzji obecnych w większości języków programowania.
Język programowania Go obsługuje następujące instrukcje decyzyjne.
Nr: instrukcja i opis
1: instrukcja if: Po wyrażeniu boolowskim następuje jedna lub więcej instrukcji w instrukcji if.
2 : instrukcja if...else : Gdy wyrażenie boolowskie jest fałszywe, po instrukcji if następuje opcjonalna instrukcja else.
3 : zagnieżdżone instrukcje if : Instrukcja if lub else if może być używana wewnątrz innej instrukcji if lub else if.
4 : instrukcja switch : instrukcja switch sprawdza zmienną pod kątem równości względem zbioru wartości.
5 : instrukcja select : instrukcja select jest podobna do instrukcji switch; jednak opisy przypadków odnoszą się do komunikacji kanałowej.
Instrukcja if
Jest to najprostsze stwierdzenie decyzyjne. Służy do decydowania, czy określona instrukcja lub blok instrukcji zostanie wykonany, tj. jeśli dany warunek jest prawdziwy, to blok instrukcji zostanie wykonany, w przeciwnym razie nie.
Składnia:
if (warunek)
{
// Instrukcja do wykonania, jeśli warunek jest prawdziwy
}
Przykład :
// Program to illustrate
//the use of if statement
package main
import "fmt"
func main() {
// taking local variable
var v int = 800
// using the if statement for
// checking condition
if(v < 2000) {
// print following if
// condition evaluates to true
fmt.Printf("v is less than 2000\n")
}
fmt.Printf("Value of v is : %d\n", v)
}
Instrukcja if
else
Instrukcja if sama w sobie informuje nas, że warunek jest prawdziwy, zostanie wykonany blok instrukcji; jeśli warunek jest fałszywy, blok instrukcji nie zostanie wykonany. Ale co, jeśli warunek jest fałszywy i chcemy zrobić coś innego? W tym momencie pojawia się instrukcja else. Gdy warunek jest fałszywy, możemy użyć instrukcji else w połączeniu z instrukcją if, aby uruchomić blok kodu.
Składnia:
if (warunek)
{
// Wykonuje ten blok if
// warunek jest prawdziwy
} w przeciwnym razie {
// Wykonuje ten blok if
// warunek jest fałszywy
}
Przykład :
// Program to illustrate
// the use of if...else statement
package main
import "fmt"
func main() {
// taking a local variable
var v int = 2400
// using the if statement for
// checking condition
if(v < 2000) {
// print following if
// the condition evaluates to true
fmt.Printf("v is less than 2000\n")
} else {
// print following if
// the condition evaluates to true
fmt.Printf("v is greater than 2000\n")
}
}
Zagnieżdżona instrukcja if
W Go zagnieżdżone if jest instrukcją if, która jest celem innego wyrażenia if lub else. Instrukcja if zagnieżdżona w innej instrukcji if jest nazywana zagnieżdżoną instrukcją if. Tak, możemy zagnieżdżać instrukcje if w instrukcjach if w GoLang. Innymi słowy, możemy zagnieździć instrukcję if w innej instrukcji if.
Składnia:
if (condition1) {
// Executes when the condition1 is true
if (condition2) {
// Executes when the condition2 is true
}
}
Przykład :
// Program to illustrate
// the use of nested if statement
package main
import "fmt"
func main() {
// taking the two local variable
var v1 int = 500
var v2 int = 800
// using if statement
if( v1 == 600 ) {
// if condition is true then
// check the following
if( v2 == 800 ) {
// if the condition is true
// then display following
fmt.Printf("Value of v1 is 500 and v2 is
800\n" );
}
}
}
Użytkownik może tutaj wybierać spośród wielu alternatyw. Instrukcje if są wykonywane w podanej kolejności. Gdy spełniony jest jeden z warunków, wykonywana jest instrukcja związana z tym if; reszta drabiny jest pomijana. Jeśli żadne z wymagań nie jest spełnione, wykonywana jest ostatnia instrukcja else.
Ważne notatki:
o Instrukcja if może mieć wartość zero lub jeden i musi wystąpić po każdej innej instrukcji if.
o Instrukcja else if w instrukcji if może zawierać od zera do wielu innych instrukcji if i musi wystąpić przed klauzulą else.
o Jeśli instrukcja else if powiedzie się, nie ma potrzeby wypróbowywania żadnej z pozostałych instrukcji else if lub else.
Składnia:
if(condition_1) {
// this block will execute when the
condition_1 is true
} else if(condition_2) {
// this block will execute when the condition2
is true
}
.
else {
// this block will execute when none
// of condition is true
}
Przykład:
// Program to illustrate
// the use of if..else..if ladder
package main
import "fmt"
func main() {
// taking a local variable
var v1 int = 800
// checking condition
if(v1 == 120) {
// if condition is true then
// display following */
fmt.Printf("Value of v1 is 120\n")
} else if(v1 == 250) {
fmt.Printf("Value of a is 250\n")
} else if(v1 == 310) {
fmt.Printf("Value of a is 310\n")
} else {
// if none of the conditions is true
fmt.Printf("None of values is matching\n")
}
}
Przejdź do pętli GoLang
Język programowania Go ma tylko jedną pętlę, którą jest pętla for. Pętla for jest formą struktury kontroli powtórzeń, która pozwala nam zaprojektować pętlę, która zostanie wykonana określoną liczbę razy. Ta pętla for może być używana na kilka sposobów w języku programowania Go, w tym:
1. Jak najbardziej podstawowa pętla for: jest porównywalna z tym, co widzimy w innych językach programowania, takich jak C, C++, C#, Java itp.
Składnia:
for initialization; condition; post{
// statement
}
Tutaj instrukcja inicjalizacji jest opcjonalna i jest uruchamiana przed rozpoczęciem pętli for. Instrukcja inicjalizacji jest zawsze zawarta w instrukcji podstawowej, takiej jak deklaracje zmiennych, instrukcje inkrementacji lub przypisania lub wywołania funkcji. Instrukcja warunku zawiera wyrażenie logiczne oceniane na początku każdej iteracji pętli. Pętla jest wykonywana, jeśli wartość instrukcji warunkowej jest prawdziwa. Instrukcja post jest wykonywana po treści pętli for. Po oświadczeniu post, oświadczenie warunku jest ponownie oceniane; jeśli wartość instrukcji warunkowej jest fałszywa, pętla zostaje zakończona.
Przykład:
/ Program to illustrate
// the use of simple for loop
package main
import "fmt"
// the main function
func main() {
// for loop
// This loop starts when x = 0
// executes till x<4 condition is true
// post statement is x++
for x := 0; x < 4; x++{
fmt.Printf("helloeveryone\n")
}
}
2. Pętla for jako pętla nieskończona: Usuwając wszystkie trzy wyrażenia z pętli for, pętla for może być wykorzystana jako pętla nieskończona. Gdy użytkownik nie umieści instrukcji warunku w pętli for, oznacza to, że instrukcja warunku jest prawdziwa, a pętla wchodzi w pętlę nieskończoną.
Składnia:
for
{
// (Instrukcje)
}
Przykład:
// Program to illustrate
// the use of an infinite loop
package main
import "fmt"
// the main function
func main() {
// infinite loop
for {
fmt.Printf("Helloeveryone\n")
}
}
3. Pętla while for: Pętla for może być również używana jako pętla while. Pętla ta jest powtarzana aż do spełnienia określonego warunku. Pętla kończy się, gdy wartość podanego warunku jest fałszywa.
Składnia:
for warunek {
// instrukcje
}
Przykład:
/ Program to illustrate
// for loop as while Loop
package main
import "fmt"
// the main function
func main() {
// while loop for loop executes till
// x < 3 condition is true
x:= 0
for x < 3 {
x += 2
}
fmt.Println(x)
}
4. Prosty zakres w pętli for: Zakres może być również użyty w pętli.
Składnia:
for x, y:= zakres zmiennej{
// instrukcje
}
Tutaj zmienne x i y są miejscem przechowywania wartości iteracji. Są one czasami określane jako zmienne iteracyjne. Druga zmienna, y, nie jest wymagana. Przed rozpoczęciem pętli wyrażenie zakresu jest oceniane raz.
Przykład:
// Program to illustrate
// the use of simple range loop
package main
import "fmt"
// the main function
func main() {
// Here rvariable is array
rvariable:= []string{"HEW", "Hello",
"Helloeveryoneworld"}
// x and y stores the value of rvariable
// x store index number of individual string
and
// y store individual string of the given
array
for x, y:= range rvariable {
fmt.Println(x, y)
}
}
5. Używanie pętli for dla napisów: Pętla for może iterować po punkcie kodowym łańcucha Unicode .
Składnia:
for index chr:= zakres str{
// instrukcje}
W tym przypadku indeks jest zmienną przechowującą pierwszy bajt punktu kodowego zakodowanego w UTF-8, chr jest zmienną przechowującą znaki podanego ciągu, a str jest ciągiem.
Przykład:
// Program to illustrate
// the use for loop using string
package main
import "fmt"
// the main function
func main() {
// String as range in the for loop
for x, y:= range "XxyCd" {
fmt.Printf("Index number of %U is %d\n",
y, x)
}
}
6. Dla map: Pętla for może przechodzić przez parę klucz i wartość mapy.
Składnia:
for klucz, wartość := zakres map {
// instrukcje
}
Przykład:
// Program to illustrate
// the use for loop using maps
package main
import "fmt"
// the main function
func main() {
// using the maps
mmap := map[int]string{
22:"Peeks",
33:"POP",
44:"PeeksofPeeks",
}
for key, value:= range mmap {
fmt.Println(key, value)
}
}
7. For channel: Pętla for może iterować po kolejnych danych przesyłanych w kanale, aż kanał zostanie zamknięty.
Składnia:
for item := range Chnl {
// statement(s)
}
Przykład:
// program to illustrate
// the use for loop using channel
package main
import "fmt"
// the main function
func main() {
// using the channel
chnl := make(chan int)
go func(){
chnl <- 1000
chnl <- 10000
chnl <- 100000
chnl <- 1000000
close(chnl)
}()
for x:= range chnl {
fmt.Println(x)
}
}
Ważne notatki:
o Nawiasy nie obejmują trzech instrukcji pętli for.
o Pętla wymaga nawiasów klamrowych.
o Nawias otwierający i instrukcja post powinny znajdować się w tej samej linii.
o Jeśli tablica, łańcuch, wycinek lub mapa są puste, pętla for nie zgłasza błędu i kontynuuje swój przebieg. Innymi słowy, jeśli tablica, łańcuch, wycinek lub mapa mają wartość zero, liczba iteracji pętli for wynosi zero.
Instrukcja switch Go
Instrukcja switch jest przykładem wielokierunkowej instrukcji rozgałęzienia. Oferuje efektywną metodę przenoszenia wykonania do różnych obszarów kodu w zależności od wartości wyrażenia. Język programowania Go pozwala na dwa rodzaje instrukcji switch:
o Przełącznik ekspresji
o Przełącznik typu
Wyrażenie switch
Wyrażenie switch jest analogiczne do instrukcji switch w C, C++ i Javie. Pozwala nam efektywnie kierować wykonanie do różnych obszarów kodu w oparciu o wartość wyrażenia.
Składnia:
switch optstatement; optexpression{
case expression1: Statement
case expression2: Statement
.
.
default: Statement
}
Ważne notatki:
o W przełączniku wyrażeń zarówno optstatement, jak i optexpression są wyrażeniami opcjonalnymi.
o Jeśli występują zarówno optstatement, jak i optexpression, należy je rozdzielić średnikiem (;).
o Jeśli w przełączniku nie ma wyrażenia, kompilator zakłada, że wyrażenie jest prawdziwe.
o Instrukcja opcjonalna, często znana jako optstatement, zawiera podstawowe instrukcje, takie jak deklaracje zmiennych, instrukcje przyrostu lub przypisania, wywołania funkcji itp.
o Jeśli zmienna pojawia się w instrukcji opcjonalnej, jej zakres jest ograniczony do tej instrukcji switch.
o Nie ma instrukcji break w instrukcji case i default instrukcji switch. Możemy jednak użyć instrukcji break i fallthrough, jeśli wymaga tego nasza aplikacja.
o W instrukcji switch instrukcja default jest opcjonalna.
o Sprawa może mieć wiele wartości oddzielonych przecinkiem (,).
o Jeśli przypadek nie zawiera wyrażenia, kompilator zakłada, że wyrażenie jest prawdziwe.
Pierwszy przykład:
// Program to illustrate
// the concept of Expression switch statement
package main
import "fmt"
func main() {
// the switch statement with both
// optional statement, i.e, day:=4
// and the expression, i.e, day
switch day:=5; day{
case 1:
fmt.Println("Sunday")
case 2:
fmt.Println("Monday")
case 3:
fmt.Println("Tuesday")
case 4:
fmt.Println("Wednesday")
case 5:
fmt.Println("Thursday")
case 6:
fmt.Println("Friday")
case 7:
fmt.Println("Saturday")
default:
fmt.Println("Invalid")
}
}
Drugi przykład :
// Program to illustrate
// the concept of Expression switch statement
package main
import "fmt"
func main() {
var value int = 3
// Switch statement without an
// optional statement and expression
switch {
case value == 1:
fmt.Println("Hey")
case value == 2:
fmt.Println("Hello")
case value == 3:
fmt.Println("Namstae")
default:
fmt.Println("Invalid")
}
}
Trzeci przykład:
// Program to illustrate
// the concept of Expression switch statement
package main
import "fmt"
func main() {
var value string = "four"
// Switch statement without the default
statement
// Multiple values in the case statement
switch value {
case "one":
fmt.Println("C")
case "two", "three":
fmt.Println("C#")
case "four", "five", "six":
fmt.Println("Go")
}
}
Przełącznik typu
Podczas porównywania typów stosowany jest przełącznik typu. Przypadek w tym przełączniku obejmuje typ, który będzie porównywany z typem w wyrażeniu przełącznika.
Składnia :
switch optstatement; typeswitchexpression{
case typelist 1: Statement
case typelist 2: Statement
.
.
default: Statement
}
Ważne notatki:
o Instrukcja opcjonalna, w skrócie optstatement, jest porównywalna z wyrażeniem switch.
o Sprawa może mieć wiele wartości oddzielonych przecinkiem (,).
o Instrukcje case i default w instrukcji typu switch nie zawierają instrukcji break. Możemy jednak użyć instrukcji break i fallthrough, jeśli wymaga tego nasza aplikacja.
o W instrukcji typu switch instrukcja default jest opcjonalna.
o Typeswitchexpression jest wyrażeniem, które w konsekwencji tworzy typ.
o Jeśli wyrażenie jest przypisane do zmiennej w typeswitchexpression za pomocą operatora :=, typ tej zmiennej jest określany przez typ zawarty w klauzuli case. Jeśli klauzula case zawiera dwa lub więcej typów, typem zmiennej jest typ, w którym została ona wygenerowana w typeswitchexpression.
Przykład:
// Program to illustrate
// the concept of Type switch statement
package main
import "fmt"
func main() {
var value interface{}
switch x:= value.(type) {
case bool:
fmt.Println("The value is of boolean type")
case float64:
fmt.Println("The value is of float64 type")
case int:
fmt.Println("value is of int type")
default:
fmt.Printf("value is of type: %T", x)
}
}
GoLang VII
Funkcje i rekurencja
Przejdź do FUNKCJE JĘZYKOWE
Funkcje to często bloki kodu lub instrukcje w programie, które umożliwiają użytkownikowi ponowne użycie tego samego kodu, oszczędzając pamięć, oszczędzając czas i, co najważniejsze, poprawiając czytelność kodu. Funkcja jest w istocie zbiorem instrukcji, które wykonują dane zadanie i dostarczają wynik wywołującemu. Funkcja może również wykonać określone zadanie bez zwracania żadnych wyników.
Deklaracja funkcji
Deklaracja funkcji jest metodą konstruowania funkcji.
Składnia:
func nazwa-funkcji(Parameterlist)(Returntype){
// ciało funkcji
}
W deklaracji funkcji znajdują się:
o func: Jest to słowo kluczowe w języku programowania Go używane do definiowania funkcji.
o nazwa-funkcji: To jest nazwa funkcji.
o Lista parametrów: Określa nazwę i typ argumentów funkcji.
o Returntype: Ten parametr jest opcjonalny i zawiera typy wartości zwracanych przez funkcję. Jeśli zamierzamy użyć zwracanego typu w naszej funkcji będziemy musieli dołączyć instrukcję return
Wywoływanie funkcji
Kiedy użytkownik chce wykonać funkcję, wywołuje ją lub wywołuje. Aby skorzystać z możliwości funkcji, należy ją wywołać. Jak pokazano w poniższym przykładzie, mamy funkcję o nazwie area() z dwoma parametrami. Teraz nazywamy tę funkcję po imieniu w funkcji main, tj. area(13, 11) z dwoma parametrami.
Przykład:
// Program to illustrate
// the use of function
package main
import "fmt"
// area() is used to find
// area of rectangle
// area() function two parameters,
// i.e, length and width
func area(length, width int)int{
arr := length* width
return arr
}
// the main function
func main() {
// Display area of the rectangle
// with the method calling
fmt.Printf("Area of rectangle is : %d",
area(13, 11))
}
Argumenty funkcji
Argumenty dostarczane do funkcji nazywane są w Go parametrami rzeczywistymi, podczas gdy parametry odbierane przez funkcję nazywane są parametrami formalnymi.
Uwaga: język Go domyślnie używa techniki call by value aby przekazać parametry w funkcji.
Język programowania Go udostępnia dwie metody przekazywania parametrów do naszej funkcji.
Wywołanie według wartości
W ten sposób przekazywania parametrów wartości parametrów rzeczywistych są przekazywane do parametrów formalnych funkcji, a dwa rodzaje parametrów są przechowywane w różnych miejscach pamięci. W rezultacie wszelkie zmiany dokonane w obrębie funkcji nie znajdują odzwierciedlenia w rzeczywistych argumentach wywołujących.
Przykład:
// Program to illustrate
// the concept of call by value
package main
import "fmt"
// function which swap the values
func swap(x, y int)int{
var o int
o= x
x=y
y=o
return o
}
// the main function
func main() {
var a int = 20
var b int = 30
fmt.Printf("a = %d and b = %d", a, b)
// call by values
swap(a, b)
fmt.Printf("\n a = %d and b = %d",a, b)
}
Wywołanie przez referencje
Ponieważ zarówno parametry rzeczywiste, jak i parametry formalne odnoszą się do identycznych lokalizacji, wszelkie zmiany dokonane w ramach funkcji mają odzwierciedlenie w rzeczywistych parametrach wywołującego.
Przykład:
// Program to illustrate
// the concept of call by reference
package main
import "fmt"
// function which swap the values
func swap(x, y *int)int{
var o int
o = *x
*x = *y
*y = o
return o
}
// the main function
func main() {
var a int = 20
var b int = 10
fmt.Printf("a = %d and b = %d", a, b)
// call by reference
swap(&a, &b)
fmt.Printf("\n a = %d and b = %d", a, b)
}
FUNKCJA ZWRACAJĄCA WIELE WARTOŚCI
Instrukcja return w języku programowania Go pozwala nam zwrócić wiele wartości z funkcji. Innymi słowy, pojedyncza instrukcja return w funkcji może zwrócić wiele wartości. Zwracane wartości są tego samego typu, co parametry podane na liście parametrów.
Składnia:
func functionname(parameterlist)(returntypelist){
// code…
}
Przykład:// Program to illustrate how a
// function return the multiple values
package main
import "fmt"
// myfunc return 3 values of int type
func myfunc(x, y int)(int, int, int ){
return x - y, x * y, x + y
}
// the main Method
func main() {
// return values are assigned into different
variables
var myvar1, myvar2, myvar3 = myfunc(4, 2)
// Display-values
fmt.Printf("The Result is: %d", myvar1 )
fmt.Printf("\nThe Result is: %d", myvar2)
fmt.Printf("\nThe Result is: %d", myvar3)
}
Nadawanie nazw zwracanym wartościom
Zwracanym wartościom w języku programowania Go można nadać nazwy. Takich nazw zmiennych możemy używać również w naszym kodzie. Nie jest wymagane dołączanie instrukcji return do tych identyfikatorów, ponieważ kompilator Go rozpozna, że te zmienne muszą zostać odesłane. Nagi powrót to nazwa nadana tej formie zwrotu. Zastosowanie samego zwrotu minimalizuje redundancję w naszym programie.
Składnia:
func functionname(para1, para2 int)(name1 int, name2 int){
// code
}
name1 i name2 to nazwy zwracanych wartości, podczas gdy para1 i para2 to argumenty funkcji.
Przykład:
// illustrate how to give names to return values
package main
import "fmt"
// myfunc return 2 values of the int type
// here, return value name
// is rectangle & square
func myfunc(x, y int)( rectangle int, square int )
{
rectangle = x*y
square = x*x
return
}
func main() {
// The return values are assigned into the two
different variables
var area1, area2 = myfunc(4, 8)
// Display the values
fmt.Printf("Area of the rectangle is: %d",
area1 )
fmt.Printf("\nThe Area of the square is: %d",
area2)
}
FUNKCJE ZMIENNE
Funkcja wariadyczna to taka, która jest wywoływana ze zmienną liczbą parametrów. Innymi słowy, funkcja variadic akceptuje zero lub więcej danych wejściowych od użytkownika. fmt. Printf jest przykładem funkcji wariadycznej; wymaga jednego stałego argumentu na początku i może zaakceptować dowolną liczbę argumentów później.
Ważne notatki:
o Ostatni typ parametru w deklaracji funkcji variadic jest poprzedzony wielokropkiem, czyli (
). Oznacza to, że funkcja może być wywoływana z dowolną liczbą tego rodzaju parametrów.
Składnia:
function function-name(para1, para2...type)type{
// code
}
o W ramach funkcji
typ działa podobnie do plasterka. Załóżmy, że mamy sygnaturę funkcji, taką jak add(b…nt)int, a argument a jest typu []int.
o W funkcji variadic możesz również podać istniejący wycinek. Jak pokazano w drugim przykładzie, wysyłamy wycinek całej tablicy do funkcji, aby to zrobić.
o Gdy do funkcji variadic nie są przekazywane żadne argumenty, wycinek w obrębie funkcji jest równy zero.
o Funkcje wariacyjne są powszechnie używane do formatowania ciągów znaków.
o W metodzie variadycznej można również przekazać kilka przekrojów.
o Parametry Variadic nie mogą być używane jako wartości zwracane, chociaż mogą być zwracane jako wycinki.
Pierwszy przykład:
// Program to illustrate
// the concept of variadic function
package main
import(
"fmt"
"strings"
)
// Variadic function to join the strings
func joinstr(element...string)string{
return strings.Join(element, "-")
}
func main() {
// zero argument
fmt.Println(joinstr())
// the multiple arguments
fmt.Println(joinstr("Hello", "HEW"))
fmt.Println(joinstr("Hello", "Everyone",
"World"))
fmt.Println(joinstr("H", "E", "L", "L", "O"))
}
Drugi przykład:
// Program to illustrate
// the concept of variadic function
package main
import(
"fmt"
"strings"
)
// The Variadic function to join strings
func joinstr(element...string)string{
return strings.Join(element, "-")
}
func main() {
// pass a slice in the variadic function
element:= []string{"hello", "FROM", "world"}
fmt.Println(joinstr(element…))
}
Kiedy korzystamy z funkcji variadic:
o Funkcja variadic służy do przekazywania wycinka w funkcji.
o Używamy funkcji zmiennej, gdy nie znamy liczby parametrów.
o Kiedy używamy funkcji zmiennej w twoim oprogramowaniu, poprawia się czytelność.
Funkcje anonimowe
Funkcja anonimowa jest cechą języka programowania Go. Funkcja anonimowa nie ma nazwy, gdy musimy napisać funkcję wbudowaną. Anonimowa funkcja w Go może skonstruować zamknięcie. Funkcja anonimowa jest również określana jako literał funkcji.
Składnia:
func(parameter-list)(returntype){
// code
// Use the return statement if returntype are
given
// if returntype is not given, then do not
// use the return statement
return
}()
Przykład:
// Program to illustrate how
// to create anonymous function
package main
import "fmt"
func main() {
// the anonymous function
func(){
fmt.Println("Welcome to World")
}()
}
Ważne notatki:
o Anonimową funkcję można przypisać do zmiennej w języku programowania Go. Kiedy przypisujemy funkcję do zmiennej, typ zmiennej zmienia się na funkcję i możemy to nazwać wywołaniem funkcji, jak pokazano w poniższym przykładzie:
// Program to illustrate
// the use of an anonymous function
package main
import "fmt"
func main() {
// Assigning anonymous
// function to variable
value := func(){
fmt.Println("Welcome to World")
}
value()
}
o W funkcji anonimowej możemy również przekazywać parametry.
Przykład:
// Program to pass arguments
// in anonymous function
package main
import "fmt"func main() {
// Passing arguments in the anonymous function
func(ele string){
fmt.Println(ele)
}("Helloeveryone")
}
o Funkcja anonimowa może również zostać przekazana jako argument do innej funkcji.
Przykład:
// Program to pass an anonymous
// function as an argument into
// the other function
package main
import "fmt"
// Passing anonymous function
// as argument
func XYZ(i func(a, b string)string){
fmt.Println(i ("Hello", "for"))
}
func main() {
value:= func(a, b string) string{
return a + b + "Hello"
}
XYZ(value)
}
o Inna funkcja może również zwrócić funkcję anonimową.
Przykład:
// Program to illustrate
// the use of anonymous function
package main
import "fmt"
// Returning the anonymous function
func XYZ() func(a, b string) string{
myf := func(a, b string)string{
return a + b + "Everyone"
} return myf
}func main() {
value := XYZ()
fmt.Println(value("Hello ", "to "))
}
Funkcje GoLang main() i init().
Język programowania Go rezerwuje dwie funkcje do celów specjalnych:
main() i init().
Funkcja main()
Główny pakiet w Go to specjalny pakiet używany z aplikacjami wykonywalnymi, w tym z metodą main(). Funkcja main() jest unikalną funkcją, która służy jako punkt wejścia programu wykonywalnego. Nie przyjmuje ani nie zwraca żadnych argumentów. Go wywołuje metodę main() automatycznie, więc nie ma potrzeby jej bezpośredniego wywoływania, a każdy program wykonywalny musi mieć jeden pakiet główny i funkcję main().
Przykład:
// Program to illustrate
// the concept of main() function
// Declaration of main package
package main
// Importing packages
import (
"fmt"
"sort"
"strings"
"time"
)
// Main function
func main() {
// Sorting the given slice
st := []int{335, 79, 113, 14, 86, 12, 467, 9}
sort.Ints(st)
fmt.Println("Sorted slice: ", st)
// Finding the index
fmt.Println("Index value: ", strings.
Index("Hello", "ks"))
// Finding the time
fmt.Println("Time: ", time.Now().Unix())
}
Funkcja init()
Funkcja init(), podobnie jak funkcja main, nie przyjmuje żadnych argumentów i nic nie zwraca. Ta funkcja jest zawarta w każdym pakiecie i jest wywoływana, gdy pakiet jest ładowany po raz pierwszy. Ta funkcja jest zdefiniowana niejawnie, więc nie możemy uzyskać do niej dostępu w innym miejscu. Możemy skonstruować wiele funkcji init() w tej samej aplikacji i będą one wykonywane w kolejności, w jakiej zostały utworzone. Funkcje init() mogą być umieszczone w dowolnym miejscu programu i są wywoływane w leksykalnej kolejności nazw plików (porządek alfabetyczny). Dopuszczalne jest dołączanie instrukcji, jeśli używana jest funkcja init(), ale należy pamiętać, że metoda init() jest wykonywana przed wywołaniem funkcji main(); dlatego nie jest zależny od funkcji main(). Głównym celem funkcji init() jest inicjalizacja zmiennych globalnych, których nie można zainicjować w kontekście globalnym.
Przykład:
// Program to illustrate
// the concept of init() function
// Declaration of main package
package main
// the importing package
import "fmt"
// the multiple init() function
func init() {
fmt.Println("Welcome everyone")
}
func init() {
fmt.Println("Hello everyone ")
}
// the main function
func main() {
fmt.Println("Welcome to home")
}
Co to jest pusty identyfikator (podkreślenie) w GoLang?
W GoLang _(podkreślenie) jest określane jako pusty identyfikator. Identyfikatory to zdefiniowane przez użytkownika nazwy komponentów oprogramowania używane do identyfikacji. GoLang zapewnia funkcję, która pozwala nam zadeklarować i wykorzystać nieużywaną zmienną przy użyciu pustego identyfikatora. Nieużywane zmienne są definiowane przez użytkownika w całym programie, ale nigdy nie są przez niego wykorzystywane. Te zmienne sprawiają, że program jest prawie nieczytelny. Ponieważ GoLang jest bardziej zwięzłym i czytelnym językiem programowania, nie umożliwia programiście określenia niepotrzebnej zmiennej; jeśli to zrobimy, kompilator zgłosi błąd. Gdy funkcja zwraca kilka wartości, ale potrzebujemy tylko kilku z nich, a niektóre odrzucamy, możemy użyć pustego identyfikatora. Informuje kompilator, że ta zmienna nie jest potrzebna i może ją zignorować bez powodowania błędu. Ukrywa wartości zmiennych i czyni program zrozumiałym. W rezultacie za każdym razem, gdy podajemy wartość Identyfikatora banku, staje się on bezużyteczny.
Pierwszy przykład: W poniższym programie funkcja mul_div zwraca dwie wartości, które przechowujemy w identyfikatorach mul i div. Jednak w całym programie używamy tylko jednej zmiennej, mul. W rezultacie kompilator zgłosi błąd, jeśli element div zostanie zadeklarowany, ale nie zostanie wykorzystany.
// Program to show compiler
// throws an error if variable is
// declared but not used
package main
import "fmt"
// the main function
func main() {
// calling function
// function returns two values which are
// assigned to mul and div the identifier
mul, div := mul_div(110, 9)
// only using the mul variable
// compiler will give an error
fmt.Println("110 x 9 = ", mul)
}
// function returning the twov
// values of integer type
func mul_div(nm1 int, nm2 int) (int, int) {
// returning values
return nm1 * nm2, nm1 / nm2
}
Drugi przykład: Aby naprawić powyższy program, użyjmy Blank Identyfikator. Po prostu użyj _(podkreślenia) zamiast identyfikacji elementu div. Pozwala kompilatorowi zignorować zadeklarowany i niewykorzystany błąd dla tej konkretnej zmiennej.
// Program to the use of Blank identifier
package main
import "fmt"
// the main function
func main() {
// calling function
// function returns two values which are
// assigned to mul and blank identifier
mul, _ := mul_div(110, 8)
// only using the mul variable
fmt.Println("110 x 8 = ", mul)
}
// function returning the two
// values of integer type
func mul_div(nm1 int, nm2 int) (int, int) {
// returning the values
return nm1 * nm2, nm1 / nm2
}
Ważne notatki:
o Wiele pustych identyfikatorów może być używanych w tym samym programie. W rezultacie program GoLang może zawierać wiele zmiennych o tej samie nazwie identyfikatora, pusty identyfikator.
o Istnieje wiele sytuacji, w których wartości muszą zostać przypisane tylko po to, aby uzupełnić składnię, mimo że wartości nigdy nie będą wykorzystywane w programie. Jak w funkcji, która zwraca wiele wartości. W takich przypadkach często stosuje się pusty identyfikator.
o W przypadku pustego identyfikatora możemy wykorzystać dowolną wartość dowolnego typu.
SŁOWO KLUCZOWE DEFER
Instrukcje odroczenia w języku Go odkładają wykonanie funkcji lub metody albo metody anonimowej do czasu powrotu pobliskich funkcji. Odroczone parametry wywołania funkcji lub metody, innymi słowy, oceniają natychmiast, ale nie wykonują, dopóki nie powróci pobliska funkcja. Możemy skonstruować opóźnioną metodę, funkcję lub funkcję anonimową za pomocą słowa kluczowego defer.
Składnia:
// Function
defer func func-name(parameterlist Type)
returntype{
// Code
}
// Method
defer func (receiver Type)
methodname(parameterlist){
// Code
}
defer func (parameterlist)(returntype){
// code
}()
Ważne notatki:
o Wiele instrukcji odroczenia jest dozwolonych w tym samym programie w Go i są one wykonywane w sekwencji LIFO (Last-In, First-Out), jak pokazano w drugim przykładzie.
o Parametry instrukcji odroczenia są oceniane w momencie wykonania instrukcji odroczenia, a nie w momencie jej wywołania.
o Instrukcje odroczenia są powszechnie używane w celu zagwarantowania zamknięcia plików, gdy ich użycie nie jest już potrzebne, w celu zamknięcia kanału lub przechwycenia paniki w programie.
Zilustrujmy to pojęcie przykładem:
Pierwszy przykład:
// Program to illustrate
// the concept of the defer statement
package main
import "fmt"
// Functions
func mul(x1, x2 int) int {
rest := x1 * x2
fmt.Println("Result: ", rest)
return 0
}
func show() {
fmt.Println("Hello, Everyone")
}
// the main function
func main() {
// Calling the mul() function
// Here the mul function behaves
// like normal function
mul(43, 25)
// Calling the mul()function
// Using defer keyword
// Here mul() function
// is defer function
defer mul(27, 46)
// Calling show() function
show()
}
Objaśnienie: W powyższym przykładzie istnieją dwie metody o nazwach mul() i show() (). Podczas gdy funkcja show() jest zwykle wywoływana w funkcji main(), funkcja mul() jest wywoływana na dwa sposoby:
Najpierw wywołujemy funkcję mul normalnie (bez słowa kluczowego defer), tj. mul(43, 25), i jest ona wykonywana, gdy funkcja jest wywoływana. Po drugie, używamy słowa kluczowego defer, aby odnieść się do funkcji mul() jako funkcji odroczonej, tj. defer odrocz mul(27, 46) i wykonuje się, gdy wszystkie otaczające metody powrócą.
Drugi przykład:
// Program to illustrate
// the multiple defer statements, to illustrate
LIFO policy
package main
import "fmt"
// Functions
func add(x1, x2 int) int {
rest := x1 + x2
fmt.Println("Result: ", rest)
return 0
}
// the main function
func main() {
fmt.Println("Starting")
// Multiple defer statements
// Executes in the LIFO order
defer fmt.Println("Ending")
defer add(37, 59)
defer add(12, 12)
}
PANIC w GoLang
Panic, podobnie jak wyjątek, pojawia się podczas wykonywania w języku programowania G. Innymi słowy, panika pojawia się, gdy w programie Go wystąpi nieoczekiwana okoliczność, powodująca przerwanie wykonywania programu. Czasami panika pojawia się w czasie wykonywania, gdy pojawia się określony warunek, taki jak dostęp do tablicy poza zakresem, jak pokazano w pierwszym przykładzie, a innym razem jest to celowo rzucane przez programistę, aby obsłużyć najgorszy scenariusz w programie Go za pomocą panika(), jak pokazano w drugim przykładzie. Funkcja paniki jest nieodłączną funkcją zdefiniowaną we wbudowanym pakiecie języka Go. Ta funkcja zatrzymuje przepływ kontroli i zaczyna panikować.
Składnia:
func panic(v interface{})
Jest w stanie zaakceptować każdy rodzaj argumentacji. Gdy w programie Go wystąpi panika, program zatrzymuje się w czasie wykonywania, a na ekranie wyjściowym wyświetlany jest komunikat o błędzie i ślad stosu aż do punktu, w którym wystąpiła panika. Ogólnie rzecz biorąc, kiedy w programie Go pojawia się panika, program nie kończy się natychmiast; zamiast tego kończy się, gdy Go zakończy wszystkie oczekujące prace dla tego programu. Na przykład, jeśli funkcja A wywołuje panikę, wykonywanie funkcji A zostaje zatrzymane, a jeśli w A dostępne są jakieś opóźnione funkcje, działają one normalnie. Następnie funkcja A powraca do swojego wywołującego, a A zachowuje się jak wywołanie paniki do dzwoniącego. Jak widać w trzecim przykładzie, ta procedura jest kontynuowana, dopóki nie zostaną zwrócone wszystkie funkcje w bieżącym goroutine, kiedy to program kończy się niepowodzeniem.
Pierwszy przykład:
// Program which illustrates the
// concept of panic
package main
import "fmt"
// the main function
func main() {
// Creating array of string type
// Using the var keyword
var myarr [3]string
// Elements are assigned using an index
myarr[0] = "HE"
myarr[1] = "Helloeveryone"
myarr[2] = "Hello"
// Accessing elements
// of the array
// Using the index value
fmt.Println("The Elements of Array:")
fmt.Println("The Element 1: ", myarr[0])
// Program panics because the
// size of the array is 3
// we try to access
// the index 5 which is not
// available in current array,
// it gives an runtime error
fmt.Println("The Element 2: ", myarr[5])
}
Drugi przykład:
// Program which illustrates
// how to create own panic
// Using the panic function
package main
import "fmt"
// Function
func entry(lang *string, aname *string) {
// When value of lang
// is nil it will panic
if lang == nil {
panic("Error: The Language cannot be nil")
}
// When value of aname
// is nil it will panic
if aname == nil {
panic("Error: The Author name cannot be
nil")
}
// When values of the lang and aname
// are non-nil values it will print
// the normal output
fmt.Printf("The Author Language: %s \n Author
Name: %s\n", *lang, *aname)
}
// the main function
func main() {
A_lang := "GO-Language"
// Here in the entry function, we pass
// a non-nil, nil values
// Due to nil value this method panics
entry(&A_lang, nil)
}
Trzeci przykład:
// Program which illustrates
// the concept of Defer while panicking
package main
import (
"fmt"
)
// Function
func entry(lang *string, aname *string) {
// the Defer statement
defer fmt.Println("The Defer statement in the
entry function")
// When value of lang
// is nil it will panic
if lang == nil {
panic("Error: The Language cannot be nil")
}
// When value of aname
// is nil it will panic
if aname == nil {
panic("Error: The Author name cannot be
nil")
}
// When values of the lang and aname
// are non-nil values it will
// print the normal output
fmt.Printf("The Author Language: %s \n Author
Name: %s\n", *lang, *aname)
}
// the main function
func main() {
A_lang := "GO-Language"
// the Defer statement
defer fmt.Println("the Defer statement in the
main function")
// in entry function, we pass
// one non-nil and one-nil value
// Due to nil value this method panics
entry(&A_lang, nil)
}
Zauważ, że instrukcja lub funkcja Defer jest wykonywana zawsze, nawet jeśli program panikuje.
Użycie panic<
o Możemy użyć paniki, aby wskazać nienaprawialny błąd, w wyniku którego program nie może kontynuować działania.
o Jeśli chcemy, aby w naszym programie pojawił się błąd w określonych okolicznościach, możemy użyć panic.
ODZYSKIWANIE
Podobnie jak bloki try/catch w językach takich jak Java, C# i inne są używane do przechwytywania wyjątków, funkcja recovery w Go służy do obsługi paniki. Jest to wbudowana funkcja zdefiniowana we wbudowanym pakiecie języka Go. Ta metoda jest używana głównie do odzyskania kontroli nad spanikowanym goroutine. Innymi słowy, zajmuje się panicznym zachowaniem goroutine.
Składnia:
func recover() interface{}
Szybkie punkty
o Funkcja odzyskiwania jest zawsze wywoływana w ramach funkcji opóźnionej, a nigdy w funkcji zwykłej. Używając funkcji odzyskiwania z normalnej funkcji lub poza funkcją opóźnioną, sekwencja paniki jest kontynuowana, jak pokazano w pierwszym przykładzie. Jak pokazano w drugim przykładzie, funkcja odzyskiwania jest zawsze wywoływana wewnątrz funkcji odroczonej, ponieważ funkcja odroczona nie zatrzymuje swojego wykonywania, jeśli program panikuje, więc funkcja odzyskiwania zatrzymuje sekwencję paniki, po prostu przywracając normalne wykonanie goroutine i pobierając przekazaną wartość błędu na panikę.
o Funkcja przywracania będzie działać tylko wtedy, gdy wywołamy ją w tym samym trybie, w którym wystąpiła panika. Nie zadziała tak, jak pokazano w trzecim przykładzie, jeśli wywołamy go w oddzielnej goroutine.
o Jeśli chcemy znaleźć ślad stosu, skorzystajmy z metody PrintStack z pakietu Debug.
Pierwszy przykład:
// Program which illustrates
// the concept of recover
package main
import "fmt"
// This function is created to handle
panic occurs in entry function
// but it does not handle panic
occurred in entry function
// because it called in normal
function
func handlepanic() {
if a := recover(); a != nil {
fmt.Println("RECOVER", a)
}
}
// Function
func entry(lang *string, aname *string) {
// Normal function
handlepanic()
// When value of lang
// is nil it will panic
if lang == nil {
panic("Error: Language cannot be nil")
}
// When value of aname
// is nil it will panic
if aname == nil {
panic("Error: Author name cannot be nil")
}
fmt.Printf("The Author Language: %s \n Author
Name: %s\n", *lang, *aname)
fmt.Printf("Return successfully from entry
function")
}
// The main function
func main() {
A_lang := "GO Language"
entry(&A_lang, nil)
fmt.Printf("Return successfully from the main
function")
}
ZAMKNIĘCIE
Funkcja anonimowa jest cechą języka programowania Go. Anonimowa funkcja może stanowić zamknięcie. Zamknięcie jest rodzajem anonimowej funkcji, która odwołuje się do zmiennych określonych poza funkcją. Jest to analogiczne do dostępu do zmiennych globalnych dostępnych przed deklaracją funkcji.
Przykład:
// Program to illustrate how
// to create Closure
package main
import "fmt"
func main() {
// Declaring variable
HFW := 0
// Assigning an anonymous
// function to variable
counter := func() int {
HFW += 1
return HFW
}
fmt.Println(counter())
fmt.Println(counter())
}
Objaśnienie: Zmienna HFW nie została przekazana jako argument funkcji anonimowej, ale jest dostępna dla tej funkcji. Ten przykład ma niewielki problem, ponieważ każda inna funkcja określona w main musi mieć dostęp do zmiennej globalnej HFW i może ją aktualizować bez wywoływania funkcji licznika. W rezultacie zamknięcie zapewnia również inną korzyść: izolację danych.
// Program to illustrate how
// to create the data isolation
package main
import "fmt"
// newCounter function to
// isolate the global variable
func newCounter() func() int {
HFW := 0
return func() int {
HFW += 1
return HFW
}
}
func main() {
// newCounter function is assigned to a
variable
counter := newCounter()
// invoke the counter
fmt.Println(counter())
// invoke the counter
fmt.Println(counter())
}
Objaśnienie: Zamknięcie odwołuje się do zmiennej HFW nawet po zakończeniu funkcji newCounter(), ale żaden inny kod poza metodą newCounter() nie ma do niej dostępu. W ten sposób utrzymywana jest trwałość danych w wywołaniach funkcji, jednocześnie izolując dane z innych programów.
REKURENCJA
Rekurencja to proces, w którym funkcja wywołuje samą siebie, niejawnie lub jawnie, a powiązana funkcja jest znana jako funkcja rekurencyjna. Funkcja anonimowa jest szczególną cechą języka programowania Go. Jest to funkcja, która nie ma nazwy. Służy do tworzenia funkcji wbudowanej. Można również określić i zdefiniować anonimowe funkcje rekurencyjne. Rekurencyjne funkcje anonimowe są również określane jako literały funkcji rekurencyjnych.
Składnia
func(parameterlist)(returntype){
// code
// call the same function
// within function for recursion
// Use the return statement only
// if return-type are given.
return
}()
Pierwszy przykład :
// Program to show
// how to create recursive
// Anonymous function
package main
import "fmt"
func main() {
// Anonymous function
var recursiveAnonymous func()
recursiveAnonymous = func() {
// Printing message to show
// the function call and iteration.
fmt.Println("The Anonymous functions could
be recursive.")
// Calling the same function
recursively
recursiveAnonymous()
}
// the main calling of function
recursiveAnonymous()
}
Drugi przykład:
// Program to show
// how to create recursive
// Anonymous function
package main
import (
"fmt"
)
func main() {
// the Anonymous function
var recursiveAnonymous func(int)
// Passing arguments to Anonymous function
recursiveAnonymous = func(variable int) {
// Checking condition to return
if variable == -1 {
fmt.Println("Welcome to our Channel")
return
} else {
fmt.Println(variable)
// Calling the same
// function recursively
recursiveAnonymous(variable - 1)
}
}
// the main calling
// of function
recursiveAnonymous(10)
}
Typy rekurencji
Istnieje kilka odmian rekurencji, co ilustrują poniższe przykłady.
Bezpośrednia rekurencja
Rekurencja bezpośrednia to rodzaj rekurencji, w której funkcja wywołuje samą siebie bezpośrednio, bez pomocy innej funkcji. Poniższy przykład ilustruje koncepcję bezpośredniej rekurencji:
// Program to illustrate
// the concept of direct recursion
package main
import (
"fmt"
)
// the recursive function for
// calculating factorial of a positive integer
func factorial_calc(number int) int {
// this is base condition
// if number is 0 or 1 the function will return 1
if number == 0 || number == 1 {
return 1
}
// if the negative argument is
// given, it prints error message & returns -1
if number < 0 {
fmt.Println("Invalid-number")
return -1
}
// the recursive call to itself with argument
decremented
// by 1 integer so that it
// eventually reaches base case
return number*factorial_calc(number - 1)
}
// main function
func main() {
// passing 0 as a parameter
answer1 := factorial_calc(0)
fmt.Println(answer1, "\n")
// passing a positive integer
answer2 := factorial_calc(5)
fmt.Println(answer2, "\n")
// passing negative integer
// prints error message
// with return value of -1
answer3 := factorial_calc(-1)
fmt.Println(answer3, "\n")
// passing positive integer
answer4 := factorial_calc(10)
fmt.Println(answer4, "\n")
}
Rekurencja pośrednia
Rekurencja pośrednia to rodzaj rekurencji, w której funkcja wywołuje inną funkcję, która następnie wywołuje funkcję wywołującą. Inna funkcja służy do wspomagania tej formy rekurencji. Funkcja wywołuje samą siebie, ale robi to pośrednio za pośrednictwem innej funkcji. Poniższy przykład ilustruje koncepcję rekurencji pośredniej:
// Program to illustrate
// the concept of indirect recursion
package main
import (
"fmt"
)
// the recursive function for printing all numbers
// upto number x
func print_one(x int) {
// if number is positive
// print the number
// call second function
if x >= 0 {
fmt.Println("In first function:", x)
// call to the second function
// which calls this first
// function indirectly
print_two(x - 1)
}
}
func print_two(x int) {
// if number is positive
// print the number, call second function
if x >= 0 {
fmt.Println("In second function:", x)
// call to first function
print_one(x - 1)
}
}
// main function
func main() {
// passing positive
// parameter which prints all
// the numbers from 1 - 10
print_one(10)
// this will not print anything as it does not
// follow base case
print_one(-1)
}
Uwaga: Rekurencja wzajemna odnosi się do rekurencji pośredniej z tylko dwiema funkcjami. Aby wspomóc rekurencję pośrednią, może istnieć więcej niż dwie funkcje.
Rekurencja ogona
Wywołanie ogona to wywołanie podprogramu, które jest ostatnim lub ostatnim wywołaniem funkcji. Kiedy wywołanie ogona ponownie wywołuje tę samą funkcję, mówi się, że funkcja jest rekurencyjna ogona. Wywołanie rekurencyjne jest ostatnią czynnością wykonywaną przez funkcję w tym przypadku.
Przykład:
// Program to illustrate
// the concept of tail recursion
package main
import (
"fmt"
)
// the tail recursive function
// to print all the numbers
// from x to 1
func print_num(x int) {
// if number is still
// positive, print it
// and call the function
// with decremented value
if x > 0 {
fmt.Println(x)
// last statement in
// the recursive function
// tail recursive call
print_num(x-1)
}
}
// the main function
func main() {
// passing positive
// number, prints 5 to 1
print_num(5)
}
Rekurencja głowy
Wywołanie rekurencyjne jest początkową instrukcją w funkcji w rekurencji głowy. Nie ma żadnych dalszych instrukcji ani operacji poprzedzających wywołanie. Funkcja nie musi niczego przetwarzać po wywołaniu, a wszystkie operacje są zakończone po powrocie.
Przykład:
// Program to illustrate
// the concept of head recursion
package main
import (
"fmt"
)
// the head recursive function
// to print all the numbers
// from 1 to x
func print_num(x int) {
// if the number is still
// less than x, call
// function with decremented value
if x > 0 {
// the first statement in function
print_num(x-1)
// printing is done at
// the returning time
fmt.Println(x)
}
}
// the main function
func main() {
// passing positive
// number, prints 5 to 1
print_num(5)
}
Uwaga: Warto zauważyć, że wynik rekurencji głowy jest dokładnie odwrotny do wyniku rekurencji ogona. Dzieje się tak dlatego, że w rekurencji ogonowej funkcja najpierw wypisuje liczbę, a następnie wywołuje samą siebie, ale w rekurencji czołowej funkcja wywołuje samą siebie, dopóki nie osiągnie przypadku podstawowego, a następnie rozpoczyna drukowanie podczas powrotu.
Nieskończona rekurencja
Wszystkie funkcje rekurencyjne były określonymi lub skończonymi funkcjami rekurencyjnymi, co oznacza, że kończyły się, gdy osiągnęły warunek podstawowy. Rekurencja nieskończona to rekurencja, która nigdy nie jest zbieżna do przypadku podstawowego i trwa w nieskończoność. To często prowadzi do awarii systemu lub wycieków pamięci.
Przykład:
// Program to illustrate
// the concept of infinite recursion
package main
import (
"fmt"
)
// infinite-recursion function
func print_hello() {
// printing infinite-times
fmt.Println("Helloeveryone")
print_hello()
}
// the main function
func main() {
// call to infinite recursive-function
print_hello()
}
Rekurencja funkcji anonimowej
W GoLang istnieje koncepcja znana jako funkcje, które nie mają nazwy. Są to tak zwane funkcje anonimowe. Anonimowe funkcje w GoLang mogą być również używane do rekurencji, jak widać w poniższych przykładach.
Pierwszy przykład:
// Program to illustrate
// the concept of anonymous function recursion
package main
import (
"fmt"
)
// main function
func main() {
// declaring anonymous function
// that takes integer value
var anon_func func(int)
// defining the anonymous
// function that prints the numbers from x to 1
anon_func = func(number int) {
// the base case
if number == 0 {
return
} else {
fmt.Println(number)
// calling anonymous function
recursively
anon_func(number-1)
}
}
// call to anonymous recursive function
anon_func(5)
}
Drugi przykład:
// Program which illustrates the
// concept of recover
package main
import (
"fmt"
)
// This function handles panic
// occur in the entry function
// with help of the recover function
func handlepanic() {
if x := recover(); x != nil {
fmt.Println("RECOVER", x)
}
}
// Function
func entry(lang *string, aname *string) {
// the Deferred function
defer handlepanic()
// When value of lang is nil it will panic
if lang == nil {
panic("Error: The Language cannot be nil")
}
// When value of aname
// is nil it will panic
if aname == nil {
panic("Error: The Author name cannot be
nil")
}
fmt.Printf("The Author Language: %s \n Author
Name: %s\n", *lang, *aname)
fmt.Printf("The Return successfully from entry
function")
}
// the main function
func main() {
A_lang := "GO-Language"
entry(&A_lang, nil)
fmt.Printf("The Return successfully from main
function")
}
Trzeci przykład
// Program which illustrates
// the recover in a goroutine
package main
import (
"fmt"
"time"
)
// For the recovery
func handlepanic() {
if x := recover(); x != nil {
fmt.Println("RECOVER", x)
}
}
/* Here, this panic is not handled by recover
function because of recover function is not
called in the same goroutine in which
panic occurs */
// the Function 1
func myfun1() {
defer handlepanic()
fmt.Println("Welcome to the Function1")
go myfun2()
time.Sleep(10 * time.Second)
}
// the Function 2
func myfun2() {
fmt.Println("Welcome to Function2")
panic("Panicked!!")
}
// the main function
func main() {
myfun1()
fmt.Println("The Return successfully from main
function")
}