So the first thing that I asked you,
is whether udacicolaVotes is a local
variable or a global variable.
And you should have determined
that it was a local variable.
Well, to figure this out, you go to
where the variable is declared, which is
here, and you know it's declared,
because the data type is right here.
And you see is it declared Inside of a
method, meaning between between the two
curly braces here, or
is it declared outside of the method?
Now, if it's declared
inside of a method,
that means that it's a local variable,
and
we can see very clearly that it is
in fact declared inside of a method.
So it's a local variable.
Well, what does that mean?
We should also be asking ourselves,
if I declared something as
a local variable, should I have?
Let's think about it in this case.
Here's our phone.
And we've been talking about udacicola,
so
let's only focus on when we
click the udacicola button.
When we click this button,
this method starts.
It sets udacicola votes to zero, and
then it adds one to udacicolaVotes,
which is zero.
So udacicolaVotes becomes one.
Now, because udacicolaVotes is a local
variable, at the end of this method,
it actually sort of dies,
or gets deleted.
The fact udacicolaVotes is trashed, or
gone, at the end of this method because
it's a local variable,
causes a couple problems.
So why is this a problem?
Well, you would think that if
three different people voted for
udacicola by clicking on the button,
that udacicolaVvotes should be three.
Well, what actually happens is the first
time you click on the button,udacicola
becomes zero.
It gets one added to it, becoming one.
And then it gets trashed.
It doesn't exist anymore.
The second time that somebody
clicks on udacicolaVotes,
well udacicolaVotes is
made all over again.
It's declared again.
Because remember, the first time
it had essentially gotten trashed.
So it needs to be remade.
And when it's remain, it's set to zero.
Now we add one again to it, but
remember the value is zero.
So udacicolaVotes is still one, even
though the button's been clicked twice.
And the same thing happens when
it's clicked the third time,
it still is one and it's actually
trashed again at the end of this method.
So that's the first problem.
It's not really saving the state
between button clicks.
About how many people have voted for
udacicola.
But another problem is down here, this
code's actually going to throw an error.
And the reasoning for that is because
remember I said that udacicolaVotes
sort of comes into existence or
its scope begins right here.
And then at the end of
this voteudacicola method.
It is trash, it's out of existence.
Which means when I come down here,
udacicolaVotes doesn't really exist.
More technically, we say that
this variable is out of scope.
Its scope was here It got declared here,
and it ended here.
But we're trying to use it down here.
And it can't be used.
Having udacicolaVotes be a local was
not a correct decision in this case.
And I can summarize why
with these two points.
It's not saving the vote about between
button click, and it's not in scope for
the show me votes method.
So this will actually cause errors.
So this will actually not compile.
Okay, so let's look at the other
variable in this program.
حسناً أول سؤال اسأله لك
فيما إذا كان udacicolaVotes
متحول محلي أو متحول عام
ويجب أن تكون قد حددت
أنه متحول محلي
حسناً، لإستنتاج ذلك، ستذهب
إلى المكان الذي حدد به المتغير، وهو
هنا، وأنت تعلم بأنه قد تم تحديده
بسبب نمط البيانات الموجودة هنا
وكما ترى هل تم تعينه داخل
الطريقة، هنا بين قوسين التنصيص، أو
تم تحديده خارج الطريقة؟
الآن، إذا تم تعينه
داخل الطريقة
هذا يعني أنه متحول محلي
يمكننا أن نرى بشكل واضح جداً
أنه في الحقيقة تم تعيينه داخل الطريقة
لذلك فهو متحول محلي
حسناً، ماذا يعني ذلك؟
علينا أيضاً أن نسأل أنفسنا
إذا صرحت عن شيء كمتحول محلي
هل ينبغي أن أفعل ذلك؟
دعونا نفكر به ضمن هذه الحالة
ها هو هاتفنا
وكنا نتحدث عن "udacicola" لذلك
دعونا نركز فقط عندما
نضغط على زر udacicola
عندما نضغط على هذا الزر
ستبدأ هذه الطريقة
سيتم تحديد قيمة udacicolaVotes بالصفر
وبعد ذلك يضاف واحد إلى udacicolaVotes
والتي هي صفر
لذلك ستصبح udacicolaVotes واحد
الآن، ولأن udacicolaVotes هو متحول محلي
ففي نهاية هذه الطريقة
في الواقع سيتوقف
أو سيحذف
في الواقع أن udacicolaVotes مهمل
أو ضائع، في نهاية هذه الطريقة لأنه
متحول محلي
ويسبب ذلك مشاكل الإزدواج
حسناً لماذا تعتبر هذه مشكلة؟
حسناً، ستعتقد إن
صوّت ثلاثة أشخاص مختلفين لـ
عن طريق النقر على الزر udacicola
فإن قيمة udacicolaVotes يجب أن تكون ثلاثة
حسناً، ما يحصل في الواقع أن المرة الأولى
التي تقوم بها بالضغط على الزر
فإن udacicola ستصبح صفر
سيتم إضافة واحد لها، لذلك ستصبح واحد
ومن ثم سوف تهمل
فهي ليست موجودة بعد الآن
في المرة الثانية التي يقوم بها
شخص ما بالضغط على udacicolaVotes
فستقوم udacicolaVotes بتكرار
ذلك كله مجدداً
لقد تم تعيينه مرة أخرى
تذكر السبب أنه في المرة الأولى
قد تم إهماله بشكل أساسي
لذلك يجب أن يعاد إنشاؤه
وعندما يبقى هكذا، فيتم تعيينه كصفر
الآن نقوم بإضافة واحد مرة أخرى
ولكن تذكر بأن القيمة صفر
فلذلك فإن udacicolaVotes لا تزال واحد
على الرغم من أنه تم النقر على الزر مرتين
ونفس الشيء يحدث
عندما يتم النقر عليه للمرة الثالثة
هو مازال واحد، وفي الواقع قد تم
إهماله مرة أخرى في نهاية هذه الطريقة
لذلك هذه هي المشكلة الأولى
فهو حقاً لا يخزّن
الحالة بين ضغط الأزرار
فكم من الأشخاص قد
صوتوا لـ "udacicola"
ولكن المشكلة الأخرى هي هنا
هذا الكود الذي سيؤدي إلى خطأ
وتفسير ذلك هو إن كنت تتذكر
عندما قلت أن udacicolaVotes
سيصبح نوعاً ما موجود
أو أن نطاقه سيبدأ من هنا
ومن ثم في نهاية
هذه الطريقة لـ voteudacicola
سيهمل، ولن يعد موجود
مما يعني أنه عندما أنظر للأسفل هنا
فإن udacicolaVotes غير موجوة حقاً
وبشكل تقني أكثر، نقول
أن هذا المتحول هو خارج النطاق
فقد كان نطاقه هنا وتم تعيينه هنا
وانتهى الأمر به هنا
ولكننا نحاول أن نستخدمه هنا
ولا يمكن استخدامه
فوجود udacicolaVotes بشكل محلي لم
يكن قراراً صحيحاً في هذه الحالة
ويمكنني أن ألخص السبب
بنقطتين التاليتين
لا يقوم بتخزين التصويت بين
الضغط على الزر، كما أنه ليس ضمن النطاق
لكي يريني طريقة التصويت
لذلك هذا سيسبب أخطاءً في الواقع
ولذلك فإن ذلك لن يكن محدداً
حسناً، دعونا ننظر إلى
متحول أخر في هذا البرنامج
Lo primero que te pregunté
era si udacicolaVotes
es una variable local o global.
Debes haber notado
que es una variable local.
Para averiguarlo ve a donde
está declarada la variable, aquí.
Sabes que se ha declarado
porque está escrita aquí.
¿Se ha declarado dentro de un método,
entre estas dos llaves,
o fuera de ese método?
Si se ha declarado dentro de un método,
quiere decir que es una variable local.
Aquí se ve claramente
que se ha declarado dentro de un método.
Así que es una variable local.
¿Qué significa esto?
La pregunta que deberíamos hacernos es
si se debería haber declarado
como una variable local.
¿Debería?
Vamos a pensar este caso.
Aquí está nuestro teléfono.
Hemos estado hablando sobre Udacicola,
así que fijémonos únicamente
en cuando pulsamos el botón de Udacicola.
Cuando pulsamos este botón,
empieza a ejecutarse este método.
Pone en cero udacicolaVotes
y luego añade 1 a udacicolaVotes,
que está en cero.
Y udacicolaVotes pasa a ser 1.
Como udacicolaVotes es una variable local,
cuando acaba este método
se destruye, se borra.
El hecho de que udacicolaVotes se borre
o se destruya al final de este método,
dado que es una variable local,
provoca algunos problemas.
¿Por qué?
Pensarás que si tres personas diferentes
votan por Udacicola apretando este botón
udacicolaVotes debería ser 3.
Lo que en verdad ocurre
es que la primera vez que pulsas el botón
udacicolaVotes es cero.
Después se añade 1,
y luego se borra, ya no existe.
La segunda vez que alguien pulsa
para votar Udacicola
udacicolaVotes vuelve a empezar de cero,
vuelve a declararse.
Recuerda que la primera vez
se había destruido,
así que vuelve a ejecutarse.
Y cuando vuelve a ejecutarse,
se pone en cero.
Vuelve a añadirse un 1
pero recuerda que el valor era cero,
así que udacicolaVotes es 1
aunque el botón se haya pulsado dos veces.
Y lo mismo ocurre
cuando se pulsa por tercera vez.
Todavía está en 1 y vuelve a borrarse
al final de este método.
Ese es el primer problema,
que no se está guardando el estado
conforme se pulsa el botón.
No se guarda el número de personas
que están votando.
Pero hay otro problema aquí abajo:
este código va a generar un error.
El motivo es que, si lo recuerdas,
he dicho que udacicolaVotes
aparece aquí,
su visibilidad empieza aquí.
Y, al final del método voteUdacicola,
se destruye, deja de existir.
Lo que significa que cuando vengo aquí,
udacicolaVotes ya no existe.
Técnicamente decimos
que esta variable no es visible.
Su visibilidad está aquí.
Se declara aquí y se acaba aquí.
Pero estamos intentando usarla aquí
y no se puede.
Que udacicolaVotes sea una variable local
no es una decisión acertada en este caso.
Resumo los motivos en dos puntos:
no guarda los votos
al pulsar varias veces el botón
y no es visible
dentro del método showMeVotes,
así que esto dará error.
Esto de aquí no se compilará.
Vamos a echar un vistazo
a la otra variable de este programa.
Donc, la premičre chose
que je vous ai demandée,
c'est si les udacicolaVotes
sont une variable locale ou globale.
Et vous devriez voir déterminé
que c'est une variable locale.
Bien, pour trouver ça, vous allez lŕ
oů la variable est déclarée, et c'est
ici, et vous savez que c'est déclaré
car le type de donnée est juste ici.
Et vous voyez que c'est déclaré dans
une méthode, c'est ŕ dire entre les deux
accolades ici, ou est-ce déclaré
en dehors de la méthode?
Maintenant, si c'est déclaré
ŕ l'intérieur de la méthode
ça signifie que
c'est une variable locale et alors
on peut clairement voir que c'est bien
déclaré ŕ l'intérieur de la méthode.
Donc c'est une variable locale.
Bien, qu'est-ce que ça veut dire ?
On devrait aussi se demander,
si j'ai déclaré quelque chose comme
une variable locale, ai-je bien fait ?
Réfléchissons-y dans ce cas.
Voici notre téléphone.
Et nous avons parlé
d'udacicola, donc
concentrons-nous seulement sur le moment
oů on clique sur le bouton udacicola.
Lorsque l'on clique sur ce bouton,
cette méthode démarre.
Cela définit les votes udacicola ŕ zéro,
puis ça ajoute un aux udacicolaVotes,
qui sont ŕ zéro.
Donc les udacicolaVotes passent ŕ un.
Comme le vote udacicola est une variable
locale, ŕ la fin de cette méthode,
il meurt en quelques sortes,
ou il est supprimé.
Les udacicolaVotes soient détruits ou
disparaissent en fin de méthode car
c'est une variable locale,
ce qui cause quelques problčmes.
Alors, pourquoi est-ce un problčme ?
Bien, vous pourriez penser
que si trois personnes ont votés
udacicola en cliquant sur le bouton,
les udacicolaVotes devraient ętre ŕ 3.
Ce qui se passe, c'est qu'au premier clic
sur le bouton, udacicola
devient zéro.
Il y en a un qui s'ajoute
et ça devient un.
Puis il se détruit.
Il n'existe plus.
La deuxičme fois que quelqu'un clique
sur les udacicolaVotes,
les udacicolaVotes sont ŕ nouveau faits.
C'est ŕ nouveau déclaré.
Car rappelez-vous, la premičre fois
il a été détruit.
Donc il doit ętre refait.
Et lorsqu'il reste, il est définit ŕ zéro.
Maintenant on ajoute ŕ nouveau un,
mais rappelez-vous la valeur est zéro.
Les udacicolaVotes sont donc ŕ un,
bien qu'on ait cliqué deux fois.
Et la męme chose
se produit au troisičme clic
il est toujours ŕ un et sera ŕ nouveau
détruit ŕ la fin de cette méthode.
C'est donc le premier problčme.
Ce n'est pas vraiment de sauvegarder
l'état entre le clics de bouton
ŕ propos de combien de personnes
ont voté pour udacicola.
Mais il y a un autre problčme ici,
ce code va en fait déclencher une erreur.
Et lŕ raison c'est que, rappelez vous
que j'ai dit que les udacicolaVotes
voient en quelque sorte le jour,
ou leur portée commence ici.
Et ŕ la fin de cette méthode
de vote udacicola.
Ils sont détruits, ils n'existent plus.
Ça veut dire que quand je viens ici, les
udacicolaVotes n'existent pas vraiment.
Plus techniquement, on dit
que cette variable est hors de portée.
Sa portée était lŕ, elle a été
déclarée lŕ, et ça s'est terminé ici.
Mais on essaie de l'utiliser ici.
Et elle ne peut pas ętre utilisée.
Les udacicolaVotes en local ça n'était
pas une bonne décision dans ce cas.
Et je peux résumer
pourquoi avec ces deux points.
Ça ne mémorise pas le vote entre
les clics, et ce n'est pas dans la portée
pour la méthode show me votes.
Cela va donc effectivement
causer des erreurs.
Donc cela ne va pas se compiler.
Ok, regardons les autres variables
de ce programme.
Hal pertama yang saya tanya
yaitu apakah udacicolaVotes termasuk
variabel lokal atau global.
Dan harusnya sudah Anda tentukan
kalau dia termasuk variabel lokal.
Nah, untuk memahaminya Anda perlu menuju
tempat dimana variabel dinyatakan
yaitu di sini, dan sudah dinyatakan
karena tipe data ada di sini.
Dan dinyatakan di dalam sebuah
metode, yang bearti di dalam
kurung kurawal ini atau apakah
ini dinyatakan di luar metode?
Sekarang, jika ini dinyatakan
dalam sebuah metode,
maka artinya ini adalah
variabel lokal dan
kita bisa lihat jelas kalau ini
dinyatakan di dalam sebuah metode.
Jadi ini merupakan sebuah lokal variabel.
Nah, apa artinya?
Kita juga harus tanya
pada diri kita,
jika saya menyatakan sesuatu sebagai
variabel lokal, haruskah saya punya?
Mari kita bahas.
Ini adalah ponsel kita.
Dan kita telah membahas
tentang udacicola, jadi
marilah hanya fokus pada saat kita
mengeklik tombol udacicola.
Saat kita mengeklik tombol ini,
metode ini memulai.
Ini mengatur nilai udacicola ke nol, lalu
menambah satu untuk udacicolaVotes,
yang bernilai nol.
jadi udacicolaVotes menjadi satu.
Karena udacicolaVotes adalah
variabel lokal, pada akhir metode ini,
dia akan mati atau dihapus.
Penyebab udacicolaVotes hancur atau
menghilang pada akhir metode ini adalah
karena variabel lokal
menyebabkan beberapa masalah.
Jadi, kenapa ini
bermasalah?
Jika Anda pikir kalau tiga
orang berbeda melakukan vote untuk
udacicola dengan cara mengeklik tombol,
maka nilai udacicolaVvotes menjadi tiga.
Yang sebenarnya terjadi adalah saat
pertama kali Anda mengeklik tombol,
udacicola menjadi nol.
Ditambah satu, menjadi satu.
Dan kemudian terbuang.
Tidak ada lagi.
Kali kedua seseorang
mengeklik udacicolaVotes,
maka udacicolaVotes
mengulang dari awal lagi.
Ini dinyatakan kembali.
Ingat, kali pertama dia terbuang.
Dia harus dibuat kembali.
Dan ketika dibuat kembali,
dia diatur ke nol.
Sekarang kita tambahkan satu lagi,
tapi ingat nilainya adalah nol.
Jadi udacicolaVotes masih tetap satu,
walaupun tombolnya di klik dua kali.
Hal sama terjadi juga saat
mengeklik yang ketiga kalinya,
masih tetap satu dan akan terbuang
kembali pada akhir metode ini.
Itu adalah masalah pertama.
Tidak akan benar-benar menyimpan nilai
antara tombol klik.
Mengenai jumlah orang yang telah
memberi vote untuk udacicola.
Masalah lain ada di bawah ini,
kode ini akan membuat masalah.
Dan alasannya, ingat yang pernah
saya katakan kalau udacicolaVotes
seperti hidup atau bisa dibilang kalau
jangkauannya dimulai di sini.
Lalu, di akhir metode voteudacicola ini.
Menjadi sampah, tidak ada lagi.
Yang berarti saat saya turun kesini,
udacicolaVotes tidak ada.
Secara teknis, variabel ini
di luar jangkauan.
Jangkauannya ada di sini, dinyatakan
di sini dan berakhir pula di sini.
Tapi, kita sedang mencobanya di sini.
Dan tidak bisa digunakan.
Memiliki udacicolaVotes sebagai lokal
bukanlah keputusan yang tepat.
Dan saya rangkum dalam dua poin.
Ini tidak menyimpan vote antara
tombol klik dan tidak berada dalam
jangkauan metode show me votes.
Jadi, ini benar-benar
akan membuat kesalahan.
Jadi ini tidak akan dikumpulkan.
Oke, ayo lihat variabel lainnya
dalam program ini.
まず 最初に私があなたに聞いたのは
udacicolaVotesがローカル変数か
グローバル変数かです
そして あなたはローカル変数だと
決定すべきでした
これを見つけ出すには変数が宣言された場所
つまり ここへ行き
そのデータタイプはここなので
それが宣言されているのが分かります
メソッドの中で宣言されているかどうか
つまり波カッコの中で宣言されているか
外で宣言されているどうかです
メソッドの中で宣言されている場合
それはローカル変数であることを
意味しています
実のところ それはメソッドの中で
宣言されていることがと明らかです
だから それはローカル変数です
どういうことでしょうか?
私たちは私たち自身にも
問いかけるべきです
ローカル変数として何かを示した時
それで良いかどうか考えましょう
このケースについて考えてみましょう
ここに私たちの携帯があります
そして 私たちは udacicolaについて
話しています
udacicolaボタンをクリックした時だけに
注目してみましょう
このボタンをクリックした時
このメソッドはスタートします
udacicolaVotesを0にセットし
0であるudacicolaVotesに
1を加えます
従って udacicolaVotesは
1になります
さて この方法の終わりに
udacicolaVotesはローカル変数なので
このメソッドの終わりにudacicolaVotesは
いわば死んだようなもので削除されます
ローカル変数なので udacicolaVotesが
このメソッドの終わりに 破棄される
またはなくなるという事実は
いくつかの問題を引き起こします
では なぜ問題なのでしょう?
もし それぞれ3人がボタンを押して
udacicolaに投票したら
あなたはudacicolaVvotesが
3になるべきだと思うでしょう
ここで実は何が起こっているかと言うと
ボタンを初めて押したら
udacicolaは0になります
1つ加えると1になります
そして破棄されます
udacicolaはもう存在していません
2度目にudacicolaVotesを
誰かがクリックします
udacicolaVotesは
また最初から作成されます
再度宣言されます
なぜなら 覚えていますか?最初に
udacicolaVotesは基本的に破棄されます
だから再度作り直す必要があります
そして作り直された時
0にセットされます
さて 再度1を追加します
しかし 覚えていますか?ここでの値は0です
だから たとえボタンが2度押されたとしても
udacicolaVotesはまだ1です
そして3度目にボタンが押されても
同じことが起こります
まだ1のままで 実際にudacicolaVotesは
この方法の最後には再度破棄されます
これが最初の問題です
ボタンクリックの間で
状態が保存されていません
何人の人がudacicolaに
投票しているかに記憶しません
しかし 他の問題はここにあります
このコードは実はエラーを投げます
そしてその理由は udacicolaVotesは
ここでその存在が始まる
またはそのスコープが始まります
そしてこのvoteudacicolaメソッドの最後に
破棄されます
存在していません
つまりここにくるとvoteudacicolaは
本当は存在していないことを意味します
もっと専門的には
この変数はスコープ外と私たちは言います
スコープはここで宣言されています
そして ここで終了しました
しかし 私たちはここで
使用しようとしています
そして使用できません
udacicolaVotesをローカル変数とすることは
このケースでは正しい選択ではありません
そして私はこの2つのポイントを使って
なぜなのかまとめる事ができます
それはボタンクリック間で投票数を
保存していないこと
showMeVotesメソッドの
スコープ内でないことです
つまり これが実は
エラーを引き起こします
つまり これは
実はコンパイルできません
それでは このプログラムの
他の変数をみてみましょう
이제 한가지를 당신에게 묻겠습니다,
udacicolaVotes는 단지
지역 변수인가요 아니면 국제 변수인가요.
그리고 당신은 이것이
지역 변수라고 생각하여야합니다.
이제 알아보기 위해서, 당신은
어디서 변수가 발견되는
것과 당신이 알고 있는 것을
알아보도록 하겠습니다.
그리고 당신은 방법의 내부를 확인하고
두가지
괄호 안의 내용을 확인하고
외부내용을 밝힐 수 있나요?
이제, 만약 밝혀졌다면
방법 내부에,
이는 지역 변수라는 의미이며
또한
우리는 매우 확실하게
방법 내부의 방법이라고 확인할 수 있습니다.
그래서 이것은 지역 변수인 것입니다.
그래서 이것은 무슨 의미일까요?
우리는 스스로에게 질문해보아야 하며,
만약 주장한 사항이
지역 변수라면, 가져야 할까요?
이 케이스에서 알아보겠습니다.
여기 휴대전화가 있습니다.
그리고 우리는udacicola에 대해 이야기하고 있습니다,
그리고
udacicola버튼을 클릭하는 것에
집중하시길 바랍니다.
이 버튼을 누를때,
이 방법은 시작됩니다.
이는udacicola를 0으로 만들며
udacicolaVotes에 1을 추가합니다,
결론적으로 0이죠
그리고 udacicolaVotes는 1이 됩니다.
이제, udacicolaVotes는 이 방법의 마지막인
지역변수이기에,
이는 실제로 소멸되거나
삭제된 사항일 것입니다.
udacicolaVotes의 사실은 삭제되었거나
사라졌을 것입니다. 왜냐하면
이는 지역 변수이며
다양한 문제를 일으키기 때문이죠.
왜 문제가 되냐구요?
아마 당신은
만약 다른 사람들이
udacicola의 버튼을 클릭함으로
udacicolaVvotes는 3이 되어야 한다고 생각할 것입니다.
실제로 첫번째 클릭했을 때
일어나는 것은,udacicola
가 영이 되는 것입니다.
이는 하나가 추가가 되도, 하나가 되는 것입니다.
그리고 삭제되죠.
이것은 더이상 존재하지 않습니다.
두번째에는 누군가
udacicolaVotes를 클릭하면,
udacicolaVotes는
지속적으로 만들어질 것입니다.
이는 계속 반복되는 것이죠
왜냐하면, 첫번째
기본사항이 삭제된 것을 기억하세요.
그리고 이것은 재 생산됩니다.
그리고 이것이 존재할 때, 이는 0입니다.
이제 우리는 한개를 추가하면,
값은 0이 되는 것을 기억해야합니다.
그리고udacicolaVotes는 여전히 하나입니다.
두번 클릭했더라도 말이죠.
그리고 세번째 클릭할때도
같은 활동을 벌이며
여전히 1이 되고 이 방법의 마무리에
실제로 삭제됩니다.
그리고 이것이 첫번째 문제입니다.
이는 단지 말을 줄이는 것이 아닌
버튼 클릭의 문제인 것입니다.
얼마나 많은 사람들이 udacicola를
투표하였는가.
하지만 다른 문제는 여기에 있습니다, 이
코드는 실제로 우류가 발생합니다.
그리고 이러한 이유로
udacicolaVotes를 기억해야합니다.
존재를 종류별로 기억하거나
관점을 여기서 시작해야합니다.
그리고
voteudacicola방법의 마지막에는
이는 삭제되고, 더이상 존재하지 않습니다.
이 의미는 여기로 내려와도
udacicolaVotes는 존재하지 않는다는 것입니다.
더 기술적으로, 우리는
이 값들이 변수 밖이라는 것을 알 수 있습니다.
이 관점은 분명히 되어 있어도
이곳에서 종료되는 것입니다.
하지만 여기서 사용할 수 있으며
여기서 사용을 할 수 없게 됩니다.
udacicolaVotes를 지역으로 가지고 있는 것은
올바른 결정이 아닌 것입니다.
그리고 저는 왜 이 두 점인지
요약할 수 있습니다.
이는 버튼을 클릭하는지
투표 방법을 보여주는지를
저장하지 않습니다.
그리고 이것은 실제로 오류를 야기합니다.
그리고 이것은 실제로 축적되지 않습니다.
좋습니다 이제
이 프로그램의 다른 변수들을 볼 차례입니다.
Então a primeira coisa
que perguntei a você,
foi se udacicolaVotes
é uma variável local ou uma variável global.
E você deveria ter respondido
que é uma variável local.
Bem, para descobrir isto, você vai para
onde a variável é declarada, que é
aqui, e você sabe que é declarado,
porque o tipo de dado é aqui mesmo.
E você vê que é declarada dentro de um
método, ou seja, entre as duas
chaves aqui, ou
é declarada fora do método?
Agora, se ele é declarado
dentro de um método,
que significa que é uma
variável local, e
podemos ver muito claramente que é
na verdade declarada dentro de um método.
Portanto, é uma variável local.
Bem, o que isso significa?
Devemos também nos perguntar,
se eu declarei algo como uma variável
local, eu deveria tê-lo feito?
Vamos pensar sobre isto neste caso.
Aqui está o nosso celular.
E nós temos falado sobre o
botão udacicola, assim
vamos apenas focar quando
clicarmos no botão udacicola.
Ao clicarmos neste botão,
este método inicializa.
Ele define votos udacicola a zero, e
depois, adiciona um a udacicolaVotes,
que é zero.
Assim, udacicolaVotes
se torna um.
Agora, por udacicolaVotes ser uma
variável local, no fim deste método,
na verdade meio que morre,
ou é apagado.
O fato do udacicolaVotes ser
descartadom ou apagao, no fim deste método
é por ele ser uma variável local,
causa alguns problemas.
Então, por que este é um problema?
Bem, você pensaria que se
três pessoas diferentes votassem
udacicola clicando no botão,
aquele udacicolaVvotes deveria ser três.
Bem, o que realmente acontece é que
na primeira vez que você clica no
botão, udacicola se torna zero.
Ela recebe um adicionado a ele,
tornando-se um.
E então ele vai para a
lixeira.
Ela não existe mais.
A segunda vez que alguém
clicar em udacicolaVotes,
bem udacicolaVotes é
todo refeito.
É declarado novamente.
Porque,lembre-se, na primeira vez
tinha essencialmente sido descartado.
Por isto, precisa ser refeito.
E quando ele permanece,
ele é definido como zero.
Agora adicionamos um novo para ele,
mas lembre-se que o valor é zero.
Então udacicolaVotes ainda é um,
mesmo depois de se clicar duas vezes.
E a mesma coisa acontece quando
for clicado pela terceira vez,
ainda é um e é, na verdade,
descartado no final deste método.
Então esse é o primeiro problema.
Não é realmente salvar o estado
entre cliques de botão.
Sobre quantas pessoas votou
udacicola.
Mas outro problema aqui embaixo,
este código na verdade errará.
E o raciocínio para isso é porque
lembre-se, eu disse que udacicolaVotes
meio que começa a existir ou
seu escopo começa bem aqui.
E, em seguida, no final de
este método voteudacicola.
É lixo, qnã existe.
O que significa que quando eu vir para cá,
udacicolaVotes realmente não existe.
Mais tecnicamente, dizemos que
esta variável está fora do escopo.
O seu escopo era aqui, ficou
declarado aqui, e terminou aqui.
Mas estamos tentando usá-lo aqui.
E não pode ser utilizado.
Tendo udacicolaVotes para um local
não foi uma decisão certa neste caso.
E eu posso resumir as razões
com estes dois pontos.
Não está salvando o voto entre
cliques de botão, e não está no escopo
para o método showmevotes.
Então, isto vai realmente causará erros.
Então, isto realmente não compilará.
Bem, então vamos olhar a outra
variável deste programa.
Первое, о чем я вас спросила,
это является переменная udacicolaVotes
локальной или глобальной.
И вы должны были определить,
что она локальная.
Чтобы понять это, смотрим туда,
где объявлена переменная, это здесь
и мы знаем, что она объявлена,
так как здесь прописан тип данных.
Вы видите, она объявлена внутри метода,
то есть между двумя волнистыми скобками,
или же снаружи метода?
Если переменная объявлена внутри метода,
это будет значить, что она локальная,
и мы ясно видим, что она действительно
объявлена внутри метода.
Значит, эта переменная - локальная.
Хорошо, а что это означает?
Нам стоит также спросить себя,
правильно ли мы поступили,
объявив какую-либо переменную локальной?
Давайте поразмышляем на данном примере.
Вот наш телефон.
Мы говорили об udacicola, так что
сосредоточимся на том,
когда мы нажимаем эту кнопку.
При нажатии на кнопку запускается метод.
Количество голосов за udacicola
задается нулевым,
затем прибавляется один к udacicolaVotes,
которое равно нулю.
Так udacicolaVotes становится
равным единице.
udacicolaVotes - локальная переменная,
так что по окончании этого метода
она, на самом деле, как бы умирает,
или удаляется.
Факт, что udacicolaVotes выбрасывается,
исчезает по окончании метода
приносит, в действительности,
пару проблем.
Так почему это проблема?
Вы можете подумать, что если
три различных человека голосуют за
udacicola нажатием кнопки,
то udacicolaVvotes станет равно трем.
На самом деле, когда кнопку
нажимают впервые,
значение udacicola становится равным нулю.
При следующем нажатии
оно станет единицей.
А затем отправится в мусор.
Перестанет существовать.
Когда udacicolaVotes
нажимают во второй раз,
она, на самом деле, заново создается.
Заново объявляется.
Так как, вспомните, в первый раз она,
по сути, была выброшена.
Поэтому ее необходимо переделать.
И снова ей придается
нулевое значение.
Теперь мы снова прибавляем один, помня,
что значение переменной равно нулю.
Так что udacicolaVotes все еще единица,
хотя на кнопку уже нажали дважды.
И то же самое происходит
при третьем нажатии,
она все еще единица и в действительности
отправляется в мусор по окончании метода.
Это первая проблема.
Это не совсем сохранение состояния
между нажатиями кнопки.
О том, как много людей
проголосовали за udacicola.
Вторая проблема - вот здесь, этот код
в действительности выдаст ошибку.
И причина лежит в том, что,
как я уже говорила, udacicolaVotes
в своем роде зарождается здесь,
ее область действия начинается именно тут.
А затем, по окончании метода voteudacicola
отправляется на свалку,
прекращает существовать.
Это значит, что когда я обращаюсь сюда,
udacicolaVotes уже не существует.
Говоря техническим языком,
мы вне области действия переменной.
Область ее действия была здесь, здесь она
была объявлена и здесь она закончилась.
Мы же пытаемся использовать ее тут.
А она не может быть использована.
Назначение udacicolaVotes локальной
не было верным решением в нашем случае.
Я могу суммировать все это двумя пунктами.
Она не сохраняет голоса между
нажатиями кнопки и находится
вне области действия метода showMeVotes.
Так что это вызовет ошибки.
В действительности код не будет скомпилирован.
Посмотрим на другую
переменную данной программы.
Size ilk sorduğum şey,
udacicolaOyları’nın, yerel bir değişken mi
yoksa küresel bir değişken mi olduğuydu.
Yerel bir değişken olarak
belirlemeliydiniz.
Peki, bunun nedenini kavramak için buraya
yani değişkenin bildirildiği yere gidin,
veri türü tam şurada olduğu için,
değişkenin bildirildiğini biliyorsunuz.
Peki, metodun, yani çengelli
parantezlerin
içinde mi yoksa dışında mı bildirilmiş?
Eğer metod içinde
bildirildiyse,
bu yerel değişken olduğu anlamına gelir ve
gerçekten metot içinde bildirildiğini
açık biçimde görebiliriz.
Yani yerel bir değişkendir.
Pekala, bunun anlamı nedir?
Kendimize şunu sormalıyız:
bir şeyi yerel değişken olarak bildirdim,
başka türlü de yapabilir miydim?
Bu örnek üzerinden,
bunun üzerine düşünelim.
İşte telefonumuz.
Udacicola üzerine konuşuyorduk, bu nedenle
yalnızca udacicola tuşuna
bastığımız da ne olduğuna odaklanalım.
Tuşa bastığımız zaman
metot yürütülmeye başlar.
Udacicola oylarına sıfır değeri verir ve
sonra sıfır olan udacicolaOylarına
bir ekler.
Böylece udacicolaOyları 1 olur.
udacicolaOyları yerel bir değişken
olduğu için, bu metodun sonunda,
bir şekilde noktalanır
ya da silinir.
Yerel bir değişken olması
nedeniyle metodun sonunda
udacicolaOylarının silinmesi
iki soruna neden olur.
Bu neden bir sorundur?
Pekala, eğer üç farklı insan
tuşa basarak,
udacicola'ya oy verseydi,
udacicolaOyları'nun üç olması gerekirdi.
Gerçekte olan ise,
tuşa ilk tıklandığında,
udacicolanın sıfırlanmasıdır.
Bir olması için, 1 eklenmesi gerekir.
1 olduktan sonra silinir.
Artık yoktur.
ikinci kez biri
udacicolaOyları'na tıklarsa
udacicolaOyları
yeni baştan oluşur.
Yeniden bildirilir.
Hatırlayın, çünkü ilk seferde
bütünüyle silinmişti.
Yani yeniden oluşturulmaya
ihtiyacı vardır.
Ve tekrar oluşturulduğunda
değer sıfırdır.
Tekrar 1 ekliyoruz ama
unutmayın değer sıfır.
Bu nedenle, tuşa iki kere tıklanmış
olsa bile, udacicola hala birdir.
Aynı şey üçüncü kez
tıklandığı zaman da olur,
Tekrar bir olur ve metodun sonunda
yine silinir.
İşte bu ilk problemdir.
İki tıklama arasında
durum kaydı yapılamıyor.
Yani kaç insanın oy verdiği
kaydedilemiyor.
Diğer bir problem ise,
bu kodun hata verecek olmasıdır.
Bunun arkasındaki neden,
dana önce söylediğim gibi,
udacicolaOyları'nın oluşması ve
faaliyetinin tam burada başlamasıdır.
Daha sonra
metodun sonunda
silinir ve
oluşumu sonlanır.
Bunun anlamı, buraya geldiğim zaman
udacicola gerçekten mevcut olmamasıdır.
Teknik olarak söylersek,
bu değişken faaliyet dışıdır.
Faaliyet alanı burasıdır,
burada bildirilir ve sonlanır.
Ama biz bunu burada kullanmak istiyoruz.
lakin kullanılamıyor.
udacicolaOyları'nın yerel olarak atanması
bu örnekte doğru bir karar değildi.
Bunun neden böyle olduğunu
şu iki nokta ile özetleyebilirim.
Tıklamalar arasında oylar kaydedilmiyor
oylarıBanagöster metodu
faaliyet alanı içinde değil.
Böylece hatalar ortaya çıkıyor.
Ve derleme mümkün olmuyor.
Pekala, şimdi bu programdaki
başka bir değişkene bakalım.
Điều đầu tiên mà tôi hỏi bạn,
là udacicolaVotes là biến cục bộ
hay biến toàn cục.
Và bạn cần xác định
rằng nó là biến cục bộ.
Vâng, để tìm hiểu, bạn đi đến nơi
khai báo biến, trong trường hợp này là
ở đây, và bạn biết nó đã được khai báo,
vì kiểu dữ liệu ở ngay tại đây.
Bạn xem nó có được khai báo Bên trong
phương thức, có nghĩa là ở giữa hai
dấu ngoặc ôm ở đây, hay
nó được khai báo bên ngoài phương thức?
Bây giờ, nếu nó được khai báo
bên trong của một phương thức,
thì có nghĩa rằng nó là một biến cục bộ,
ta có thể thấy rõ ràng rằng trong thực tế
nó được khai báo bên trong phương thức.
Nên nó là biến cục bộ.
Ồ, vậy điều đó có nghĩa là gì?
Chúng ta cũng nên tự hỏi,
nếu tôi khai báo một thứ là
một biến cục bộ, tôi có nên?
Hãy nghĩ về nó trong trường hợp này.
Đây là điện thoại của chúng tôi.
Chúng ta đã nói về udacicola, nên
hãy chỉ tập trung vào khi chúng ta
nhấn nút udacicola.
Khi ta nhấn vào nút này,
phương thức này bắt đầu.
Nó đặt phiếu udacicola bằng không,
sau đó nó thêm một vào udacicolaVotes,
thứ hiện đang bằng không.
Và udacicolaVotes trở thành một.
Vì udacicolaVotes là biến cục bộ,
ở cuối phương thức này,
nó sẽ biến mất hoặc bị xóa,
udacicolaVotes bị đẩy vào thùng rác, hoặc
biến mất, khi kết thúc phương thức này vì
nó là một biến cục bộ,
gây ra một số vấn đề.
Vậy, tại sao nó là một vấn đề?
Bạn sẽ nghĩ rằng nếu
ba người khác nhau bình chọn cho
udacicola bằng cách nhấn vào nút,
mà udacicolaVotes phải bằng ba.
Vâng, điều xảy ra là lần đầu tiên
khi bạn nhấn vào nút, udacicola
trở thành không.
Nó thêm một vào, và trở thành một.
Và rồi nó bị đẩy vào thùng rác.
Nó không còn tồn tại nữa.
Lần thứ hai người nào đó
nhấp chuột vào udacicolaVotes,
udacicolaVotes được thực hiện
thêm một lần nữa.
Nó lại được khai báo.
Bởi vì, hãy nhớ rằng lần đầu tiên
nó đã bị gạt vào thùng rác.
Nên nó cần phải được làm lại.
Và khi nó vẫn còn, nó được đặt bằng không.
Bây giờ chúng ta thêm một vào, nhưng
nhớ giá trị là không.
Vậy nên udacicolaVotes vẫn là một,
dù đã nhấn vào nút đó hai lần.
Và điều tương tự sẽ xảy ra khi
nhấn vào nút đó lần thứ ba,
nó vẫn là một và nó lại bị xóa
một lần nữa ở cuối phương thức này.
Đó là vấn đề đầu tiên.
Nó thực ra không lưu trạng thái
giữa các lần nhấn nút.
Khoảng bao nhiêu người đã bình chọn cho
udacicola.
Nhưng vấn đề là ở đây, đoạn mã
này gây ra một lỗi.
Và lý do của nó là vì
hãy nhớ tôi đã nói rằng udacicolaVotes
tồn tại hoặc
phạm vi của nó bắt đầu ngay đây.
Sau đó ở cuối
phương thức voteudacicola này.
Là thùng rác, nó không còn tồn tại.
Có nghĩa là khi tôi đến đây,
udacicolaVotes không tồn tại.
Nói một cách kỹ thuật hơn thì
biến này nằm ngoài phạm vi.
Phạm vi của nó ở đây,
Nó được khai báo ở đây và kết thúc ở đây.
Nhưng ta đang cố gắng dùng nó ở đây.
Và không thể dùng được nó.
Để udacicolaVotes là biến cục bộ không là
quyết định đúng đắn trong trường hợp này.
Và tôi có thể tóm tắt lý do tại sao
với hai điểm này.
Nó không lưu các phiếu giữa các lần
nhấn nút, và nó không thuộc phạm vi của
phương thức cho tôi thấy các phiếu.
Vì vậy, nó thực ra sẽ gây ra lỗi.
Nên nó sẽ không biên dịch.
Giờ hãy xem đến các
biến khác trong chương trình này.
所以我问你的第一个事情是
udacicolaVotes 是一个局部变量还是一个全局变量
然后你已经判断它是局部变量
好的 为了证明它 你要去声明这个变量的地方 在这
你知道它已经声明了 因为数据类型已经在这了
你看到这是一个方法内的声明 意味着在这两个花括号之间
或者它是方法外的声明?
现在 如果它是方法内的声明
这意味着它是一个局部变量
我们可以清楚看到方法内的声明
所以它是一个局部变量
好的 这意味着什么?
我们应该常常问自己
如果我声明局部变量 我应该怎么做?
让我们在这个例子里思考
这是我们的手机
我们已经讨论过 udacicola 所以
我们只关注点击 udacicola 按钮的时候
当我们点击这个按钮 这个方法开始
它将 udacicolaVotes 归零 并将1票加给 udacicolaVotes
udacicolaVotes 的初始值是0
所以 udacicolaVotes 变为1
现在 因为 udacicolaVotes 是局部变量 在这个方法的最后
它实际上注销了 或者说被删除了
事实上 udacicolaVotes 已经废除了 或者 在这个方法的最后因为
它是局部变量 导致两个问题
为什么引起这些问题?
好的 你可以想象三个不同的人投票给 udacicola
通过点击按钮 udacicolaVvotes 会变为3
好的 当你第一次点击按钮时会发生 udacicola
归零
它加了1 变为1
之后它废除了
它就再也不存在了
第二次有人点击 udacicolaVvotes
udacicolaVvotes 再把那些做一遍
它再一次声明
因为记得 第一次本质上已经废除了
所以它需要资源回收
当它资源回收 它归零
现在我们再对它加1 不过记得值是0
所以 udacicolaVvotes 依然是1 甚至当按钮被按两次
当点击三次同样的事情会发生
它还是1并且再次废除在方法的最后
所以这是第一个问题
它实际上没有存储点击两次的状态
关于多少人投票给 udacicola
不过另一个问题在这里 这段代码有一个错误
原因是 记得我说过的 udacicolaVvotes
存在或它的作用域开始于这里
在 voteudacicola 方法的最后
它被废除了 它不存在了
意味着当我回到这 udacicolaVotes 已经不存在了
更深技术层面 我们说这个变量不在作用域内
它的作用域在这 它声明在这 它在这结束
我们试着把它用在这
它不能使用
在这个例子里将 udacicolaVotes 定义为局部变量是不正确的决定
我把它总结为这两点
它在两次点击按钮之间不能保存票数 并且对于显示 Votes 方法
不是在作用域里
所以这会引起错误
这不能被编译
好的 让我们看看这个程序的另一个变量
我要問你的第一件事情是
udacicolaVotes是一個區域變數還是全域變數
你應該確定它是一個區域變數
為了弄清楚這一點 請轉至宣告這個變數的位置
就是在這里 你知道我們已經宣告這個變數 因為在這里資料類型是正確的
你可以看到它是在一個方法內宣告的 這是在兩個花括號之間
還是在方法之外宣告的呢
如果是在方法內部宣告的
那就是一個區域變量
我們可以看得很清楚 它是在方法內宣告的
因此它是一區域變數
這意味著什么呢
我們應該問我們自己
如果聲明為區域變數 將會得到什么
以這個例子 我們來思考
這是我們的電話
我們討論的是udacicola
當我們按一下udacicola按鈕時
當我們按一下這個按鈕時 這個方法開始執行
它把udacicolaVotes投票數設定為0 然后加一到udacicolaVotes
后者是0
因此udacicolaVotes變成1
因為udacicolaVotes是一個區域變量 位于這個方法的末尾
它實際上會消失 或者刪除
在這個方法的末尾 udacicolaVotes會被作為垃圾處理或消失
因為它是一個區域變數 而造成一些問題
為什么這是一個問題呢
你可以想像一下 有三個不同的人按一下按鈕
為udacicola投票 udacicolaVvotes應該是三
實際上的情況是 你第一次按下按鈕時
udacicola變成0
然后加一 變成一
然后被作為垃圾被回收
從而不再存在
一個人第二次按udacicolaVotes時
就重新產生udacicolaVotes
并再次宣告
請記住 在第一次按下按鈕時 它已經被作為垃圾回收
因此需要重新創建
在它處于保留狀態時 它被設定為零
現在我們再次將它加一 但是請記住值是零
因此udacicolaVotes仍然是一 盡管按鈕被按下兩次
第三次按下時 發會生同樣的事情
它仍然是一 在此方法結束時它實際作為垃圾回收
這是第一個問題
在兩次按擊之間 并沒有累計
有多少人為udacicola投票
這里的另一個問題是 此代碼實際上會拋出錯誤
原因是 前面我說過
udacicolaVotes在這里出現 它的范圍啟始于這里
在這個voteudacicola方法的末尾
它作為垃圾被回收 從而不再存在
這意味著在這里udacicolaVotes實際上不存在
更具體地說 這個變數已經超出范圍
它的范圍是這里 在這里宣告 在這里結束
但是我們嘗試在這里使用它
它不能被使用
在這個例子中 把udacicolaVotes設為區域變數不是一個正確的決定
原因有兩點
第一 在兩次按下按鈕之間它沒有保存投票數
第二 它不在演示性投票計數方法的范圍之內
因此它實際上會造成問題
這將不會被編譯
讓我們來看程式中的另一個變數