Grundlegendes zur Booleschen Logik in Go

Der boolesche Datentyp (bool) kann einer von zwei Werten sein, entwedertrue oderfalse. Boolesche Werte werden bei der Programmierung verwendet, um Vergleiche anzustellen und den Programmablauf zu steuern.

Boolesche Werte stellen die Wahrheitswerte dar, die dem logischen Zweig der Mathematik zugeordnet sind, der Algorithmen in der Informatik informiert. Das nach dem Mathematiker George Boole benannte Wort Boolean beginnt immer mit einem großgeschriebenenB.

Der Datentyp in Go for Boolean istbool, alles in Kleinbuchstaben. Die Wertetrue undfalse werden immer mit Kleinbuchstabent bzw.f angegeben, da es sich um spezielle Werte in Go handelt.

Dieses Tutorial behandelt die Grundlagen, die Sie benötigen, um zu verstehen, wie der Datentypboolfunktioniert, einschließlich Boolescher Vergleiche, logischer Operatoren und Wahrheitstabellen.

Vergleichsoperatoren

Bei der Programmierung werdencomparison operators verwendet, um Werte zu vergleichen und bis zu einem einzelnen Booleschen Wert von entweder wahr oder falsch auszuwerten.

Die folgende Tabelle zeigt Boolesche Vergleichsoperatoren.

Operator	Was es bedeutet
==	Gleicht
!=	Nicht gleichzusetzen mit
<	Weniger als
>	Größer als
⇐	Weniger als oder gleich
>=	Größer als oder gleich wie

Operator

Was es bedeutet

Gleicht

Nicht gleichzusetzen mit

Weniger als

Größer als

⇐

Weniger als oder gleich

Größer als oder gleich wie

Um zu verstehen, wie diese Operatoren funktionieren, weisen Sie zwei Ganzzahlen in einem Go-Programm zwei Variablen zu:

x := 5
y := 8

In diesem Beispiel hatx den Wert5 und weniger alsy den Wert8.

Gehen wir mit diesen beiden Variablen und ihren zugehörigen Werten die Operatoren aus der vorhergehenden Tabelle durch. In diesem Programm werden Sie aufgefordert, auszudrucken, ob jeder Vergleichsoperator entweder wahr oder falsch ist. Zum besseren Verständnis dieser Ausgabe muss Go auch eine Zeichenfolge drucken, um anzuzeigen, was ausgewertet wird:

package main

import "fmt"

func main() {
    x := 5
    y := 8

    fmt.Println("x == y:", x == y)
    fmt.Println("x != y:", x != y)
    fmt.Println("x < y:", x < y)
    fmt.Println("x > y:", x > y)
    fmt.Println("x <= y:", x <= y)
    fmt.Println("x >= y:", x >= y)
}

Outputx == y: false
x != y: true
x < y: true
x > y: false
x <= y: true
x >= y: false

Nach mathematischer Logik hat Go aus den Ausdrücken Folgendes ausgewertet:

Ist 5 (x) gleich 8 (y)? false
Ist 5 ungleich 8? true
Ist 5 weniger als 8? true
Ist 5 größer als 8? false
Ist 5 kleiner oder gleich 8? true
Ist 5 nicht kleiner oder gleich 8? false

Obwohl hier Ganzzahlen verwendet wurden, können Sie diese durch Gleitkommawerte ersetzen.

Zeichenfolgen können auch mit Booleschen Operatoren verwendet werden. Sie unterscheiden zwischen Groß- und Kleinschreibung, es sei denn, Sie verwenden eine zusätzliche Zeichenfolgemethode.

Sie können sehen, wie Zeichenfolgen in der Praxis verglichen werden:

Sammy := "Sammy"
sammy := "sammy"

fmt.Println("Sammy == sammy: ", Sammy == sammy)

OutputSammy == sammy:  false

Die ZeichenfolgeSammy ist nicht gleich der Zeichenfolgesammy, da sie nicht genau gleich sind. einer beginnt mit einem GroßbuchstabenS und der andere mit einem Kleinbuchstabens. Wenn Sie jedoch eine andere Variable hinzufügen, der der WertSammy zugewiesen ist, werden sie als gleich ausgewertet:

Sammy := "Sammy"
sammy := "sammy"
alsoSammy := "Sammy"

fmt.Println("Sammy == sammy: ", Sammy == sammy)
fmt.Println("Sammy == alsoSammy", Sammy == alsoSammy)

OutputSammy == sammy:  false
Sammy == alsoSammy true

Sie können auch die anderen Vergleichsoperatoren einschließlich> und< verwenden, um zwei Zeichenfolgen zu vergleichen. Go vergleicht diese Zeichenfolgen lexikografisch mit den ASCII-Werten der Zeichen.

