Bom dia rapaziada. Eu tenho uma dúvida aqui sobre JS (javascript). Nesse código abaixo; é uma coisa bem básica, eu sei, mas eu sóu perfeccionista e gosto de entender os pormenores…
let num;
num = 1;
while (num <= 10) {
console.log(num);
num = num + 1;
Ná última linha do loop (num=num+1) eu entendo o funcionamento, a lógica etc, mas…
Como o javascript ler essa parte do código me deixa confuso porque:
depois que há o incremento do valor e a variável de controle passa a valer o valor incrementado, essa parte (num= num+1) é lida como pelo JS?
(num=1+1) —> (num= 2+1) etc… OU (1 = 1+1) → (2 = 2+1)
Como que isso é interpretado?
Pergunto isso porque, quando há o incremento do valor, a variável passa a valer o valor incrementado, certo? Então, como o “1º (num)” dessa parte (“num” = num+1) é lido? Ele vale “num” ou ele vai valer o valor atualizado da variável de controle?
Só sei um pouco de programação, mas acho que dá para responder.
O valor de num sempre será atualizado na última linha.
Na 2ª linha você atribuiu na variável num o valor 1 (num = 1)
Na 5ª linha você atribuiu na variável num o valor que estiver lá + 1 em cada iteração do while
(num = num + 1)
e no loop:
num = 2 (1 + 1)
num = 3 (2 + 1)
num = 4 (3 + 1)
num = 5 (4 + 1)
Se eu entendi bem, você está tentando entender num como se fosse um objeto, o problema é que, por estarmos falando de tipos primitivos, que não são objetos, os mesmos são imutáveis, você não está mudando o valor de num, você está guardando um novo valor em num:
let a = 5;
let b = a;
a = a + 1;
console.log(a) // 6
console.log(b) // 5
let foo = {num: 2};
let bar = foo
foo.num = foo.num + 1
console.log(foo) // {num: 3}
console.log(bar) // {num: 3}
Outra possibilidade é confusão na ordem de avaliação, operações de atribuição avaliam primeiro o lado direito, depois atribuem o valor ao lado esquerdo. num não é modificado quando estamos avaliando o lado direito (num+1). Alguma chance de você estar confundindo com a operação num++;?
Por isso eu perguntei se não ocorreu alguma confusão, se ele achou que isso ocorre já do lado direito da operação de atribuição num = num + 1, não ficou muito claro para mim onde ele está tendo dificuldade de entender o que a engine faz.
num é uma variável. Pelo que eu estudei de programação (JS) o let é um tipo de um var “mais local” vamos dizendo assim e quando foi declarado num = 1 a variável let num recebeu 1.
Dentro do while o num começa com 1:
num(1) = num(1) + 1;
num passa a ser 2:
num(2) = num(2) + 1;
num passa a ser 3… E assim vai até o 10… Quando o valor for 11 acaba o while.
Uma maneira mais prática/lógica de ler/interpretar de como essa parte é lida, é: Adicione 1 ao conteúdo atual da variável num e armazene esse novo valor na variável num.
Imaginando que em num já existe 2 ficaria: Adicione 1 ao conteúdo atual da variável num(que atualmente é 2) e armazene esse resultado(2+1) na variável num(que antes era 2 agora vai passar conter 3).
let num; # define o tipo de variável
num = 1; # atribui o valor 1 a variável
while (num <= 10) { # testa se o valor for menor ou igual a 10, em caso verdadeiro entra dentro do loop
console.log(num); # exibe o valor atual atribuído a variável num
num = num + 1; # faz soma do valor num + 1 e atribui este novo valor a variável num, sobrescrevendo o valor anterior (num = 1+1)
let num; // Declara uma variável chamada ‘num’.
num = 1; // Inicializa a variável ‘num’ com o valor 1.
while (num <= 10) { // Inicia um loop ‘while’ que continuará enquanto ‘num’ for menor ou igual a 10.
console.log(num); // Imprime o valor atual de ‘num’ no console.
num = num + 1; // Incrementa o valor de ‘num’ em 1. Isso poderia ser abreviado como ‘num++’.
}
// O loop continuará executando até que ‘num’ seja maior que 10. Quando ‘num’ atingir 11, o loop terminará.
Era examente isso que eu queria saber. Não é que eu estivesse confundindo, eu só queria saber como que funciona mesmo, pois nenhuma apostila ou guia diz isso que você falou. Por isso eu ficava imaginando o porquê de não ser 1=1+1. Eu meio que pensei mais em baixo nível e tals…
É uma confusão um pouco comum em JS, especialmente porque tipos primitivos parecem se comportar como objetos quando, na verdade, a engine apenas encapsula o mesmo em um objeto efêmero para tal. Esse tipo de informação você encontra na MDN.
