One place for hosting & domains

      lógica

      Entendendo a lógica booleana em Go


      O tipo de dados Booleano (bool) pode ser um de dois valores, verdadeiro ou falso. Os Booleanos são usados na programação para fazer comparações e controlar o fluxo do programa.

      Os Booleanos representam os valores de verdade que estão associados ao ramo lógico da matemática, que informa algoritmos na ciência da computação. Nomeado em homenagem ao matemático George Boole, a palavra Booleano sempre começa com um B maiúsculo.

      O tipo de dados em Go para Booleanos é bool, escrito em letras minúsculas. Os valores true [verdadeiro] e false [falso] sempre estarão com as letras t e f, respectivamente em minúsculas, já que eles são valores especiais em Go.

      Este tutorial irá abordar os fundamentos básicos necessários para entender como o tipo de dados bool funciona, incluindo a comparação Booleana, operadores lógicos e tabelas de verdade.

      Operadores de comparação

      Em programação, os operadores de comparação são usados para comparar valores e avaliá-los em um único valor Booleano de verdadeiro ou falso.

      A tabela abaixo mostra operadores de comparação Booleanos.

      OperadorO que significa
      ==Igual a
      ! =Não igual a
      <Menor que
      >Maior que
      <=Menor ou igual a
      >=Maior ou igual a

      Para entender como esses operadores funcionam, vamos atribuir dois números inteiros a duas variáveis em um programa em Go:

      x := 5
      y := 8
      

      Neste exemplo, já que x tem o valor de 5, ele é menor que y que tem o valor de 8.

      Usando essas duas variáveis e seus valores associados, vamos examinar cuidadosamente os operadores da tabela anterior. Neste programa, você pedirá ao Go para imprimir se cada operador de comparação avalia como verdadeiro ou falso. Para ajudar a entender melhor esse resultado, você também fará o Go imprimir uma string para mostrar o que está avaliando:

      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)
      }
      

      Output

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

      De acordo com a lógica matemática, o Go avaliou o seguinte das expressões:

      • 5 (x) é igual a 8 (y)? falso
      • 5 não é igual a 8? verdadeiro
      • 5 é menor que 8? verdadeiro
      • 5 é maior que 8? falso
      • 5 é menor ou igual a 8? verdadeiro
      • 5 não é menor ou igual a 8? falso

      Embora os inteiros foram usados aqui, você poderia substituí-los por valores float.

      As strings também podem ser usadas com operadores Booleanos. Elas diferenciam maiúsculas de minúsculas, a menos que você utilize um método string adicional.

      Você pode examinar como as strings são comparados na prática:

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

      Output

      Sammy == sammy: false

      A string Sammy não é igual à string sammy, porque elas não são exatamente as mesmas; uma começa com uma maiúscula S e a outra com uma minúscula s. Mas, se você adicionar outra variável à qual for atribuído o valor de Sammy, então, elas avaliarão para iguais:

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

      Output

      Sammy == sammy: false Sammy == alsoSammy true

      Você também pode usar outros operadores de comparação incluindo > e < para comparar duas strings. O Go irá comparar essas strings lexicograficamente, usando os valores ASCII dos caracteres.

      Você também pode avaliar valores Booleanos com operadores de comparação:

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

      Output

      t != f: true

      O bloco de código anterior avaliou que true não é igual a false.

      Note a diferença entre os dois operadores = e ==.

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

      O primeiro = é o operador de atribuição, que definirá um valor como sendo igual a outro. O segundo, ==, é um operador de comparação e irá avaliar se dois valores são iguais.

      Operadores lógicos

      Há dois operadores lógicos que são usados para comparar valores. Eles avaliam expressões em valores Booleanos, retornando true ou false. Esses operadores são &&, || e ! e são definidos na lista abaixo:

      • && (x && y) é o operador and. Será verdade se ambas as declarações forem verdadeiras.
      • || (x || y) é o operador or. Será verdade se pelo menos uma declaração for verdadeira.
      • ! (! x) é o operador not. Será verdade apenas se a instrução for falsa.

      Os operadores lógicos são normalmente usados para avaliar se duas ou mais expressões são verdadeiras ou não verdadeiras. Por exemplo, eles podem ser usados para determinar se a nota é de aprovação e se o estudante está inscrito no curso; além disso, se ambos os casos forem verdadeiros, então o estudante receberá uma nota no sistema. Outro exemplo seria determinar se um usuário é um cliente ativo válido de uma loja online, com base em se eles têm o crédito da loja, ou fizeram uma compra nos últimos 6 meses.

      Para entender como os operadores lógicos funcionam, vamos avaliar três expressões:

      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
      

      Output

      true true true

      No primeiro caso, fmt.Println((9 > 7) && (2 < 4)), ambos 9 > 7 e 2 < 4 precisavam avaliar como verdadeiros, já que o operador and foi usado.

      No segundo caso, fmt.Println((8 == 8)) || 6 ! = 6)), como 8 = = 8 avaliou como verdadeiro, não fez diferença que 6 ! = 6 avaliou como falso, pois o operador or foi usado. Se você tivesse usado o operador and, isso avaliaria como falso.

      No terceiro caso, fmt.Println(!( 3 <= 1)), o operador not nega o valor falso retornado de 3 <=1.

      Vamos substituir os números floats por inteiros e almejar avaliações de falso:

      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
      

      Neste exemplo:

      • and deve ter pelo menos uma expressão falsa avaliar como falso.
      • em relação a or, ambas as expressões devem avaliar como falso.
      • ! deve ter sua expressão interna como verdade, a fim de que a nova expressão avalie como falso.

      Se esses resultados não ficaram claros para você, consulte algumas tabelas de verdade para obter mais esclarecimentos.

      Você também pode escrever instruções compostas usando &&, || e !:

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

      Primeiramente, examine a expressão mais próxima ao centro: (0.8 < 3.1) || (0.1 == 0.1). Essa expressão avalia como true porque ambas as declarações matemáticas são true.

      Em seguida, o Go pega o valor retornado true e o combina à próxima expressão interna: (-0.2 > 1.4) && (true). Esse exemplo retorna false porque a declaração matemática -0.2 > 1.4 é falsa e (false) e (true) retornam false.

      Por fim, temos a expressão exterior: !( false), que é avaliada como true, então o valor final retornado se imprimirmos essa declaração será:

      Output

      true

      Os operadores lógicos &&, || e ! avaliam expressões e retornam valores Booleanos.

      Tabelas de verdade

      Há muito a se aprender sobre o ramo da lógica na matemática, mas você pode aprender um pouco a respeito de modo seletivo, a fim de aprimorar o seu pensamento algorítmico ao programar.

      A seguir, apresentamos tabelas verdade para o operador de comparação == e cada um dos operadores lógicos &&, || e !. Embora você possa ser capaz de entendê-los, também pode ser útil memorizá-los, já que isso pode tornar seu processo de decisão na programação mais rápido.

      == (equal) Tabela verdade

      x==yRetorna
      verdadeiro==verdadeiroverdadeiro
      verdadeiro==falsofalso
      falso==verdadeirofalso
      falso==falsoverdadeiro

      && (and) Tabela verdade

      xand (e)yRetorna
      verdadeiroand (e)verdadeiroverdadeiro
      verdadeiroand (e)falsofalso
      falsoand (e)verdadeirofalso
      falsoand (e)falsofalso

      || (ou) Tabela verdade

      xouyRetorna
      verdadeiroouverdadeiroverdadeiro
      verdadeirooufalsoverdadeiro
      falsoouverdadeiroverdadeiro
      falsooufalsofalso

      ! (não) Tabela verdade

      nãoxRetorna
      nãoverdadeirofalso
      nãofalsoverdadeiro

      As tabelas verdade são tabelas matemáticas comuns usadas em lógica. Elas são úteis de se ter em mente durante a criação de algoritmos (instruções) em programação de computadores.

      Usando os operadores Booleanos para o controle de fluxo

      Para controlar o fluxo e os resultados de um programa na forma de instruções de controle de fluxo, você pode usar uma condição seguida de uma cláusula.

      Uma condição avalia em relação a um valor Booleano de verdadeiro ou falso, apresentando um ponto em que uma decisão será tomada no programa. Ou seja, uma condição diria a você se algo avalia em relação a verdadeiro ou falso.

      A cláusula é o bloco de código que vem após a condição e determina o resultado do programa. Ou seja, trata-se da parte “faça isso” da construção “Se x é true, então, faça isso”.

      O bloco de código abaixo mostra um exemplo de operadores de comparação que funcionam um depois do outro, com instruções condicionais para controlar o fluxo de um programa em Go:

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

      Esse programa irá avaliar se cada nota do estudante é de aprovação ou reprovação. No caso de um estudante com uma nota de 83, a primeira instrução avaliará como true e a instrução de impressão da Passing grade (nota de aprovação) será acionada. No caso de um estudante com uma nota de 59, a primeira instrução avaliará como false, então o programa seguirá em frente para executar a instrução de impressão vinculada à expressão else: Failing grade (nota de reprovação).

      Os operadores Booleanos apresentam condições que podem ser usadas para decidir o resultado eventual de um programa através de instruções de controle de fluxo.

      Conclusão

      Este tutorial trouxe explicações sobre os operadores de comparação e de lógica que pertencem ao tipo Booleano, além de tabelas verdade e o uso dos Booleanos para o controle de fluxo de programa.



      Source link

      Información sobre la lógica de booleanos en Go


      El tipo de datos “Boolean” (​​​​​​bool​​​​​​) puede ser uno de dos valores, ya sea true (verdadero) o false (falso). Los booleanos se utilizan en programación para realizar comparaciones y controlar el flujo de los programas.

      Los booleanos representan los valores de verdad que se asocian con la rama lógica de la matemática, que informa algoritmos en la Informática. La palabra “Boolean”, en honor al matemático George Boole, siempre comienza con B mayúscula.

      El tipo de datos en Go para “Boolean” es bool, que se escribe por completo en minúsculas. Los valores true y false siempre aparecerán con t y f minúsculas respectivamente, ya que son valores especiales en Go.

      En este tutorial, se abordarán los aspectos básicos que necesitará para comprender el funcionamiento del tipo de datos bool, que incluye la comparación booleana, los operadores lógicos y las tablas de verdad.

      Operadores de comparación

      En el ámbito de la programación, los operadores de comparación se utilizan para comparar valores y realizar evaluaciones hasta un único valor “Boolean” verdadero o falso.

      En la siguiente tabla se muestran operadores de comparación “Boolean”.

      OperadorQue significa
      ==Igual a
      ! =No es igual a
      <Menor que
      >Mayor que
      <=Menor o igual que
      >=Mayor o igual que

      Para entender el funcionamiento de estos operadores, asignaremos dos números enteros a dos variables en un programa de Go:

      x := 5
      y := 8
      

      En este ejemplo, dado que x tiene el valor 5, es inferior a y, que tiene el valor 8.

      Usando estas dos variables y sus valores asociados, repasemos los operadores de la tabla anterior. A través de este programa, solicitará a Go que realice impresiones si cada operador de comparación hace evaluaciones con verdadero o falso. Para ayudar a entender mejor este resultado, también solicitará a Go imprimir una cadena que muestre lo que evalúa:

      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)
      }
      

      Output

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

      Siguiendo la lógica matemática, Go evaluó lo siguiente de las expresiones:

      • ¿Es 5 (x) igual a 8 (y)? false
      • ¿5 no es igual a 8? true
      • ¿5 es menor que 8? true
      • ¿5 es mayor que 8? false
      • ¿5 es menor o igual que 8? true
      • ¿5 no es menor o igual que 8? false

      Si bien en este caso se utilizaron enteros, podría sustituirlos por valores flotantes.

      Las cadenas también pueden utilizarse con operadores “Boolean”. Se distinguen mayúsculas y minúsculas, a menos que utilice un método de cadena adicional.

      Podrá ver cómo se comparan las cadenas en la práctica:

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

      Output

      Sammy == sammy: false

      La cadena Sammy no es igual a la cadena sammy, ya que su similitud no es absoluta; una comienza con S mayúscula y la otra con s minúscula. Sin embargo, si añade otra variable que tenga asignado el valor Sammy, entonces se evaluarán como iguales:

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

      Output

      Sammy == sammy: false Sammy == alsoSammy true

      También puede usar los otros operadores de comparación, incluidos > y < para comparar dos cadenas. Go comparará estas cadenas de forma lexicográfica usando los valores ASCII de los caracteres.

      También puede evaluar valores “Boolean” con operadores de comparación:

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

      Output

      t != f: true

      El bloque de código anterior evaluó que true no es igual a false.

      Observe la diferencia entre los dos operadores = y ==.

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

      El primero = es el operador de asignación, que establecerá un valor igual a otro. El segundo, ==, es un operador de comparación y evaluará si dos valores son iguales.

      Operadores lógicos

      Existen dos operadores lógicos que se utilizan para comparar valores. Evalúan las expresiones hasta los valores “Boolean” y muestran true o false. Estos operadores son &&, || y !, y se definen en la siguiente lista:

      • && (x && y) es el operador and. Es verdadero si ambas instrucciones lo son.
      • || (x || y) es el operador or. Es verdadero si al menos una instrucción lo es.
      • ! (! x) es el operador not. Sólo es verdadero si la instrucción es falsa.

      Los operadores lógicos suelen utilizarse para evaluar si dos o más expresiones son verdaderas o no. Por ejemplo, pueden utilizarse para determinar si una calificación es aprobatoria y que el estudiante está registrado en el curso, y si ambos son verdaderos entonces se le asignará al alumno una calificación en el sistema. Otro ejemplo implicaría determinar si un usuario es un cliente activo válido de una tienda en línea,basándose en la posibilidad de que tenga crédito con la tienda o haya realizado una compra en los últimos 6 meses.

      Para entender el funcionamiento de los operadores lógicos, evaluaremos tres expresiones:

      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
      

      Output

      true true true

      En el primer caso, fmt.Println((9 > 7) && (2 < 4)), tanto 9 > 7 como 2 < 4 debieron evaluarse como verdaderas, ya que se utilizó el operador and.

      En el segundo caso, fmt.Println((8 == 8) || (6 ! = 6)), ya que 8 == 8 se evaluó como verdadero; no marcó una diferencia que 6 != 6 se evalúe como falso porque se utilizó el operador or. Si hubiera utilizado el operador and​​​ , esto se evaluaría como falso.

      En el tercer caso, fmt.Println(!(3 <= 1)), el operador not niega el valor falso que 3 <=1 muestra.

      Sustituiremos los flotantes por enteros y buscaremos evaluaciones falsas:

      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
      

      En este ejemplo:

      • Para and debe haber al menos una expresión falsa evaluada como falsa.
      • Para or, ambas expresiones deben evaluarse como falsas.
      • La expresión interna de ! debe ser verdadera para que la nueva expresión se evalúe como falsa.

      Si estos resultados le parecen confusos, revise algunas tablas de verdad para aclarar conceptos.

      También puede escribir instrucciones compuestas usando &&, || y !:

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

      Primero, observe la expresión más interna: (0.8 < 3.1) || (0.1 == 0.1). Esta expresión se evalúa como true porque ambas instrucciones matemáticas son true.

      A continuación, Go utiliza el valor mostrado true y lo combina con la siguiente expresión interior: (-0.2 > 1.4) && (true). En este ejemplo se muestra false, ya que la instrucción matemática -0.2 > 1.4 es falsa, y (false) y (true) muestran false.

      Por último, se encuentra la expresión externa: !( false), que se evalúa como true, por lo que el valor mostrado al final, si imprimimos esta instrucción, es el siguiente:

      Output

      true

      Los operadores lógicos &&, || y ! evalúan las expresiones y muestran los valores “Boolean”.

      Tablas de verdad

      Hay mucho que aprender sobre la rama lógica de la matemática, pero puede aprender de forma selectiva algo de esto para mejorar su pensamiento algorítmico a la hora de crear programas.

      Las siguientes son tablas de verdad para el operador de comparación == y cada uno de los operadores lógicos &&, || y !. Aunque pueda ser capaz de encontrar una explicación para ellos, también puede resultar útil memorizarlos, ya que esto puede agilizar su proceso de toma de decisiones para la programación.

      Tabla de verdad de == (equal)

      x==yResultado
      true==truetrue
      true==falsefalse
      false==truefalse
      false==falsetrue

      Tabla de verdad de && (and)

      xandyResultado
      trueandtruetrue
      trueandfalsefalse
      falseandtruefalse
      falseandfalsefalse

      Tabla de verdad de || (or)

      xoryResultado
      trueortruetrue
      trueorfalsetrue
      falseortruetrue
      falseorfalsefalse

      Tabla de verdad de ! (not)

      notxResultado
      nottruefalse
      notfalsetrue

      Las tablas de verdad son tablas matemáticas comunes que se emplean en la lógica y resulta útil tomarlas en cuenta al crear algoritmos (instrucciones) en el campo de la programación informática.

      Uso de operadores “Boolean” para el control de flujo

      Para controlar el flujo y los resultados de un programa en la forma de instrucciones de control de flujo, puede usar una condición seguida de una* cláusula*.

      Una condición evalúa hasta un valor “Boolean” verdadero o falso y se presenta un punto en el que se toma una decisión en el programa. Es decir, una condición le mostraría si algo se evalúa a verdadero o falso.

      La cláusula es el bloque de código que sigue la condición y dicta el resultado del programa. Es decir, es la parte “hacer esto” de la construcción “Si x es true, hacer esto”.

      En el bloque de código que se muestra a continuación se muestra un ejemplo de operadores de comparación trabajando en equipo con instrucciones condicionales para controlar el flujo de un programa de Go:

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

      Este programa evaluará si la calificación de cada estudiante es aprobatoria o reprobatoria. En el caso de un estudiante con una calificación de 83, la primera instrucción se evaluará a true y se activará la instrucción de impresión de Passing grade. En el caso de un estudiante con una calificación de 59, la primera instrucción se evaluará a false, por lo que el programa proseguirá con la ejecución de la instrucción de impresión vinculada a la expresión “else”: Failing grade.

      Los operadores “Boolean” presentan condiciones que pueden utilizarse para decidir el resultado final de un programa a través de instrucciones de control de flujo.

      Conclusión

      En este tutorial, repasamos la comparación y los operadores lógicos pertenecientes al tipo “Boolean”, así como las tablas de verdad y el uso de booleanos para el control de flujo de un programa.



      Source link