Sie können Boolesche Werte auch mit Vergleichsoperatoren auswerten:

t := true
f := false

fmt.Println("t != f: ", t != f)

Outputt != f:  true

Der vorhergehende Codeblock bewertete, dasstrue nicht gleichfalse ist.

Beachten Sie den Unterschied zwischen den beiden Operatoren= und==.

x = y   // Sets x equal to y
x == y  // Evaluates whether x is equal to y

Das erste= ist der Zuweisungsoperator, der einen Wert gleich einem anderen setzt. Das zweite,==, ist ein Vergleichsoperator und bewertet, ob zwei Werte gleich sind.

Logische Operatoren

Es gibt zwei logische Operatoren, die zum Vergleichen von Werten verwendet werden. Sie werten Ausdrücke bis auf Boolesche Werte aus und geben entwedertrue oderfalse zurück. Diese Operatoren sind&&,|| und! und werden in der folgenden Liste definiert:

&& (x && y) ist der Operatorand. Es ist wahr, wenn beide Aussagen wahr sind.
|| (x || y) ist der Operatoror. Es ist wahr, wenn mindestens eine Aussage wahr ist.
! (!x) ist der Operatornot. Es ist nur wahr, wenn die Aussage falsch ist.

Logische Operatoren werden normalerweise verwendet, um zu bewerten, ob zwei oder mehr Ausdrücke wahr sind oder nicht. Sie können beispielsweise verwendet werden, um zu bestimmen, ob die Note bestanden wurde und ob der Schüler im Kurs registriert ist. Wenn beide Fälle zutreffen, wird dem Schüler eine Note im System zugewiesen. Ein anderes Beispiel wäre zu bestimmen, ob ein Benutzer ein gültiger aktiver Kunde eines Onlineshops ist, basierend darauf, ob er über ein Guthaben verfügt oder in den letzten 6 Monaten einen Kauf getätigt hat.

Um zu verstehen, wie logische Operatoren funktionieren, werden drei Ausdrücke ausgewertet:

fmt.Println((9 > 7) && (2 < 4))   // Both original expressions are true
fmt.Println((8 == 8) || (6 != 6)) // One original expression is true
fmt.Println(!(3 <= 1))            // The original expression is false

Outputtrue
true
true

Im ersten Fall musstenfmt.Println((9 > 7) && (2 < 4)), sowohl9 > 7 als auch2 < 4 als wahr bewertet werden, da der Operatorand verwendet wurde.

Im zweiten Fall,fmt.Println((8 == 8) || (6 != 6)), machte es keinen Unterschied, dass6 != 6 als falsch ausgewertet wurde, da8 == 8 als falsch ausgewertet wurde, da der Operatoror verwendet wurde. Wenn Sie den Operatorand verwendet hätten, würde dies als falsch ausgewertet.

Im dritten Fall,fmt.Println(!(3 <= 1)), negiert der Operatornot den falschen Wert, den3 <=1 zurückgibt.

Lassen Sie uns ganze Zahlen durch Floats ersetzen und falsche Auswertungen anstreben:

fmt.Println((-0.2 > 1.4) && (0.8 < 3.1))  // One original expression is false
fmt.Println((7.5 == 8.9) || (9.2 != 9.2)) // Both original expressions are false
fmt.Println(!(-5.7 <= 0.3))               // The original expression is true

In diesem Beispiel:

and muss mindestens einen falschen Ausdruck haben, der als falsch ausgewertet wird.
or muss beide Ausdrücke als falsch auswerten lassen.
! muss seinen inneren Ausdruck wahr haben, damit der neue Ausdruck als falsch ausgewertet wird.

Wenn Ihnen diese Ergebnisse unklar erscheinen, gehen Sie zur weiteren Klärung einigetruth tablesdurch.

Sie können zusammengesetzte Anweisungen auch mit&&,|| und! schreiben:

!((-0.2 > 1.4) && ((0.8 < 3.1) || (0.1 == 0.1)))

Schauen Sie sich zuerst den innersten Ausdruck an:(0.8 < 3.1) || (0.1 == 0.1). Dieser Ausdruck ergibttrue, da beide mathematischen Aussagentrue sind.

Als nächstes nimmt Go den zurückgegebenen Werttrue und kombiniert ihn mit dem nächsten inneren Ausdruck:(-0.2 > 1.4) && (true). In diesem Beispiel wirdfalse zurückgegeben, da die mathematische Aussage-0.2 > 1.4 falsch ist und (false) und (true)false zurückgeben.

Schließlich haben wir den äußeren Ausdruck:!(false), der zutrue ausgewertet wird. Der endgültige Rückgabewert, wenn wir diese Anweisung ausdrucken, lautet also:

Outputtrue

Die logischen Operatoren&&,|| und! werten Ausdrücke aus und geben boolesche Werte zurück.

