0:00:00.000,0:00:06.726
Nessa seção, quero acrescentar a ideia de variáveis (variables) ao código que temos. Uma

0:00:06.726,0:00:12.640
variável (variable) é como uma caixa na memória. E essa caixa guarda um valor como um número ou

0:00:12.640,0:00:18.411
uma sequência de caracteres (string). Então, se você olhar para esse diagrama aqui. Se eu tenho a linha,

0:00:18.411,0:00:23.158
X é igual a sete. Isso se chama uma 'atribuição de variável' (variable assignment). E a forma de pensar

0:00:23.158,0:00:27.839
nisso é que na memória há uma caixa. Desenhei uma caixinha aqui. E é

0:00:27.839,0:00:32.576
chamada de X. Ela pode conter um valor. Então quando o código (code) diz X é igual a sete, o que

0:00:32.576,0:00:37.258
isso significa é pegue o valor sete e guarde na caixa. Isso é basicamente

0:00:37.258,0:00:41.828
o que a atribuição de variáveis (variable assignment) faz. Se eu olhar para o que esse código aqui faz

0:00:41.828,0:00:46.342
Na primeira linha eu digo X é igual a sete, então eu estou guardando um sete ali

0:00:46.342,0:00:51.285
E então as linhas seguintes mencionam X. Essa diz imprima (print) X ou imprima 'lucky',

0:00:51.285,0:00:56.895
X e as aparições de X, sem um sinal de igual, essas apenas recuperam (retrieve) o valor

0:00:56.895,0:01:02.504
fora da caixa. Qualquer coisa guardada ali será usada

0:01:02.504,0:01:07.734
Então se eu executar (run). O que eu obtenho é apenas a impressão

0:01:07.734,0:01:12.808
do sete. Porque essa linha do X igual a sete guardou um sete na caixa e as

0:01:12.808,0:01:17.946
linhas seguintes só se referem ao X. Se eu mudar para oito, eu só mudo uma

0:01:17.946,0:01:23.019
linha e executo, então agora todas as linhas se referem a oito porque

0:01:23.019,0:01:28.029
essa linha está guardando um oito na caixa. Tente mais um experimento aqui; acho que

0:01:28.029,0:01:34.579
vimos números e caracteres. Dois tipos de dados (data) que podemos usar muito. Então se eu

0:01:34.579,0:01:41.056
disser X igual entre aspas. Isso guardará o caracter na caixa. Então se

0:01:41.056,0:01:48.164
Executo então eu terei essas linhas. Na realidade, esse

0:01:48.164,0:01:53.677
nome X eu escolho X como primeiro exemplo, porque é uma variável comum nas

0:01:53.677,0:01:58.283
aulas de matemática, mas esse nome pode ser qualquer coisa que a gente queira,

0:01:58.283,0:02:03.128
é só sermos consistentes, então vou mudar para X Y Z é igual

0:02:03.128,0:02:07.973
então criaremos uma variável chamada X Y Z com as aspas

0:02:07.973,0:02:12.461
e tudo que preciso fazer é ter certeza que todas as linhas seguintes também

0:02:12.461,0:02:16.583
refiram-se a XYZ. Se executo , o programa ainda funciona.[br]então o ponto é que

0:02:16.583,0:02:20.547
você pode escolher qualquer variável, qualquer nome que quiser para a variável

0:02:20.547,0:02:24.775
Então quando quiser se referir a essa variável, usará esse mesmo nome.

0:02:24.775,0:02:29.374
Você deve ser consistente com você mesmo. O ponto desse uso simples de

0:02:29.374,0:02:33.694
variáveis é mais apenas para evitar repetições. Significa que existe um

0:02:33.694,0:02:37.906
valor (value) que eu quero usar no meu programa. Posso atribui-lo em uma variável

0:02:37.906,0:02:42.334
em uma linha anterior, e então só usar essa variável em um monte de linhas seguintes.

0:02:42.334,0:02:46.816
E se depois eu quiser mudar o programa usando outro valor, posso simplesmente

0:02:46.816,0:02:51.082
mudar em um lugar, com a variável. E todos os usos dessa

0:02:51.082,0:02:55.186
variável usarão o novo valor. Então usaremos esse padrão

0:02:55.186,0:03:00.570
com muita muita frequência no nosso código. Devo dizer que o uso

