30:T471,As operações aritméticas (cálculos) funcionam de forma diferente para cada tipo de dado. Quando tratamos de dados numéricos (`int` e `float`), elas irão acontecer da forma como esperamos, com os princípios básicos da própria aritmética. Mas quando falamos de *booleanas* ou *Strings*, as coisas ficam um pouco diferentes. As quatro operações básicas são expressas da seguinte forma na programação: **Adição** ```js let a = 10; let b = 5; let c = a + b; // c = 15 let d = 50; let e = 100; let f = 40; let g = d + e + f; // g = 190 ``` **Subtração** ```js let a = 10; let b = 7 let c = a - b; // c = 3 let d = 50; let e = 100; let f = 40; let g = d - e - f; // g = -90 ``` **Multiplicação** ```js let a = 10; let b = 3 let c = a * b; // c = 30 let d = 5; let e = 10; let f = 2; let g = d * e * f; // g = 100 ``` **Divisão** ```js let a = 10; let b = 2 let c = a / b; // c = 5 let d = 100; let e = 5; let f = 2; let g = d / e / f; // g = 10 ``` E, logicamente, é possível misturá-las e utilizar parênteses para indicar a ordem das operações: ```js let z = a * ((b + 10) - ((c * d)/2)) / (e / f); ```31:[] 2e:{"title":"Operações","cells":[{"id":0,"value":"# Operações","pinned":false,"hidden":false,"mode":"md"},{"id":5,"value":"### Primeiros procedimentos utilizando variáveis","pinned":false,"hidden":false,"mode":"md"},{"id":8,"value":"\n----\n","pinned":false,"hidden":false,"mode":"md"},{"id":150,"value":"A primeira coisa que você fará com as variáveis é realizar operações sobre elas. Há pelo menos 2 tipos de operações nas linguagens de programação: as operações aritméticas (cálculos), e as operações lógicas, responsáveis em grande parte pelo fluxo e encaminhamento dos acontecimentos ao longo do seu código.","pinned":false,"hidden":false,"mode":"md"},{"id":272,"value":"

\n\n### Operações aritiméticas\n\n---\n","pinned":false,"hidden":false,"mode":"md"},{"id":287,"value":"$30","pinned":false,"hidden":false,"mode":"md"},{"id":347,"value":"Novamente, isto tudo é muito abstrato... mas para quê tudo isso serve? Vamos a um exemplo concreto utilizando a biblioteca gráfica P5.js:\n","pinned":false,"hidden":false,"mode":"md"},{"id":349,"value":"

","pinned":false,"hidden":false,"mode":"html"},{"id":354,"value":"Na linha `16` realizamos uma operação sobre a variável `x1`: seu valor anterior é acrescido de `2` cada vez que a *função* `draw()` é executada (algo em torno de 30 vezes por segundo). Um pouco antes disso a instrução `line()` é executada, e desenha uma linha utilizando a variável `x1` como referência horizontal para uma das coordenadas dela. Esta posição (definida por `x1`) vai sendo alterada com o tempo, e o desenho vai ser formando.","pinned":false,"hidden":false,"mode":"md"},{"id":366,"value":"Há alguns *shortcuts* para operações aritméticas muito frequentes: somas e subtrações unitárias.\n\nPara somar 1 ao valor de uma variável, você pode utilizar `++` após ela:\n\n```js\nlet x = 10;\nx++; // x = 11\n```\n\nPara subtrair 1 ao valor de uma variável, você pode utilizar `--` após ela:\n\n```js\nlet y = 11;\ny--; // y = 9\n```","pinned":false,"hidden":false,"mode":"md"},{"id":305,"value":"Uma outra operação, a de **resto de divisão** também está disponível e poderá ser bastante útil para lidar com algumas questões na programação. Esta operação devolve o valor do resto na operação de divisão entre inteiros. Ela é realizada desta forma:\n\n```js\nlet r1 = 8 % 3; // r = 2\nlet r2 = 11 % 3; // r = 2\nlet r3 = 7 % 2; // r = 1\n\nlet parouimpar = v % 2;\n// se 0 é par, se 1 é impar\n```","pinned":false,"hidden":false,"mode":"md"},{"id":316,"value":"Potências são calculadas através do operador `**` e raízes quadradas podem ser calculadas utilizando `0.5` como potência, ou pela instrução `Math.sqrt()`:\n\n```js\nlet pt = 5 ** 2; // pt = 25\nlet or = pt ** (1/2); // or = 5\nlet or2 = Math.sqrt(pt); // or2 = 5 \n```","pinned":false,"hidden":false,"mode":"md"},{"id":331,"value":"☞ *Outros tipos de cálculo como senos, cossenos, tangentes, logaritmos, etc., são todos feitos através de funções do objeto* `Math`. *Funções e objetos serão assuntos de capítulos mais à frente.*","pinned":false,"hidden":false,"mode":"md"},{"id":432,"value":"Se utilizarmos uma variável *booleana* em uma operação aritmética, ela se comportará como um número, onde `false` será equivalente a `0`, e `true` a `1`;\n\n```js\nlet a = true;\nlet b = 10;\nlet c = a + b; // c = 11\n```","pinned":false,"hidden":false,"mode":"md"},{"id":414,"value":"Já quando somamos duas *strings*, o resultado que temos é uma concatenação dos conteúdos. Não há subtração, multiplicação ou divisão de *strings*, e qualquer operação neste sentido, produzirá um erro no código.\n\nPara a concatenação, trabalhamos como se realizássemos uma operação aritmética comum:\n\n```js\nlet t1 = \"Olá.\";\nlet t2 = \"Bom dia!\";\nlet c = t1 + t2; // c = \"Olá.Bom dia!\"\nlet c2 = t1 + \" \" + t2; // c2 = \"Olá. Bom dia!\"\n```","pinned":false,"hidden":false,"mode":"md"},{"id":429,"value":"Ao se somar uma variável *booleana* com uma *string*, o valor da variável *booleana* será convertido para *string*, ou seja, `false` virará `\"false\"`, e `true` virará `\"true\"`, e ambas serão concatenadas. O mesmo acontecerá se somarmos um valor numérico a uma variável *string*: o valor numérico será convertido para uma *string*, e o resultado será de uma concatenação de duas *strings*.","pinned":false,"hidden":false,"mode":"md"},{"id":342,"value":"☞ *Estas são as operações aritméticas básicas. Para todos os tópicos em javascript há sempre muito mais do que este livro aborda, pois lidamos aqui com as questões introdutórias da linguagem.*","pinned":false,"hidden":false,"mode":"md"},{"id":340,"value":"

\n\n### Operações lógicas\n\n---\n","pinned":false,"hidden":false,"mode":"md"},{"id":345,"value":"Operações lógicas são aquelas necessárias, principalmente, para a condução do fluxo de execução do código. Elas lidam com valores resultantes da comparação de outros valores, ou sua atribuição, e mediante a estas operações, aquilo que o código deverá fazer fica definido. Na própria linha `19` do código já utilizado, temos uma *condicional* que finaliza (ou não) a execução do código, dependendo do resultado de uma comparação (se o valor da variável `x1` for maior que o da variável `windowWidth`).","pinned":false,"hidden":false,"mode":"md"},{"id":377,"value":"

","pinned":false,"hidden":false,"mode":"html"},{"id":379,"value":"Mas a primeira de todas as operações lógicas você já vem utilizando sem perceber: é a operação de atribuição, feita através de `=`. O símbolo `=` atribui um valor a alguma variável, isto é, quando dizemos `let x = 0;` estamos fazendo uma operação lógica de atribuição de valores. Algumas atribuições resultantes de operações aritméticas simples são tão comuns que também possuem alguns `shortcuts`. Quando queremos atribuir à própria variável um valor resultante de uma soma, subtração, multiplicação ou divisão (como é o caso da linha 16, onde temos `x1 = x1 + 2`), podemos escrever este código da seguinte forma:\n\n**Soma**\n```\nlet x = 10;\nx += 5; // é o mesmo que x = x + 5\n```\n\n**Subtração**\n```\nlet x = 10;\nx -= 3; // é o mesmo que x = x - 3\n```\n\n**Multiplicação**\n```\nlet x = 10;\nx *= 2; // é o mesmo que x = x * 2\n```\n**Divisão**\n```\nlet x = 10;\nx /= 2; // é o mesmo que x = x / 2\n```","pinned":false,"hidden":false,"mode":"md"},{"id":381,"value":"Depois das atribuições, temos as comparações. Toda operação de comparação (lembre-se, é uma **operação**) produz como resultado um valor *booleano*, isto é, toda vez que comparamos algo, temos como produto desta operação um valor `true` ou `false`. As instruções condicionais (que veremos mais à frente) determinam o que será executado em um código em função de um valor `true` ou `false`, e daí sua grande importância na programação.\n\n","pinned":false,"hidden":false,"mode":"md"},{"id":391,"value":"```js\nlet x = 50;\nlet y = 20;\nlet c = (x < y); // c = false\n```","pinned":false,"hidden":false,"mode":"md"},{"id":389,"value":"Estas são as diversas operações de comparação disponíveis:\n\n| Operador | Exemplo | Explicação |\n|----------|---------|------------|\n| `==` | `x == 10` | Resulta em `true` se
o valor de `x` for igual a 10 |\n| `===` | `x === z` | Resulta em `true` se
o valor de `x` for igual ao de `z`
e `x` for do mesmo tipo de variável que `z` |\n| `!=` | `x != 2` | Resulta em `true` se
o valor de `x` for diferente de 2 |\n| `!==` | `x !== z` | Resulta em `true` se
o valor de `x` for diferente do de `z`,
**ou** o tipo de variável de `x` for diferente do de `z` |\n| `>` | `x > 5` | Resulta em `true` se
o valor de `x` for maior que 5 |\n| `>=` | `x >= 5` | Resulta em `true` se
o valor de `x` for maior ou igual a 5 |\n| `<` | `x < 5` | Resulta em `true` se
o valor de `x` for menor que 5 |\n| `<=` | `x <= 5` | Resulta em `true` se
o valor de `x` for menor ou igual a 5 |\n","pinned":false,"hidden":false,"mode":"md"},{"id":449,"value":"Um dos erros mais comuns entre iniciantes em programação é, ao tentar fazer uma comparação, por exemplo `x == 10`, se escreve a operação lógica de atribuição `x = 10`, o que resulta em algo completamente adverso ao que se buscava fazer: a condição será sempre `true`, pois o valor foi atribuído, e não comparado.","pinned":false,"hidden":false,"mode":"md"},{"id":396,"value":"E para complicar um pouco este conjunto, temos por fim as operações *booleanas* que concatenam diversas operações de comparação para gerar uma condição ainda mais complexa:\n\n```js\nlet x = 50;\nlet y = 20;\nlet c = ( ( x < y ) || (y > 10) ); // c = true\n```","pinned":false,"hidden":false,"mode":"md"},{"id":398,"value":"Mas o quê aconteceu aqui acima, para que `c` seja `true`? O operador `booleano` `||` é uma operação lógica de `ou`, isto é, se a condição `(x < y)` **ou** se a condição `(y > 10)` forem, qualquer uma delas, válidas, o resultado final da operação será `true`.\n\nSão três os operadores lógicos *booleanos*:","pinned":false,"hidden":false,"mode":"md"},{"id":401,"value":"| Operador | Tipo | Exemplo | Explicação |\n|----------|------|---------|------------|\n| `&&` | `e` | `(x > 10 && x < 20)` | Resulta em `true` se
o resultado das duas
operações forem `true` |\n| || | `ou` | `(x > 10` || `x < 20`) | Resulta em `true` se
o resultado de ao menos uma
das operações for `true` |\n| `!` | `negação` | `( !(x > 10) )` | Resulta em `true` se
o resultado da operação
for `false` |\n","pinned":false,"hidden":false,"mode":"md"},{"id":435,"value":"Multiplas operações *booleanas* podem ser realizadas em sequência, criando condições bastante complexas:\n\n```js\nlet c = ( !( (x > 10) && (x <= 20) ) ) || ( ( x <= -10 ) && ( x != -20 ) );\n```\n\nEsta expressão se traduz verbalmente como: se o valor de `x` não estiver entre `10.001` e `20`, ou se o valor de `x` for menor que `-10` desde que não seja `-20`... se qualquer uma destas duas condições for verdadeira, o resultado será `true`.","pinned":false,"hidden":false,"mode":"md"},{"id":438,"value":"Este tipo de construção pode parecer complexa e desnecessária, mas boa parte dos problemas de decisão nos códigos nos exigem estabelecermos condições lógicas envolvendo múltiplas questões ao mesmo tempo. É por conta da lógica *booleana* que a programação é conhecida como sendo associada matemática.","pinned":false,"hidden":false,"mode":"md"},{"id":45,"value":"

","pinned":false,"hidden":false,"mode":"html"}],"files":"$W31","stdlib":"1","titling":"auto"}