One place for hosting & domains

      Sysadmin eBook: Como fazer servidores funcionarem


      Baixe o e-book completo!

      Como fazer servidores funcionarem: um guia prático para a administração de sistemas, eBook no formato EPUB

      Como fazer servidores funcionarem: um guia prático para a administração de sistemas, eBook no formato PDF

      Introdução ao e-book

      Este livro destaca habilidades práticas de administrador de sistema e arquiteturas comuns. Além disso, também ele aborda as melhores práticas aplicáveis aos sistemas de automatização e execução, em qualquer escala, de um notebook ou servidor para 1.000 ou mais. Ele foi criado para orientar você dentro da disciplina, e, com sorte, encorajar você a aprender mais sobre a administração de sistemas.

      Este livro baseia-se no programa Como fazer servidores funcionarem: um guia prático para a administração do sistema Linux, encontrado na Comunidade da DigitalOcean. O livro foi estruturado em torno de alguns tópicos centrais:

      1. Tópicos introdutórios

      2. Pilhas de tecnologia LAMP e LEMP

      3. Protegendo seus servidores

      4. Automação com o Ansible

      5. Controle de versão e integração contínua

      Sinta-se à vontade para escolher tópicos neste livro que lhe interessam e explore-os usando esses capítulos como guias. Trabalhar com este livro irá expor você a uma grande variedade de tecnologias, termos técnicos e abordagens conceituais para gerenciar servidores Linux. Aprenda de cada capítulo ou seção no seu próprio ritmo e na ordem que quiser.

      Baixe o e-book

      Baixe o e-book em formato EPUB ou PDF, seguindo os links abaixo.

      Baixe o e-book completo!

      Como fazer servidores funcionarem: um guia prático para a administração de sistemas, eBook no formato EPUB

      Como fazer servidores funcionarem: um guia prático para a administração de sistemas, eBook no formato PDF

      Para obter recursos adicionais sobre a administração de sistemas para ajudar você a começar, e para participar da comunidade DigitalOcean de outros desenvolvedores e administradores, confira nossa biblioteca crescente de tutoriais, perguntas e projetos com o sinalizador Getting Started (Começando).



      Source link

      Como instalar e utilizar a ferramenta Radamsa para fazer teste de fuzzing em programas e serviços de rede no Ubuntu 18.04


      O autor selecionou a Electronic Frontier Foundation, Inc para receber uma doação como parte do programa Write for DOnations.

      Introdução

      As ameaças de segurança estão se tornando cada vez mais sofisticadas, de modo que os desenvolvedores e administradores de sistemas precisam adotar uma abordagem proativa na defesa e teste da segurança de seus aplicativos.

      Um método comum para testar a segurança dos aplicativos cliente ou serviços de rede é o fuzzing, que envolve a transmissão de dados inválidos ou malformados repetidamente para o aplicativo e analisando sua resposta. Isso é útil para ajudar a testar a resiliência e a robustez do aplicativo a entradas inesperadas, que podem incluir dados corrompidos ou ataques reais.

      A Radamsa é uma ferramenta de fuzzing de código aberto que pode gerar casos de teste baseados em dados de entrada específicos do usuário. A Radamsa é totalmente passível de script e, até agora, tem sido bem-sucedida em encontrar vulnerabilidades em aplicativos reais, como o Gzip.

      Neste tutorial, você instalará e usará a Radamsa para fazer o teste de fuzzing da linha de comando e dos aplicativos baseados em rede, usando seus próprios casos de teste.

      Aviso: a Radamsa é uma ferramenta de teste de penetração que pode permitir que você identifique as vulnerabilidades ou pontos fracos em certos sistemas ou aplicativos. Você não deve usar as vulnerabilidades encontradas com a Radamsa para qualquer forma de comportamento inconsequente, exploração prejudicial ou mal-intencionada. As vulnerabilidades devem ser relatadas para o mantenedor do aplicativo afetado, de maneira ética e não ser divulgadas publicamente, sem permissão expressa.

      Pré-requisitos

      Antes de iniciar este guia, será necessário o seguinte:

      • Um servidor Ubuntu 18.04 configurado de acordo com o tutorial de Configuração Inicial do servidor com o Ubuntu 18.04, incluindo um usuário não raiz com privilégios sudo e firewall habilitado para bloquear portas não essenciais.
      • Um aplicativo de linha de comando ou baseado em rede que deseja testar, como o Gzip, Tcpdumb, Bind, Apache, jq ou qualquer outro aplicativo de sua escolha. A título de exemplo para este tutorial,usaremos o jq.

      Aviso: a Radamsa pode provocar a instabilidade ou a falha dos aplicativos ou sistemas em execução. Assim, somente execute a Radamsa em um ambiente em que você esteja preparado para essa situação, como num servidor dedicado, por exemplo. Além disso, assegure-se de que possui a devida permissão escrita do proprietário de um sistema, antes de realizar o teste de fuzzing em tal sistema.

      Assim que tiver tudo pronto, logue no seu servidor como usuário não raiz para começar.

      Passo 1 — Instalando a Radamsa

      Primeiro, você irá baixar e compilar a Radamsa para começar a usá-la no seu sistema. O código fonte da Radamsa está disponível no repositório oficial no GitLab.

      Comece atualizando o índice de pacotes local para refletir quaisquer novas alterações dos autores do código:

      Em seguida, instale os pacotes gcc, git, make e wget. Eles são necessários para compilar o código fonte em um binário executável:

      • sudo apt install gcc git make wget

      Após confirmar a instalação, a ferramenta apt irá baixar e instalar os pacotes especificados e todas as dependências necessárias.

      Em seguida, você irá baixar uma cópia do código fonte da Radamsa, clonando-o a partir do repositório hospedado no GitLab:

      • git clone https://gitlab.com/akihe/radamsa.git

      Isso criará um diretório chamado radamsa, que contém o código fonte do aplicativo. Vá para o diretório para começar a compilar o código:

      Em seguida, inicie o processo de compilação usando o make:

      Por fim, instale o binário da Radamsa compilado para o seu $PATH:

      Assim que terminar, verifique a versão instalada para garantir que tudo está funcionando:

      Sua saída será semelhante à seguinte:

      Output

      Radamsa 0.6

      Caso veja um erro radamsa: command not found (comando não encontrado), verifique novamente se todas as dependências necessárias foram instaladas e se não houve erros durante a compilação.

      Agora que instalou a Radamsa, comece a gerar alguns exemplos de casos para teste, a fim de entender como a Radamsa funciona e para o que ela pode ser usada.

      Passo 2 — Gerando casos para o teste de fuzzing

      Agora que a Radamsa foi instalada, utilize-a para gerar alguns casos para o teste de fuzzing.

      Um caso de teste é uma fração de dados que será usada como entrada para o programa que você estiver testando. Por exemplo, se estiver fazendo o teste de fuzzing em um programa de arquivamento como o Gzip. Como caso para teste, você pode usar um arquivo morto que estiver tentando descompactar.

      Nota: a Radamsa manipulará os dados de entrada de diversas formas inesperadas, inclusive através de repetição extrema, bit flips [manipulação de bits], controle de injeção de caractere e assim por diante. Isso pode provocar a interrupção ou a instabilidade de sua sessão no terminal; portanto, esteja ciente disso, antes de continuar.

      Primeiro, envie uma mensagem de texto simples para a Radamsa para ver o que acontece:

      • echo "Hello, world!" | radamsa

      Isso manipulará (ou confundirá) os dados inseridos e dará como resultado um caso de teste, por exemplo:

      Output

      Hello,, world!

      Neste caso, a Radamsa adicionou uma vírgula extra entre o Hello e o world. Pode não parecer uma alteração significativa, mas, em alguns aplicativos, pode levar à interpretação incorreta dos dados.

      Vamos tentar novamente, executando o mesmo comando. Você verá um outro resultado:

      Output

      Hello, '''''''wor'd!

      Dessa vez, várias aspas (') foram inseridas na string, incluindo uma que sobrescreveu-e à letra l da palavra world. Esse caso de teste em particular traz maior probabilidade de gerar problemas para um aplicativo, uma vez que as aspas simples/duplas são usadas com frequência para separar diferentes frações de dados em uma lista.

      Vamos testar mais uma vez:

      Output

      Hello, $+$PATHu0000`xcalc`world!

      Nesse caso, a Radamsa inseriu uma string de injeção do shell, o que será útil para testar as vulnerabilidades da injeção de comandos no aplicativo que você está testando.

      Você usou a Radamsa para fazer fuzz com uma string de entrada e produzir uma série de casos de teste. Em seguida, você usará a Radamsa para fazer o fuzz em um aplicativo de linha de comando.

      Passo 3 — Fazendo o fuzzing em um aplicativo de linha de comando

      Neste passo, você utilizará o Radamsa para fazer o fuzz em um aplicativo de linha de comando e informará sobre quaisquer falhas que ocorrerem.

      A técnica exata para o fuzzing em cada programa varia significativamente e métodos distintos serão mais eficazes para programas distintos. No entanto, neste tutorial utilizaremos o exemplo do jq, que é um programa de linha de comando para o processamento de dados JSON.

      Você pode usar qualquer outro programa similar, desde que ele siga o princípio geral de tomar alguma forma de dados estruturados ou não estruturados, fazendo algo com eles e em seguida, exibindo um resultado. Por exemplo, esse exemplo também funcionaria com o Gzip, Grep, bc, tr e assim por diante.

      Se ainda não tiver o jq instalado, instale-o usando a apt:

      O jq será instalado agora.

      Para começar o fuzzing, crie um arquivo de exemplo que você usará como a entrada para a Radamsa:

      Então, adicione os seguintes dados de exemplo em JSON ao arquivo:

      test.json

      {
        "test": "test",
        "array": [
          "item1: foo",
          "item2: bar"
        ]
      }
      

      Você pode analisar esse arquivo usando o jq caso queria verificar se a sintaxe JSON é válida:

      Se o JSON for válido, o jq exibirá o arquivo. Caso contrário, ele exibirá um erro, que você pode usar para corrigir a sintaxe, onde for necessário.

      Em seguida, faça o fuzz no arquivo de teste em JSON usando a Radamsa e, em seguida, envie-o para o jq. Isso fará com que o jq leia o caso de teste de fuzzing/para manipulação, em vez de dados originais JSON válidos:

      Se a Radamsa fizer o fuzzing dos dados JSON, de modo que ainda fiquem válidos – do ponto de vista sintático, o jq exibirá os dados, mas com as alterações que a Radamsa tiver feito neles.

      Como alternativa, se a Radamsa fizer com que os dados JSON se tornem inválidos, o jq exibirá um erro relevante. Por exemplo:

      Output

      parse error: Expected separator between values at line 5, column 16

      O resultado alternativo seria que o jq não conseguiria lidar corretamente com os dados que passaram por fuzzing, fazendo com que ele falhe ou que se comporte indevidamente. É precisamente isso o que você estará buscando alcançar com o fuzzing, uma vez que isso pode ser indicação de uma vulnerabilidade de segurança, tais como um estouro de buffer ou uma injeção de comando.

      Para testar as vulnerabilidades de maneira mais eficaz dessa maneira, um script Bash pode ser usado para automatizar o processo de fuzzing, incluindo a geração de casos de teste, passando-os para o programa alvo e capturando qualquer resultado relevante.

      Crie um arquivo chamado jq-fuzz.sh:

      O conteúdo exato do script irá variar, dependendo do tipo de programa em que você estiver fazendo o fuzzing e os dados de entrada. No caso do jq e de outros programas semelhantes, porém, o script a seguir será o suficiente.

      Copie o script em seu arquivo jq-fuzz.sh:

      jq-fuzz.sh

      #!/bin/bash
      while true; do
        radamsa test.json > input.txt
        jq . input.txt > /dev/null 2>&1
        if [ $? -gt 127 ]; then
          cp input.txt crash-`date +s%.%N`.txt
          echo "Crash found!"
        fi
      done
      

      Esse script contém um while para fazer o conteúdo entrar em um loop, repetidas vezes. A cada vez que o script entrar em loop, a Radamsa gerará um caso de teste, com base no test.json e o salvará no arquivo input.txt.

      Na sequência, o caso de teste, input.txt, será executado com o programa jq e todo o resultado – padrão e de erros – será redirecionado para o diretório /dev/null, a fim de evitar que a tela do terminal fique cheia.

      Por fim, o valor de saída do jq é verificado. Se o valor de saída for maior que 127, isso indica que houve um encerramento fatal (uma falha); em seguida, os dados de entrada são salvos – para revisão posterior – em um arquivo chamado crash-, seguido de carimbo de data do Unix, com a data atual em segundos e nanossegundos.

      Marque o script como executável e o coloque em funcionamento, de modo a iniciar o teste de fuzzing do jq, automaticamente:

      • chmod +x jq-fuzz.sh
      • ./jq-fuzz.sh

      Você pode teclar o CTRL+C a qualquer momento para terminar o script. Então, você pode verificar se foram encontradas falhas com o ls, a fim de exibir uma listagem de diretório, contendo quaisquer arquivos de falha que tiverem sido criados.

      Você pode querer melhorar seus dados de entrada JSON, uma vez que o uso de um arquivo de entrada mais complexo provavelmente melhoraria a qualidade de seus resultados de fuzzing. Evite utilizar um arquivo grande ou que contenha muitos dados repetidos—um arquivo pequeno seria a entrada ideal, mas que contenha o máximo de elementos ‘complexos’ possível. Por exemplo, um bom arquivo de entrada conterá amostras de dados armazenados em todos formatos, que incluem strings, números inteiros, booleanos, listas e objetos, bem como dados aninhados, sempre que possível.

      Você usou a Radamsa para fazer o fuzzing em um aplicativo de linha de comando. Em seguida, você usará a Radamsa para fazer o fuzz em serviços de rede.

      Passo 4 — Pedidos de fuzzing em serviços de rede

      A Radamsa também pode ser usada para fazer o fuzzing em serviços de rede, seja atuando como um cliente ou servidor de rede. Neste passo, você usará a Radamsa para fazer o fuzzing em um serviço de rede, com a Radamsa atuando como cliente.

      O objetivo do fuzzing em serviços de rede é testar o quão resiliente um determinado serviço de rede é para os clientes, enviando-lhe dados malformados ou mal-intencionados. Muitos serviços de rede – como servidores Web ou DNS – são geralmente expostos à Internet, o que significa que eles são um alvo comum para invasores. Um serviço de rede que não seja resistente o suficiente para receber dados malformados pode falhar ou, pior ainda, falhar em um estado aberto, o que permite que invasores leiam dados confidenciais, como chaves de criptografia ou dados do usuário.

      A técnica específica para o fuzzing em serviços de rede varia bastante, dependendo do serviço de rede em questão. No entanto, neste exemplo usaremos a Radamsa para fazer o fuzz em um servidor Web básico, servindo conteúdo de HTML estático.

      Primeiro, você precisa configurar o servidor Web para testes. Você pode fazer isso usando o servidor de desenvolvimento integrado que vem com o pacote php-cli. Você também precisará do curl para testar seu servidor Web.

      Se não tiver o php-cli e/ou o curl instalados, instale-os usando a ferramenta apt:

      • sudo apt install php-cli curl

      Em seguida, crie um diretório para armazenar seus arquivos do servidor Web e vá até ele:

      Então, crie um arquivo HTML que contenha uma amostra de texto:

      Adicione o que vem a seguir ao arquivo:

      index.html

      <h1>Hello, world!</h1>
      

      Agora, você pode executar seu servidor Web do PHP. Você precisará ser capaz de visualizar o registro do servidor Web, ao mesmo tempo que ainda continuará a usar outra sessão de terminal. Dessa maneira, abra outra sessão de terminal e de SSH para o seu servidor para este fim:

      • cd ~/www
      • php -S localhost:8080

      Isso irá gerar algo parecido com o seguinte:

      Output

      PHP 7.2.24-0ubuntu0.18.04.1 Development Server started at Wed Jan 1 16:06:41 2020 Listening on http://localhost:8080 Document root is /home/user/www Press Ctrl-C to quit.

      Agora, você pode retornar para a sessão de terminal original e testar se o servidor Web está funcionando, usando o curl:

      Isso exibirá o arquivo de exemplo index.html que você criou anteriormente:

      Output

      <h1>Hello, world!</h1>

      Seu servidor Web precisa estar acessível apenas localmente. Assim, você não deve abrir quaisquer portas no seu firewall para ele.

      Agora que você configurou seu servidor Web de teste, você pode iniciar o teste de fuzzing nele, usando a Radamsa.

      Primeiro, será necessário criar um exemplo de pedido de HTTP para usar como dados de entrada para a Radamsa. Crie um novo arquivo para armazenar isso em:

      Então, copie a seguinte amostra de pedido HTTP para o arquivo:

      http-request.txt

      GET / HTTP/1.1
      Host: localhost:8080
      User-Agent: test
      Accept: */*
      

      Em seguida, utilize a Radamsa para enviar esse pedido HTTP para o seu servidor Web local. Para fazer isso, você terá que usar a Radamsa como cliente TCP, o que pode ser feito especificando-se um endereço IP e porta à qual se conectar:

      • radamsa -o 127.0.0.1:8080 http-request.txt

      Nota: esteja ciente que usar a Radamsa como um cliente TCP possivelmente fará com que dados malformados/mal-intencionados sejam transmitidos pela rede. Isso pode interromper as coisas. Assim, tenha o cuidado de acessar somente as redes que você está autorizado a testar ou, de preferência, continue usando o endereço do localhost (127.0.0.1).

      Por fim, caso visualize os registros produzidos em relação ao seu servidor Web local, verá que ele recebeu os pedidos, mas provavelmente não os processou, já que eles eram inválidos/malformados.

      Os registros produzidos estarão visíveis em sua segunda janela de terminal:

      Output

      [Wed Jan 1 16:26:49 2020] 127.0.0.1:49334 Invalid request (Unexpected EOF) [Wed Jan 1 16:28:04 2020] 127.0.0.1:49336 Invalid request (Malformed HTTP request) [Wed Jan 1 16:28:05 2020] 127.0.0.1:49338 Invalid request (Malformed HTTP request) [Wed Jan 1 16:28:07 2020] 127.0.0.1:49340 Invalid request (Unexpected EOF) [Wed Jan 1 16:28:08 2020] 127.0.0.1:49342 Invalid request (Malformed HTTP request)

      Para obter resultados ideais e garantir que as falhas fiquem registradas, talvez você queira escrever um script de automação semelhante ao usado no Passo 3. Você deve considerar, ainda, o uso de um arquivo de entrada mais complexo, que possa conter adições, como a função de cabeçalhos HTTP extras.

      Você fez o fuzzing em um serviço de rede usando a Radamsa, que agiu como um cliente TCP. Em seguida você fará o fuzzing em um cliente de rede com a Radamsa atuando como um servidor.

      Passo 5 — Fazendo o fuzzing em aplicativos clientes de rede

      Neste passo, você usará a Radamsa para fazer o teste de fuzzing em um aplicativo cliente de rede. Isso pode ser feito através da interceptação das respostas de um serviço de rede e do fuzzing delas, antes de serem recebidas pelo cliente.

      O objetivo deste tipo de fuzzing é testar o quão resilientes os aplicativos cliente de rede são para receberem dados malformados ou mal-intencionados, vindos de serviços de rede. Por exemplo, testar um navegador Web (cliente) recebendo um HTML malformado de um servidor Web (serviço de rede), ou testar um cliente DNS recebendo respostas de DNS malformadas de um servidor DNS.

      Tal como aconteceu com o fuzzing de aplicativos de linha de comando ou de serviços de rede, a técnica exata para o fuzzing em cada aplicativo cliente de rede varia consideravelmente. No entanto, neste exemplo, você usará o whois, que é um aplicativo de envio/recebimento, baseado no protocolo TCP.

      O aplicativo whois é utilizado para fazer pedidos aos servidores WHOIS e receber registros WHOIS como resposta. O WHOIS opera pela porta TCP 43 em texto não criptografado, o que o torna um bom candidato para testes de fuzzing baseados em rede.

      Se ainda não tiver o whois instalado, instale-o usando a ferramenta apt:

      Primeiro, você precisará adquirir uma amostra de resposta do whois para usar como dados de entrada. Para tanto, você pode fazer um pedido whois e salvar o resultado em um arquivo. Aqui, você pode usar qualquer domínio que quiser, uma vez que estará testando o programa whois localmente, usando dados de amostra:

      • whois example.com > whois.txt

      Em seguida, você precisará configurar a Radamsa como um servidor que atenda versões dessa resposta do whois que já passaram pelo fuzzing. Uma vez que a Radamsa está executando em modo de servidor, você terá que conseguir continuar usando o seu terminal. Assim, é recomendável abrir outra sessão de terminal e outra conexão via protocolo SSH com o seu servidor para esse fim:

      • radamsa -o :4343 whois.txt -n inf

      Agora, a Radamsa estará executando em modo de servidor TCP e atenderá uma versão de whois.txt – que já passou por fuzzing – toda vez que uma conexão for feita no servidor, independentemente de quais dados da solicitação forem recebidos.

      Agora, você já pode prosseguir com o teste do aplicativo cliente whois. Você vai precisar fazer uma solicitação whois normal para um domínio de sua escolha (não precisa ser o mesmo para os quais os dados da amostra se destinam), mas com o whois apontado para o seu servidor local da Radamsa:

      • whois -h localhost:4343 example.com

      A resposta consistirá nos dados da sua amostra, mas que já passaram pelo processo de fuzzing da Radamsa. Desde que a Radamsa esteja em execução, você pode continuar a fazer pedidos para o servidor local, pois toda vez ele irá fornecer uma resposta diferente que já passou pelo fuzzing.

      Assim como ocorre no fuzzing em serviços de rede, para melhorar a eficiência esse teste de fuzzing do cliente de rede e assegurar que eventuais falhas sejam capturadas, talvez você queira escrever um script de automação semelhante ao usado no Passo 3.

      Neste passo final, você usou a Radamsa para realizar o teste de fuzzing de um aplicativo cliente de rede.

      Conclusão

      Neste artigo, você configurou a Radamsa e a usou para fazer o fuzzing em um aplicativo de linha de comando, um serviço de rede e um cliente de rede. Portanto, você já tem o conhecimento básico necessário para fazer o teste de fuzzing em seus próprios aplicativos, com a expectativa de aprimorar a robustez e a resistência deles a ataques.

      Se quiser explorar a Radamsa ainda mais, faça uma revisão detalhada do arquivo README da Radamsa, pois ele traz outras informações técnicas e exemplos de como a ferramenta pode ser usada:

      Confira também algumas outras ferramentas de fuzzing, como a American Fuzzy Lop (AFL), que é uma ferramenta de fuzzing avançada, desenvolvida para testar aplicativos binários em velocidade e com precisão extremamente elevadas.



      Source link

      Como fazer cálculos matemáticos com operadores em Go


      Introdução

      Os números são comuns na programação. Eles são usados para representar coisas como: dimensões de tela, localizações geográficas, dinheiro e pontos, a quantidade de tempo que passa em um vídeo, posições de avatares de jogos, cores através da atribuição de códigos numéricos e assim por diante.

      O desempenho eficaz das operações matemáticas na programação é uma habilidade importante a se desenvolver, tendo em vista a frequência com a qual você vai trabalhar com números. Embora a compreensão de alto grau da matemática possa ajudar você a ser um melhor programador, tal compreensão não é um pré-requisito. Se você não tiver experiência em matemática, tente pensar nela como uma ferramenta para realizar o que quiser alcançar e também como uma maneira de melhorar seu pensamento lógico.

      Trabalharemos com dois tipos de dados mais usados em Go – os números inteiros e os floats:

      • Os inteiros, como o próprio nome diz, são número inteiros que podem ser positivos, negativos, ou 0 (…, -1, 0, 1, …).
      • Os floats são números reais que contêm casas decimais, como 9.0, ou -2.25.

      Este tutorial irá rever os operadores que podemos usar com os tipos de dados no Go.

      Operadores

      Um operador é um símbolo ou função que indica uma operação. Por exemplo, na matemática o sinal de mais ou + é o operador que indica a adição.

      Na linguagem Go, vamos ver alguns operadores familiares que são trazidos da matemática. No entanto, outros operadores que usaremos são específicos para a programação de computadores.

      Aqui está uma tabela de referência rápida de operadores relacionados à matemática em Go. Neste tutorial, vamos falar sobre todas as operações a seguir.

      Operação O que ela retorna
      x + y Soma de x e y
      x - y Diferença entre x e y
      -x Muda o sinal de x
      +x Identidade de x
      x * y Produto de x e y
      x / y Quociente de x e y
      x % y Resto de x / y

      Também vamos abordar os operadores de atribuição de compostos, incluindo o += e *=, que combinam operadores matemáticos com o operador =.

      Adição e subtração

      Em Go, os operadores de adição e subtração são executados assim como fazem na matemática. De fato, você pode usar a linguagem de programação Go como uma calculadora.

      Vamos examinar alguns exemplos, começando com os inteiros:

      fmt.Println(1 + 5)
      

      Output

      6

      Em vez de enviar os inteiros diretamente para a instrução fmt.Println, podemos inicializar variáveis para representar os valores inteiros usando a sintaxe como segue:

      a := 88
      b := 103
      
      fmt.Println(a + b)
      

      Output

      191

      Como os inteiros podem ser números positivos e negativos (e também 0), podemos adicionar um número negativo a um número positivo:

      c := -36
      d := 25
      
      fmt.Println(c + d)
      

      Output

      -11

      A adição irá comportar-se de maneira parecida com os floats:

      e := 5.5
      f := 2.5
      
      fmt.Println(e + f)
      

      Output

      8

      Como adicionamos dois floats juntos, o Go retornou um valor float com uma casa decimal. No entanto, como a casa decimal é zero neste caso, a fmt.Println retirou a formatação decimal. Para formatar a saída corretamente, podemos usar fmt.Printf e o verbo %2f, que irá formatar para duas casas decimais, desta forma:

      fmt.Printf("%.2f", e + f)
      

      Output

      8.00

      A sintaxe da subtração é a mesma que a da adição, exceto que mudamos o operador do sinal de mais (+) para o sinal de menos (-):

      g := 75.67
      h := 32.0
      
      fmt.Println(g - h)
      

      Output

      43.67

      Em Go, podemos usar somente os operadores nos mesmos tipos de dados. Não podemos somar um int e um float64:

      i := 7
      j := 7.0
      fmt.Println(i + j)
      

      Output

      i + j (mismatched types int and float64)

      Tentar usar os operadores em tipos de dados diferentes resultará em um erro de compilação.

      Operações aritmética unárias

      Uma expressão matemática unária consiste de apenas um componente ou elemento. Na linguagem Go, podemos usar os sinais mais e menos, como um único elemento com um valor para: retornar a identidade do valor (+), ou alterar o sinal do valor (-).

      Embora não seja comumente usado, o sinal mais indica a identidade do valor. Podemos usar o sinal de mais com valores positivos:

      i := 3.3
      fmt.Println(+i)
      

      Output

      3.3

      Ao usarmos o sinal de mais com um valor negativo, ele também retornará a identidade daquele valor e, neste caso, seria um valor negativo:

      j := -19
      fmt.Println(+j)
      

      Output

      -19

      Com um valor negativo, o sinal de mais retorna o mesmo valor negativo.

      No entanto, o sinal de menos muda o sinal de um valor. Então, quando enviarmos um valor positivo, vamos descobrir que o sinal de menos antes do valor retornará um valor negativo:

      k := 3.3
      fmt.Println(-k)
      

      Output

      -3.3

      De forma alternativa, quando usamos o operador unário de sinal menos com um valor negativo, será retornado um valor positivo:

      j := -19
      fmt.Println(-j)
      

      Output

      19

      As operações aritméticas unárias, indicadas pelo sinal de mais e de menos retornarão a identidade do valor no caso de +i ou o sinal oposto do valor como em -i.

      Multiplicação e divisão

      Como na adição e na subtração, a multiplicação e a divisão ficarão muito semelhantes à forma como elas funcionam na matemática. O sinal que usaremos para a multiplicação no Go é * e o sinal que usaremos para a divisão é a /.

      Aqui está um exemplo de como fazer uma multiplicação em Go com dois valores float:

      k := 100.2
      l := 10.2
      
      fmt.Println(k * l)
      

      Output

      1022.04

      Em Go, a divisão tem características diferentes, dependendo do tipo numérico que estivermos dividindo.

      Se estivermos dividindo números inteiros, o operador / do Go executará a divisão com arredondamento para baixo, onde para o quociente x, o número retornado será o maior número inteiro menor que ou igual a** x**.

      Se você executar o exemplo a seguir, fazendo a divisão 80 / 6, receberá 13 como o resultado e o tipo de dados será um int:

      package main
      
      import (
          "fmt"
      )
      
      func main() {
          m := 80
          n := 6
      
          fmt.Println(m / n)
      }
      

      Output

      13

      Se o resultado desejado for um float, você precisa converter explicitamente os valores antes da divisão.

      Você pode fazer isso envolvendo seus valores com o seu tipo float desejado de float32() ou float64():

      package main
      
      import (
          "fmt"
      )
      
      func main() {
          s := 80
          t := 6
          r := float64(s) / float64(t)
          fmt.Println(r)
      }
      

      Output

      13.333333333333334

      Módulo

      O operador % é o módulo que, após a divisão, retorna o resto em vez do quociente. Isso é útil para a descoberta de números que sejam múltiplos do mesmo número.

      Vamos examinar um exemplo do módulo:

      o := 85
      p := 15
      
      fmt.Println(o % p)
      

      Output

      10

      Desdobrando isso tudo, temos que 85 dividido por 15 retorna o quociente 5 com um resto de 10. Nosso programa retorna o valor 10 aqui, uma vez que o operador módulo retorna o resto de uma expressão de divisão.

      Para fazer cálculos de módulos com tipos de dados float64, você usará a função Mod do pacote math:

      package main
      
      import (
          "fmt"
          "math"
      )
      
      func main() {
          q := 36.0
          r := 8.0
      
          s := math.Mod(q, r)
      
          fmt.Println(s)
      }
      

      Output

      4

      Precedência de operador

      Na linguagem Go, assim como na matemática, precisamos ter em mente que os operadores serão avaliados por ordem de precedência e não da esquerda para a direita ou da direta para a esquerda.

      Se examinarmos a seguinte expressão matemática:

      u = 10 + 10 * 5
      

      Podemos lê-la da esquerda para a direita, mas a multiplicação será feita primeiro; assim, se tivéssemos que imprimir u, receberíamos o seguinte valor:

      Output

      60

      Isso acontece porque 10 * 5 é igual a 50 e, em seguida, adicionamos 10 para retornar 60 como o resultado final.

      Se, em vez disso, quiséssemos somar o valor de 10 a 10 e depois multiplicássemos aquela soma por 5, usaríamos parênteses em Go, assim como faríamos na matemática:

      u := (10 + 10) * 5
      fmt.Println(u)
      

      Output

      100

      Uma maneira de lembrar a ordem da operação é através do acrônimo PEMDAS:

      Ordem Letra Representa
      1 P Parênteses
      2 E Expoente
      3 M Multiplicação
      4 D Divisão
      5 A Adição
      6 S Subtração

      Você pode estar familiarizado com outro acrônimo para a ordem das operações, como o BEDMAS ou BODMAS. Qualquer que seja o acrônimo que funcione melhor para você, procure tê-lo em mente ao realizar operações matemáticas em Go para que os resultados que você espera sejam retornados.

      Operadores de atribuição

      O operador de atribuição mais comum é aquele que você já usou: o sinal igual =. O operador de atribuição = atribui o valor à direita para uma variável à esquerda. Por exemplo, o v = 23 atribui o valor do inteiro 23 à variável v.

      Ao programar, é comum usar operadores de atribuição compostos que realizam uma operação no valor de uma variável e, depois, atribuem o novo valor resultante para aquela variável. Esses operadores compostos combinam um operador aritmético com o operador =. Portanto, para a adição vamos combinar + com = para obter o operador composto +=. Vejamos como fica:

      w := 5
      w += 1
      fmt.Println(w)
      

      Output

      6

      Primeiro, definimos a variável w igual ao 5 e, depois, usamos o operador de atribuição composto += para somar o número da direita ao valor da variável à esquerda; em seguida, atribuímos o resultado para w.

      Os operadores de atribuição compostos são usados frequentemente no caso de loops for, que você usará quando quiser repetir um processo várias vezes:

      package main
      
      import "fmt"
      
      func main() {
      
          values := []int{0, 1, 2, 3, 4, 5, 6}
      
          for _, x := range values {
      
              w := x
      
              w *= 2
      
              fmt.Println(w)
          }
      
      }
      

      Output

      0 2 4 6 8 10 12

      Ao usar um loop for para iterar na fatia chamada valores, você pôde automatizar o processo do operador *=, o qual multiplicou a variável w pelo número 2 e, então, atribuiu o resultado de volta para a variável w.

      Go tem um operador de atribuição composto para cada um dos operadores aritméticos discutidos neste tutorial.

      Para adicionar e, então, atribuir o valor:

      y += 1
      

      Para subtrair e, então, atribuir o valor:

      y -= 1
      

      Para multiplicar e, então, atribuir o valor:

      y *= 2
      

      Para dividir e, então, atribuir o valor:

      y /= 3
      

      Para retornar o resto e, então, atribuir o valor:

      y %= 3
      

      Os operadores de atribuição compostos podem ser úteis quando as coisas precisam ser aumentadas ou diminuídas, de maneira incremental, ou quando você precisar automatizar certos processos em seu programa.

      Conclusão

      Este tutorial tratou de muitos dos operadores que você usará com os tipos de dados numéricos inteiros e float. Você pode aprender mais sobre os diferentes tipos de dados em Entendendo tipos de dados em Go e em Como converter tipos de dados.



      Source link