Wahrheitstabellen

Es gibt viel zu lernen über den logischen Zweig der Mathematik, aber Sie können einige davon selektiv lernen, um Ihr algorithmisches Denken beim Programmieren zu verbessern.

Das Folgende sind Wahrheitstabellen für den Vergleichsoperator== und jeden der Logikoperatoren&&,|| und!. Möglicherweise können Sie sie auch auswendig lernen, aber es kann auch hilfreich sein, sie auswendig zu lernen, um Ihren Programmierentscheidungsprozess zu beschleunigen.

`==` (gleich) Wahrheitstabelle

x	==	y	Kehrt zurück
true	==	true	true
true	==	falsch	falsch
falsch	==	true	falsch
falsch	==	falsch	true

Kehrt zurück

true

falsch

true

falsch

true

`&&` (und) Wahrheitstabelle

x	and	y	Kehrt zurück
true	and	true	true
true	and	falsch	falsch
falsch	and	true	falsch
falsch	and	falsch	falsch

and

Kehrt zurück

true

and

true

and

falsch

and

true

falsch

and

falsch

`||` (oder) Wahrheitstabelle

x	or	y	Kehrt zurück
true	or	true	true
true	or	falsch	true
falsch	or	true	true
falsch	or	falsch	falsch

Kehrt zurück

true

falsch

true

falsch

true

falsch

`!` (nicht) Wahrheitstabelle

not	x	Kehrt zurück
not	true	falsch
not	falsch	true

not

Kehrt zurück

not

true

falsch

not

falsch

true

Wahrheitstabellen sind gebräuchliche mathematische Tabellen, die in der Logik verwendet werden, und sind nützlich, um bei der Erstellung von Algorithmen (Anweisungen) in der Computerprogrammierung zu berücksichtigen.

Verwenden von Booleschen Operatoren zur Flusssteuerung

Um den Stream und die Ergebnisse eines Programms in Form von Flusssteuerungsanweisungen zu steuern, können Siecondition gefolgt vonclause verwenden.

Acondition wird bis zu einem Booleschen Wert von wahr oder falsch ausgewertet und zeigt einen Punkt an, an dem eine Entscheidung im Programm getroffen wird. Das heißt, eine Bedingung würde Ihnen sagen, ob etwas als wahr oder falsch bewertet wird.

clause ist der Codeblock, der aufcondition folgt und das Ergebnis des Programms bestimmt. Das heißt, es ist der Teil "do this" der Konstruktion "Wennxtrue ist, dann mach das."

Der folgende Codeblock zeigt ein Beispiel für Vergleichsoperatoren, die zusammen mit bedingten Anweisungen arbeiten, um den Ablauf eines Go-Programms zu steuern:

if grade >= 65 {                 // Condition
    fmt.Println("Passing grade") // Clause
} else {
    fmt.Println("Failing grade")
}

Dieses Programm bewertet, ob die Note jedes Schülers bestanden wird oder nicht. Bei einem Schüler mit einer Note von83 wird die erste Anweisung mittrue bewertet, und die Druckanweisung vonPassing grade wird ausgelöst. Bei einem Schüler mit einer Note von59 wird die erste Anweisung mitfalse bewertet, sodass das Programm die Druckanweisung ausführt, die an den Ausdruck else gebunden ist:Failing grade .

Boolesche Operatoren stellen Bedingungen dar, anhand derer das endgültige Ergebnis eines Programms über Flusssteuerungsanweisungen entschieden werden kann.

Fazit

In diesem Lernprogramm wurden Vergleichsoperatoren und logische Operatoren des Booleschen Typs sowie Wahrheitstabellen und die Verwendung von Booleschen Operatoren für die Programmflusssteuerung behandelt.

TOC

Grundlegendes zur Booleschen Logik in Go

Vergleichsoperatoren

Logische Operatoren

Wahrheitstabellen

`==` (gleich) Wahrheitstabelle

`&&` (und) Wahrheitstabelle

`||` (oder) Wahrheitstabelle

`!` (nicht) Wahrheitstabelle

Verwenden von Booleschen Operatoren zur Flusssteuerung

Fazit

Related

TOC

Grundlegendes zur Booleschen Logik in Go

Vergleichsoperatoren

Logische Operatoren

Wahrheitstabellen

== (gleich) Wahrheitstabelle

&& (und) Wahrheitstabelle

|| (oder) Wahrheitstabelle

! (nicht) Wahrheitstabelle

Verwenden von Booleschen Operatoren zur Flusssteuerung

Fazit

Related

`==` (gleich) Wahrheitstabelle

`&&` (und) Wahrheitstabelle

`||` (oder) Wahrheitstabelle

`!` (nicht) Wahrheitstabelle