Když slyšíme pojem „operátory“, mnohým z nás se ihned vybaví matematické operace jako sčítání, odčítání, dělení nebo umocňování. Operátory však sahají daleko za hranice matematiky. Jsou to mocné nástroje používané k porovnávání, manipulaci a vyhodnocování dat v různých kontextech.
Například v programování a analýze dat mohou operátory sloužit k ověřování podmínek, jako je zjištění, zda je cena v aplikaci pro obchodování příliš nízká nebo příliš vysoká. Kromě toho umožňují operátory provádět akce, jako je spojování nebo transformace dat.
Představte si, že sečtete náklady na všechny položky v nákupním košíku, abyste vypočítali celkovou cenu — to je další příklad použití operátorů. Jejich všestrannost z nich činí klíčový nástroj jak pro logické, tak pro numerické řešení problémů.
Typy operátorů
• Aritmetické operátory: Používají se pro matematické úkoly, jako je sčítání, odčítání a násobení
• Porovnávací operátory: Slouží k porovnání dvou hodnot; například pro kontrolu, zda jsou rovny, nerovny, menší nebo větší než druhá hodnota
• Logické operátory: Pracují s hodnotami typu Boolean a určují, zda jsou obě pravdivé, pouze jedna pravdivá nebo zda je hodnota Boolean nepravdivá
• Adresní operátory: Souvisí s ukazateli; tomuto tématu se budeme věnovat v samostatném článku
• Operátory pro příjem: Používají se při práci s kanály v Go; těmto operátorům se budeme věnovat později při probírání kanálů
Aritmetické operátory
Pro demonstraci aritmetických operátorů si nasimulujeme nákupní účet. K vytvoření naší simulace použijeme jak aritmetické, tak porovnávací operátory. Začněme prozkoumáním hlavních použití operátorů.
Tato ukázka demonstruje použití aritmetických operátorů jako
+, *, / a - pro výpočet nákupního účtu.package main
import "fmt"
func main() {
// Seznam cen položek
var item1, item2, item3 float64 = 19.99, 45.50, 12.75
// Použití aritmetických operací
total := item1 + item2 + item3 // Součet všech položek
discount := 10.0 // Paušální sleva v procentech
discountAmount := (total * discount) / 100
finalTotal := total - discountAmount
// Zobrazení účtu
fmt.Println("Ceny položek:")
fmt.Printf("Položka 1: %.2f\n", item1)
fmt.Printf("Položka 2: %.2f\n", item2)
fmt.Printf("Položka 3: %.2f\n", item3)
fmt.Printf("Mezisoučet: %.2f\n", total)
fmt.Printf("Sleva (%.2f%%): -%.2f\n", discount, discountAmount)
fmt.Printf("Celkem po slevě: %.2f\n", finalTotal)
}• Sčítání cen položek: Ceny jednotlivých položek (
item1, item2, item3) sečteme pomocí operátoru + pro výpočet mezisoučtu• Výpočet slevy: Procento slevy se aplikuje pomocí operátorů násobení (
*) a dělení (/)• Odečtení slevy: Výše slevy se odečte od mezisoučtu pro získání konečné celkové ceny
Ceny položek:
Položka 1: 19.99
Položka 2: 45.50
Položka 3: 12.75
Mezisoučet: 78.24
Sleva (10.00%): -7.82
Celkem po slevě: 70.42 Zkrácené operátory
Když přičítáte hodnotu k aktuální hodnotě, může se to bez použití zkrácených operátorů stát zdlouhavým.
Jaké máme zkrácené operátory?
--: Sniž číslo o 1
++: Zvyš číslo o 1
+=: Přičti a přiřaď
-=: Odečti a přiřaďPoužijeme příklady zkrácených operátorů, abychom ukázali, jak mohou zjednodušit a zkompaktnit váš kód. Vytvoříme některé proměnné a použijeme zkrácené operátory pro jejich úpravy, přičemž výsledky budeme průběžně tisknout.
package main
import "fmt"
func main() {
// Počáteční proměnné
a := 10
b := 20
c := 5
// Tisk počátečních hodnot
fmt.Println("Počáteční hodnoty:")
fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
// Použití zkrácených operátorů
// Přičti a přiřaď
a += 5 // ekvivalentní s a = a + 5
fmt.Printf("Po 'a += 5': a = %d\n", a)
// Odečti a přiřaď
b -= 10 // ekvivalentní s b = b - 10
fmt.Printf("Po 'b -= 10': b = %d\n", b)
// Vynásob a přiřaď
c *= 2 // ekvivalentní s c = c * 2
fmt.Printf("Po 'c *= 2': c = %d\n", c)
// Vyděl a přiřaď
c /= 3 // ekvivalentní s c = c / 3
fmt.Printf("Po 'c /= 3': c = %d\n", c)
// Zbytek po dělení a přiřaď
a %= 4 // ekvivalentní s a = a % 4
fmt.Printf("Po 'a %%= 4': a = %d\n", a)
// Tisk konečných hodnot
fmt.Println("Konečné hodnoty:")
fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
}Výstup:
a = 10, b = 20, c = 5
Po 'a += 5': a = 15
Po 'b -= 10': b = 10
Po 'c *= 2': c = 10
Po 'c /= 3': c = 3
Po 'a %= 4': a = 3
Konečné hodnoty:
a = 3, b = 10, c = 3 Porovnávání hodnot
Logika v aplikacích zahrnuje to, že váš kód činí rozhodnutí. Tato rozhodnutí jsou založena na porovnání hodnot proměnných s pravidly, která definujete, což má formu porovnání.
Používáme specifickou sadu operátorů pro provádění těchto porovnání a výsledek je vždy hodnota typu Boolean — buď
true, nebo false. Často budete potřebovat provést více porovnání, abyste dospěli k jednomu rozhodnutí. K tomu pomáhají logické operátory.Logické operátory pracují primárně se dvěma hodnotami a vždy produkují výsledek typu Boolean. Mohou být použity pouze s hodnotami typu Boolean.
Porovnávací operátory:
•
==: Pravda, pokud jsou dvě hodnoty stejné•
!=: Pravda, pokud dvě hodnoty nejsou stejné•
<: Pravda, pokud je levá hodnota menší než pravá•
<=: Pravda, pokud je levá hodnota menší nebo rovna pravé•
>: Pravda, pokud je levá hodnota větší než pravá•
>=: Pravda, pokud je levá hodnota větší nebo rovna pravéLogické operátory:
•
&&: Pravda, pokud jsou levá a pravá hodnota obě pravdivé•
||: Pravda, pokud je jedna nebo obě hodnoty pravdivé•
!: Tento operátor pracuje pouze s jednou hodnotou a výsledek je pravda, pokud je hodnota nepravdiváPojďme se podívat na příklad použití některých z těchto operátorů. Představte si, že máte dvě portfolia — akcie a kryptoměny — a chcete porovnat celkovou hodnotu každého z nich, abyste zjistili, kde máte více alokovaných peněz.
package main
import "fmt"
func main() {
// Hodnoty portfolií
stocks := 15000.0
crypto := 10000.0
// Porovnání hodnot portfolií
fmt.Println("Porovnání portfolií:")
// Použití porovnávacích operátorů
if stocks == crypto {
fmt.Println("Portfolia akcií a kryptoměn mají stejnou hodnotu.")
} else if stocks > crypto {
fmt.Println("Portfolio akcií je větší než portfolio kryptoměn.")
} else {
fmt.Println("Portfolio kryptoměn je větší než portfolio akcií.")
}
// Použití logických operátorů
riskyCrypto := crypto > 5000.0 && crypto < 20000.0
fmt.Printf("Je portfolio kryptoměn považováno za rizikové? %v
", riskyCrypto)
highStocksOrCrypto := stocks > 20000.0 || crypto > 20000.0
fmt.Printf("Máme vysoce hodnotné portfolio buď v akciích, nebo v kryptoměnách? %v
", highStocksOrCrypto)
// Použití operátoru NOT
lowRiskStocks := !(stocks > 20000.0)
fmt.Printf("Je portfolio akcií považováno za nízkorizikové? %v
", lowRiskStocks)
}Výstup:
Porovnání portfolií:
Portfolio akcií je větší než portfolio kryptoměn.
Je portfolio kryptoměn považováno za rizikové? true
Máme vysoce hodnotné portfolio buď v akciích, nebo v kryptoměnách? false
Je portfolio akcií považováno za nízkorizikové? true Nulové hodnoty
Nulová hodnota proměnné je její výchozí hodnota na základě typu. V jazyce Go má každý základní typ předdefinovanou nulovou hodnotu.
Bonus — Formátovací parametry ve
fmt.Printf V části o zkrácených operátorech jsme použili
%d. Existuje však více možností formátování, které mohou zpočátku působit nezvykle.Podívejme se na ně, aby vám již nepřipadaly matoucí.
Funkce
fmt.Printf v Go používá šablonovací jazyk s „parametry“ pro formátování. Tyto parametry vám umožňují ovládat, jak bude hodnota při tisku naformátována a zobrazena. Například parametr %#v tiskne hodnoty ve stylu syntaxe Go, což je obzvláště užitečné při ladění.
Zde je jednoduchý příklad použití fmt.Printf:
package main
import "fmt"
func main() {
type User struct {
Name string
Age int
}
u := User{Name: "Alice", Age: 30}
fmt.Printf("Výchozí formát: %v
", u) // Výstup: {Alice 30}
fmt.Printf("Detailní formát: %+v
", u) // Výstup: {Name:Alice Age:30}
fmt.Printf("Syntaxe Go: %#v
", u) // Výstup: main.User{Name:"Alice", Age:30}
fmt.Printf("Typ: %T
", u) // Výstup: main.User
fmt.Printf("Desetinné číslo: %d
", u.Age) // Výstup: 30
fmt.Printf("Řetězec: %s
", u.Name) // Výstup: Alice
}Výstup:
Výchozí formát: {Alice 30}
Detailní formát: {Name:Alice Age:30}
Syntaxe Go: main.User{Name:"Alice", Age:30}
Typ: main.User
Desetinné číslo: 30
Řetězec: Alice