Introduktion till Go-operatörer

Alla programmeringsspråk kommer med vissa operatörer som används för att utföra vissa logiska / matematiska operationer. Operatörer är vanligtvis konstruerade som vanligtvis fungerar som funktioner. Operatörer betecknas i princip med specialtecken och används för tillägg (+), subtraktioner (-) och till och med liknande uppdrag (=)

Språk har vanligtvis inbyggda operatörer och vissa språk tillåter användardefinierade operatörer.

Elementen eller numren som operatören appliceras på kallas operander. Operatörens position med avseende på operander kan vara prefix, postfix eller Infix.

Olika operatörer är följande:

  • Aritmetiska operatörer
  • Logiska operatörer
  • Relationsoperatörer
  • Bitvisa operatörer
  • Uppdragsoperatörer
  • Diverse / Andra operatörer

1. Aritmetik

Låt oss anta a = 6, b = 3

  • Lägg till: Detta används för att lägga till siffror

Exempel: c = a + b; // c ger 9

  • Subtrahera: Detta används för att subtrahera siffror

Exempel : c = ab; // c ger 3

  • Multiplicera: Detta används för att multiplicera siffror

Exempel : c = a * b; // c ger 18

  • Dela: Detta används för att dela upp siffror

Exempel : c = a / b; // c ger 2

  • Modul: Detta används för att få återstoden efter en uppdelning av siffror

Exempel : c = a% b; // c ger 0

  • Ökning: Detta används för att öka heltalvärdet med 1

Exempel : a ++ // a är nu 7

  • Dekrement: Detta används för att minska heltalvärdet med 1

Exempel : a– // a är nu 5

2. Logiskt

Logiska operationer som AND, OR operation, INTE utförs av dessa operatörer.

Låt x = 0, y = 1

  • OCH (&&): Om båda operanderna inte värderas, blir ANDEN av dem sanna.

Exempel : x && y = falskt

  • ELLER (||): Om någon av operandema är icke-noll, blir OR av dem sanna

Exempel : x || y = sant

  • NOT (!): Inte används för att vända operandets logiska värde.

Ex :! X = sant

! y = falskt

! (x && y) = sant

3. Relationellt

Relationsoperatörer returnerar sant eller falskt baserat på operationer på operander.

Låt a = 3; b = 4; c = 3;

  • Lika (==): Detta returnerar sant om operanderna är lika

Exempel : a == c returnerar sant

a == b returnerar falskt

  • NotEquals (! =): Detta returnerar sant om operander inte är lika

Exempel : a! = C returnerar falskt

a! = b returnerar sant

  • GreaterThan (>): Detta returnerar sant om den vänstra operanden är större än höger

Exempel : a> b returnerar falskt

  • LessThan (<): Detta returnerar sant om vänsteroperand är mindre än höger

Till exempel: a

  • GreaterThanOrEqualTo (> =): Detta returnerar sant om den vänstra operanden är större än eller lika med den högra operanden

Exempelvis : a> = c returnerar sant

  • LessThanOrEqualTo (<=): Detta returnerar sant om den vänstra operanden är större än eller lika med den högra operanden

Exempel : a <= b returnerar sant

4. BitWise

Dessa operatörer arbetar bit för bit och matar ut logiken baserat på bitoperationer.

Nedan är sanningstabellen för referens:

X

 Y X & Y X | Y X Y

0

 0 0 0

0

0

 1 0 1

1

1

 0 0 1

1
1 1 1 1

0

Exempel: Låt A = 10, B = 13

A = 0000 1100

B = 0000 1101

  • &: Används för att utföra bitvis OCH drift

Exempel: A & B = 0000 1100 = 12

  • |: Används för att utföra bitvis ELLER operation

Exempel: A | B = 0000 1101 = 13

  • ^: Används för att utföra XOR-operation

Exempel: A B = 0000 0001 = 1

  • <<: Detta är den vänstra växlingen som används för att flytta bitarna till vänster med ett nummer som anges till höger

Exempel: A << 2: Detta skulle förskjuta A-värdet med 2

dvs: 0000 0010

0000 1000 = 8

  • >>: Detta är rätt växling som används för att flytta bitarna till höger med ett nummer som anges till höger

Exempel: A >> 1: Detta skulle förskjuta A-värdet med 1

dvs: 0000 0010

0000 0001 = 1

5. Uppdrag

Dessa används för att tilldela värden från höger operand till vänster baserat på operatören.

Låt a = 4, b = 2

  • =: Används för att tilldela värdet helt enkelt från höger till vänster.

Exempel: a = b // Tilldelar b-värde dvs. 2 till a

  • + =: Används för att lägga till värdet och tilldela det till vänsteroperand

Exempel: a + = b => a = a + b => a = 6

  • - =: Används för att subtrahera värdet och tilldela det till vänsteroperand

Exempel: a- = b => a = ab => a = 2

  • * =: Används för att multiplicera värdet och tilldela det till vänsteroperand

Exempel: a * = b => a = a * b => a = 8

  • / =: Används för att dela värdet och tilldela det till vänsteroperand

Exempel: a / = b => a = a / b => a = 2

  • % =: Används för att tilldela påminnelsen efter delning

Exempel: a% = b => a = a% b => a = 0

  • << =: Används för att vänster skift och tilldela värdet till variabeln

Exempel: a <= a << 2

  • >> =: Används för att höger växla och tilldela värdet till variabeln

Exempel: b >> = 2 => = b >> 2

  • & =: Bitvis OCH Uppdrag.

Exempel: c & = 2 => c = c & 2

  • | =: Bitvis ELLER tilldelning.

Exempel: c | = 2 => c = c | 2

  • =: Bitvis XOR-tilldelning.

Exempel: c = 2 => c = c 2

6. Övrigt / Diverse

& och * är ytterligare två operatörer som Go stöder

  • &: Detta används för att få en variabels faktiska adress

Användning : & a;

  • *: Detta används för att få pekaren till en variabel

Användning: * a

Rekommenderade artiklar

Detta har varit en guide till Go Operators. Här har vi diskuterat olika typer av Go-operatörer med exempel. Du kan också titta på följande artikel för att lära dig mer -

  1. C Operatörer
  2. Matlab-alternativ
  3. GitHub-alternativ
  4. Skillnader mellan Go och Java

Kategori:

Mjukvaruutveckling