0:03:00.570,0:03:06.712
do sinal de igual não é o mesmo que usamos em uma aula de matemática ou

0:03:06.712,0:03:12.703
Algebra. Na matemática é uma afirmação mais forte dizer X igual a Y. É como

0:03:12.703,0:03:18.296
dizer que são iguais o tempo todo. E em computação, o sinal de igual

0:03:18.296,0:03:22.751
não tem essa definição complicada.[br]É realmente só uma atribuição.

0:03:22.751,0:03:27.502
Quando essa linha for executada, pegue o valor dela e guarde em uma caixa

0:03:27.502,0:03:32.134
chamada X Y Z ou o que for. Então isso apenas acontece quando essa

0:03:32.134,0:03:37.004
linha for executada. Mas não afeta o programa inteiro. Então é

0:03:37.004,0:03:41.874
mais simples do que usar o sinal de igual que você está acostumado, da matemática

0:03:41.874,0:03:49.972
Bem, então deixe-me tentar um pequeno exemplo de código que

0:03:49.972,0:03:56.185
siga o padrão que dê saída (output) e diz mude o código para

0:03:56.185,0:04:01.297
produzir essa saída (output). E então a ideia é que existe alguém por quem você tinha uma

0:04:01.297,0:04:06.348
queda, na escola, você tinha uma queda por alguém, então vamos

0:04:06.348,0:04:11.645
escrever essa pequena saída (output) sobre isso. Digamos que tive uma queda por alguém chamada

0:04:11.645,0:04:16.019
Alice. Então irá dizer Alice, Alice, Alice, Alice, quatro vezes e

0:04:16.019,0:04:20.761
também, 'na escola eu tive uma queda por Alice'. 'Agora a maldição caíra sobre Alice'. Agora

0:04:20.761,0:04:25.628
a ideia com esse programa é não repetir o nome Alice um monte de vezes. É para

0:04:25.628,0:04:30.383
usar as variáveis. Para por o nome uma vez, então se eu decidir que ao invés disso

0:04:30.383,0:04:35.139
tive uma queda por alguém chamado Bob ou Zoe ou o que for. Então posso apenas mudar em

0:04:35.139,0:04:39.778
um lugar. Então direi X é igual Alice. Isso é o que a afirmação do problema

0:04:39.778,0:04:45.185
diz. E a ideia é então apenas escrever nas outras linhas se referindo a X. Então,

0:04:45.185,0:04:50.380
para dizer o nome quatro vezes, posso apenas dizer imprima (print) X, vírgula, X,

0:04:50.380,0:04:55.506
vírgula X, vírgula, X. Vamos tentar isso e então tenho quatro. Então

0:04:55.506,0:05:01.180
para a próxima linha, dirá 'na escola eu tive uma queda por' e é como preencher

0:05:01.180,0:05:06.580
o espaço em branco, certo? Usar o nome que for. Então posso fazer isso dizendo

0:05:06.580,0:05:11.850
imprima com aspas e essa parte apenas como caracter (string). Então direi.

0:05:11.850,0:05:19.622
'Na escola eu tive uma queda por' ok essa parte é normal e então termino com

0:05:19.622,0:05:27.020
um (string) e direi vírgula X. Então imprimirá o caracter e eu seguirei com um

0:05:27.020,0:05:33.621
X. Vamos tentar. Assim. E farei a última linha. Você notará que

0:05:33.621,0:05:40.190
os ponto vírgulas. Sempre coloco eles em JavaScript e na realidade eles

0:05:40.190,0:05:47.003
geralmente são opcionais. Direi que agora é um pouco manhoso então essa é a (string) e

0:05:47.003,0:05:53.816
direi vírgula X. Então de novo eu tenho um misto de (string) e o X. Então eu

0:05:53.816,0:05:59.948
aqui no meio coloco 'maldição caia' ( curse is lifted) . Assim funciona e

0:05:59.948,0:06:04.334
é um uso simples de variáveis onde usamos o sinal de igual uma vez e

0:06:04.334,0:06:08.211
talvez usemos algumas outras vezes abaixo, mas na verdade é o padrão que iremos

0:06:08.211,0:06:12.138
usar nas aulas. Acho que curtiremos muito, então

0:06:12.138,0:06:13.720
esse é o padrão (pattern) que quero que pratiquem.