quanto a tipos primitivos e não primitivos.

Foi passado no curso um artigo em inglês, https://medium.com/@ethannam/javascripts-memory-model-7c972cd2c239 entendi o porquê os arrays podem ser usados como "const" e não precisam de "let", visto que o const não sofre alteração em seu valor (de referência) na Stack. E entendi como um let quando alterado seu valor, ele cria outro espaço na memória, outro endereço, para o novo valor. Nada nesse caso é sobrescrito.

Quando o Bugan tenta dar o exemplo, não me fez muito sentido, ainda não entendi de fato qual é o objeto, e o que é ou não um tipo não primitivo quando se trata de objetos.

Aqui está o código do arquivo index

let valor = 200;
contaCorrenteRicardo.transferir(valor, conta2);

console.log("valor: ", valor);
console.log(conta2);

e o do método que foi testado

transferir (valor, conta) {
    conta.cidade = "São Paulo";
    const valorSacado = this.sacar(valor);
    conta.depositar(valorSacado);
    valor = 20

Conclusão que se chega no vídeo: "Perceba que, apesar do atributo cidade ter sido adicionado à conta2, o valor não foi alterado."

O que realmente não me faz sentido é que no caso do Método, o valorsó é alterado depois que já foi feito o saque e depósito, por isso não alterou-se nada, não por causa de seu tipo (primitivo ou não). Quando eu jogo no meu código esse valor = 20 antes da ativação de sacar e depositar, eu tenho de fato a alteração do valor de 200 para 20. Será que isso era mesmo para acontecer com tipos não primitivos?

Olá, Tales! Tudo bem?

Primeiro, vamos tratar essa parte de primitivos e não primitivos:

Primitivos: valores tratados diretamente pelo JavaScript, essas variáveis guardam valores. Exemplo: números.
Não primitivos: a aplicação guarda o endereço em memória e não o valor em si. Importantes casos são as arrays e os objetos.

O que o instrutor tentou explicar foi que, quando passamos um valor primitivo via parâmetro, como o JS trata como valor absoluto, ele lê aquele valor e, dentro da função, cria uma variável daquele parâmetro com o mesmo valor. Apesar de iguais, não são o mesmo dado em memória.

No caso de valores não primitivos, a situação é bem diferente. Como o JS os trata como endereços dos valores, é passado via parâmetro o endereço, o mesmo endereço que aponta para o objeto fora da função, então estamos tratando o mesmo dado, e não dados de mesmo valor mas diferentes. Assim, se alteramos dentro da função, essas alterações são persistidas fora da função também.

Quanto ao teste que você fez, não deveria funcionar assim, justamente pelo explicado acima, a variável valorde dentro da função possui um valor próprio, que mais ninguém possui (nem mesmo o valor de fora da função).

Quando o instrutor altera o valor dentro da função, é independente do saque, porque ele não quer motrar os reflexos dessa alteração na conta em si, mas na valor do index.js. Confirme que o experimento que você fez também teve essa finalidade, e se continuar assim, responda aqui para entendermos melhor o que acontece!

Obs.: Na explicação, repeti alguns conceitos que você já tinha mostrado conhecimento no tópico, com o intuito de manter a explicação completa. Mas a explicação que você deu no primeiro parágrafo está correta, e explica bem a diferença de funcionamento de variáveis que guardam referências e variáveis que guardam valores diretamente.

Espero ter ajudado, e qualquer coisa estou à disposição! Bons estudos!

PRORROGAMOS O DESCONTO!