1
00:00:00,000 --> 00:00:05,410

2
00:00:05,410 --> 00:00:07,640
>> ડો LLOYD: બધા હક છે, તેથી
માતાનો આંટીઓ વિશે વાત કરો.

3
00:00:07,640 --> 00:00:10,015
તેથી આંટીઓ પ્રકારની ઠંડી હોય છે
તેઓ તમારા કાર્યક્રમ માટે પરવાનગી આપે છે કારણ કે

4
00:00:10,015 --> 00:00:12,050
કોડ રેખાઓ ચલાવવા માટે
ઉપર અને ઉપર અને ઉપર.

5
00:00:12,050 --> 00:00:15,600
વારંવાર કર્યા વગર નકલ કરવા
અને પેસ્ટ કરો અથવા અન્યથા તેમને પુનરાવર્તન કરો.

6
00:00:15,600 --> 00:00:17,630
મુખ્ય ત્રણ છે
તમે જોશો આંટીઓ પ્રકારના.

7
00:00:17,630 --> 00:00:21,010
તમે કદાચ વાપરવા માટે પ્રસંગ પડશે
દરેક એક તમે CS50 મારફતે પ્રગતિ તરીકે.

8
00:00:21,010 --> 00:00:22,940
આ આંટીઓ કેટલાક ખૂબ છે
સ્ક્રેચ માંથી તમે પરિચિત,

9
00:00:22,940 --> 00:00:25,814
તેથી ફરી, અમે શરતો કર્યું,
અમે બાજુ દ્વારા બાજુ તેમને મૂકીશું

10
00:00:25,814 --> 00:00:28,930
એક સાધર્મ્ય હોય તો અમે ડ્રો કરી શકો છો.

11
00:00:28,930 --> 00:00:33,600
>> પ્રથમ, સ્ક્રેચ માંથી કાયમ છે
જે જ્યારે (સત્ય) માટે સરખાવે છે.

12
00:00:33,600 --> 00:00:35,390
આ અમે એક અનંત લૂપ કૉલ છે.

13
00:00:35,390 --> 00:00:38,560
આ સર્પાકાર વચ્ચે કોડ લીટીઓ
કૌંસ, ખૂબ પઝલ ટુકડાઓ જેવા

14
00:00:38,560 --> 00:00:41,190
સી અંદર ફિટ
કાયમ બ્લોક છે,

15
00:00:41,190 --> 00:00:45,290
ટોચ પરથી વારંવાર ચલાવવા કરશે
નીચે, ઉપર અને ઉપર અને ઉપર,

16
00:00:45,290 --> 00:00:46,085
કાયમ.

17
00:00:46,085 --> 00:00:48,710
તમામ કર્યા પછી, તમે અમારી યાદ તો
બુલિયન અભિવ્યક્તિઓ ચર્ચા,

18
00:00:48,710 --> 00:00:51,060
સાચું હંમેશા સાચું છે.

19
00:00:51,060 --> 00:00:53,250
અમે કરી રહ્યા છીએ તેથી જો
સાચું, જેથી લાંબા કંઈક

20
00:00:53,250 --> 00:00:58,227
તે true-- છે થોડી silly-- સાચું લાગે છે
હંમેશા સાચી છે, તેથી તે હંમેશા સ્કોર પડશે.

21
00:00:58,227 --> 00:01:00,060
તે કાયમ સ્કોર પડશે અને
ક્યારેય અને ક્યારેય અમે સુધી

22
00:01:00,060 --> 00:01:02,900
સાથે બહાર ભંગ કરવા માટે એક માર્ગ શોધવા
વિરામ નિવેદન, જે ફરી,

23
00:01:02,900 --> 00:01:06,350
અમે થોડી જ્યારે પહેલા જોયું અમે
સ્વીચ વિશે વાત કરવામાં આવી હતી.

24
00:01:06,350 --> 00:01:08,725
>> અથવા તો માત્ર મારવા અમારા
કાર્યક્રમ, કે જે આકસ્મિક,

25
00:01:08,725 --> 00:01:11,110
શું તમે ક્યારેય એક જાતે શોધી તો
એક અનંત લૂપ સાથે પરિસ્થિતિ

26
00:01:11,110 --> 00:01:13,484
અને તમે બંધ કરવા માટે કેવી રીતે ખબર નથી
ચાલી માંથી તમારા કાર્યક્રમ.

27
00:01:13,484 --> 00:01:16,527
જસ્ટ નિયંત્રણ સી હિટ અને
કે તમે તમારા કાર્યક્રમ મારવા પડશે.

28
00:01:16,527 --> 00:01:18,360
પરંતુ આ, ફરીથી, છે
એક અનંત લૂપ કહેવાય છે.

29
00:01:18,360 --> 00:01:19,818
તે કાયમ ચાલશે કે લૂપ છે.

30
00:01:19,818 --> 00:01:22,570

31
00:01:22,570 --> 00:01:25,610
હવે, જ્યારે આંટીઓ નથી
હંમેશા અનંત, પણ કારણ કે

32
00:01:25,610 --> 00:01:27,880
અમે બુલિયન બદલો કરી શકો છો
કંઈક સાથે અભિવ્યક્તિ

33
00:01:27,880 --> 00:01:29,867
થોડી વધુ ઉપયોગી કરતાં માત્ર સાચું.

34
00:01:29,867 --> 00:01:30,950
તેથી અહીં અન્ય એક ઉદાહરણ છે.

35
00:01:30,950 --> 00:01:34,600
જ્યારે કેટલાક બુલિયન
અભિવ્યક્તિ અને પછી સર્પાકાર કૌંસ.

36
00:01:34,600 --> 00:01:38,310
તે સરખું ખૂબ ખૂબ છે
શરૂઆતથી સુધી પુનરાવર્તન.

37
00:01:38,310 --> 00:01:40,700
બીજા, હું પડશે, તેમ છતાં
આ તફાવત સમજાવે છે.

38
00:01:40,700 --> 00:01:44,310
>> , સી જેથી બુલિયન અભિવ્યક્તિ તો
જ્યારે લૂપ ની અંદર

39
00:01:44,310 --> 00:01:47,980
સાચા, લીટીઓ માટે મૂલ્યાંકન
સર્પાકાર કૌંસ વચ્ચે કોડ

40
00:01:47,980 --> 00:01:51,900
ઉપર અને ઉપર વારંવાર ચલાવવા કરશે
અને ઉપર બુલિયન અભિવ્યક્તિ સુધી

41
00:01:51,900 --> 00:01:55,174
ખોટા મૂલ્યાંકન.

42
00:01:55,174 --> 00:01:57,340
તેથી ઉદાહરણ તરીકે, તમે કદાચ
કાઉન્ટર અમુક પ્રકારના હોય છે.

43
00:01:57,340 --> 00:02:01,440
તેથી શરૂઆતમાં તમે કહી
આ લૂપ પૂર્ણાંક એક્સ શૂન્ય બરાબર કહે છે.

44
00:02:01,440 --> 00:02:06,370
X 100 કરતાં ઓછી છે, એક દંપતિ કરવા
કે સર્પાકાર કૌંસ અંદર વસ્તુઓ,

45
00:02:06,370 --> 00:02:10,570
પછી તમારા લૂપ અંતે, તમે કહી
x વત્તા પ્લસ, જો તમે X incrementing કરી રહ્યાં છો.

46
00:02:10,570 --> 00:02:13,360
આખરે એક્સ મળશે
100 અને તમે

47
00:02:13,360 --> 00:02:15,760
શરત કારણ કે બંધ
X 100 કરતાં ઓછી છે

48
00:02:15,760 --> 00:02:19,416
લાંબા સમય સુધી સાચું હશે
ટૂંક સમયમાં એક્સ 100 બરાબર છે.

49
00:02:19,416 --> 00:02:21,820
100 100 કરતાં ઓછી નથી.

50
00:02:21,820 --> 00:02:25,870
>> હવે કંઈક અંશે ભેળસેળ, વર્તન
શરૂઆતથી બ્લોક વિપરીત છે.

51
00:02:25,870 --> 00:02:29,110
આ છે તેથી જો ખરેખર કાળજી રાખો
આંટીઓ ઉપયોગ કરીને તમારા પ્રથમ ધાડ.

52
00:02:29,110 --> 00:02:33,630
મૂળભૂત રીતે, વારંવાર
સ્ક્રેચ બ્લોક સુધી

53
00:02:33,630 --> 00:02:35,970
કંઈક પુનરાવર્તન કરશે
અને ઉપર અને ઉપર,

54
00:02:35,970 --> 00:02:40,460
અભિવ્યક્તિ, ત્યાં સુધી બુલિયન
ષટ્કોણાકૃતિ અભિવ્યક્તિ સાચું છે.

55
00:02:40,460 --> 00:02:43,860
તેથી તે કરી રાખશે
તે સાચું છે ત્યાં સુધી.

56
00:02:43,860 --> 00:02:48,881
દરમિયાન, જ્યારે લૂપ ચાલશે
તે ખોટા છે ત્યાં સુધી તે કરવા માટે ચાલુ.

57
00:02:48,881 --> 00:02:51,630
તેથી તેઓ તદ્દન સમાન છો, પરંતુ
કે જે હમણાં જ થોડો તફાવત છે

58
00:02:51,630 --> 00:02:55,140
તમે ખાસ કરીને કારણ કે ખૂબ કાળજી રાખો માટે
સંક્રમણ તમારા પ્રથમ ધાડ

59
00:02:55,140 --> 00:02:58,149
સી માં ખંજવાળી.

60
00:02:58,149 --> 00:03:00,190
લૂપ આગળના પ્રકારની છે
ખરેખર ખૂબ સમાન.

61
00:03:00,190 --> 00:03:02,860
તે શું જ્યારે લૂપ કહેવાય છે.

62
00:03:02,860 --> 00:03:07,060
આ લૂપ બધા લીટીઓ ચલાવવા કરશે
એક વખત આ સર્પાકાર કૌંસ વચ્ચે કોડ,

63
00:03:07,060 --> 00:03:09,530
અને પછી તે તપાસ કરશે
બુલિયન અભિવ્યક્તિ.

64
00:03:09,530 --> 00:03:11,700
બુલિયન અભિવ્યક્તિ તો
સાચું મૂલ્યાંકન,

65
00:03:11,700 --> 00:03:14,340
તે પાછા જાઓ અને પુનરાવર્તન કરશો
ઉપર અને ઉપર કે પ્રક્રિયા

66
00:03:14,340 --> 00:03:17,690
અને ઉપર બુલિયન સુધી
અભિવ્યક્તિ false પર મૂલ્યાંકન.

67
00:03:17,690 --> 00:03:23,370
તેથી આ લૂપ, જ્યારે લૂપ જેમ નહિં પણ, છે
ઓછામાં ઓછી એક સમય ચલાવવા માટે ખાતરી આપી.

68
00:03:23,370 --> 00:03:26,080
આ એક ખૂબ સુંદર ઉપયોગી હોઈ શકે છે.

69
00:03:26,080 --> 00:03:28,011
>> છેલ્લે, અમે લૂપ માટે હોય છે.

70
00:03:28,011 --> 00:03:30,010
આંટીઓ માટે પ્રકારની છે
વાક્યરચના અનુસાર unattractive

71
00:03:30,010 --> 00:03:32,330
અને જતા ઘણો છે
અહીં, તેથી મારી સાથે સહન

72
00:03:32,330 --> 00:03:34,640
અમે પ્રયાસ અને આ સિવાય ટુકડાઓ તોડી છે.

73
00:03:34,640 --> 00:03:36,810
સામાન્ય રીતે, ઉપયોગ કેસ
લૂપ માટે તમે છે

74
00:03:36,810 --> 00:03:40,136
કંઈક પુનરાવર્તન કરવા માંગો છો
વખત ચોક્કસ સંખ્યા.

75
00:03:40,136 --> 00:03:42,010
અહીં આ ઉદાહરણમાં,
હું વારંવાર બ્લોક હોય

76
00:03:42,010 --> 00:03:44,010
સ્ક્રેચ માંથી, જે
લૂપ માટે સમાન

77
00:03:44,010 --> 00:03:47,340
સી, કંઈક 10 વખત પુનરાવર્તન.

78
00:03:47,340 --> 00:03:49,250
અને લૂપ માટે
ત્યાં ડાબી, જે

79
00:03:49,250 --> 00:03:51,410
ચાર લૂપ છે કે
આ જ વાત કરી શકે છે.

80
00:03:51,410 --> 00:03:52,570
આ 10 વખત જાઓ કરશે.

81
00:03:52,570 --> 00:03:56,720
શૂન્ય થી ગણતરી, અમે
આ લૂપ દરેક પાસ વધારો.

82
00:03:56,720 --> 00:03:59,220
અને અમે તે કરવાનું ચાલુ રાખી
હું કરતાં ઓછી 10 છે ત્યાં સુધી.

83
00:03:59,220 --> 00:04:00,134
>> તેથી શું થાય છે?

84
00:04:00,134 --> 00:04:01,550
ત્યાં કોડ સંપૂર્ણ ઘણો છે.

85
00:04:01,550 --> 00:04:03,424
માટે જે તે નીચે તોડી દો
શું પગલું શું થઈ રહ્યું છે

86
00:04:03,424 --> 00:04:05,684
પગલું દ્વારા અમે લૂપ માટે મારફતે ડિગ છે.

87
00:04:05,684 --> 00:04:08,350
થયું કે પ્રથમ વસ્તુ છે
કાઉન્ટર ચલ કેન્દ્ર છે.

88
00:04:08,350 --> 00:04:11,970
કે પ્રથમ ડાબી બધું
કૌંસ અંદર અર્ધવિરામ

89
00:04:11,970 --> 00:04:12,970
ચલાવવામાં આવે છે.

90
00:04:12,970 --> 00:04:15,180
આ કિસ્સામાં, અમે છે
હું 0 બરાબર પૂર્ણાંક કહે છે.

91
00:04:15,180 --> 00:04:18,709
હું નામની એક નવી ચલ જાહેર,
ચલો કે એક પ્રકાર પૂર્ણાંક છે

92
00:04:18,709 --> 00:04:22,570
અને અમે અંદર કિંમત કહી રહ્યાં છે
કે ચલ શૂન્ય હોઈ ચાલે છે.

93
00:04:22,570 --> 00:04:25,480
>> અમે શું બીજા વસ્તુ છે
અમે પછી તરત જ મૂલ્યાંકન

94
00:04:25,480 --> 00:04:26,750
બુલિયન અભિવ્યક્તિ.

95
00:04:26,750 --> 00:04:30,100
બુલિયન અભિવ્યક્તિ છે
બે અર્ધવિરામ મધ્યમ.

96
00:04:30,100 --> 00:04:31,360
હું કરતાં ઓછી 10 છે.

97
00:04:31,360 --> 00:04:32,410
તે સાચું છે, અહીં વાત સાચી છે?

98
00:04:32,410 --> 00:04:36,030
અમે હમણાં જ હું બરાબર છે જણાવ્યું હતું કે
શૂન્ય છે, અને તેથી 0, 10 કરતાં ઓછી છે

99
00:04:36,030 --> 00:04:38,040
અને જેથી શરત
સાચું છે અને અમે હવે કરશે

100
00:04:38,040 --> 00:04:40,640
આ લૂપ શરીર ચલાવવા માટે આગળ ધપાવો.

101
00:04:40,640 --> 00:04:41,480
તો તે ખોટું હતું.

102
00:04:41,480 --> 00:04:46,380
જો, ઉદાહરણ તરીકે, હું બદલે જણાવ્યું હતું કે
હું 0 છે હું 15 બરાબર જણાવ્યું હતું કે બરાબર

103
00:04:46,380 --> 00:04:47,820
હું 15 બરાબર INT.

104
00:04:47,820 --> 00:04:51,450
વેલ 15 10 કરતાં ઓછી હોય છે, તેથી અમે
લૂપ શરીરમાં દાખલ ક્યારેય કરશે

105
00:04:51,450 --> 00:04:55,450
બુલિયન અભિવ્યક્તિ કારણ કે
ખોટા હોય મૂલ્યાંકન કરશે.

106
00:04:55,450 --> 00:04:59,060
>> અમે નીચે ટોચ પરથી પસાર થાય છે પછી,
અમે સર્પાકાર તાણવું બંધ કે અનુભવી

107
00:04:59,060 --> 00:05:00,830
ત્રીજા વસ્તુ થાય છે.

108
00:05:00,830 --> 00:05:03,840
કાઉન્ટર ચલ છે
વધે, અથવા બદલે, આ લાઇન્સ

109
00:05:03,840 --> 00:05:07,790
એક નિવેદનમાં કોડ પછી
આ અંદર બીજા અર્ધવિરામ

110
00:05:07,790 --> 00:05:10,500
આંટીઓ કૌંસ માટે ચલાવવામાં આવે છે.

111
00:05:10,500 --> 00:05:13,250
તેથી અમે બહાર શરૂ
હું 0 બરાબર પૂર્ણાંક કહે છે.

112
00:05:13,250 --> 00:05:15,770
પછી અમે કે નહીં તપાસો
બુલિયન અભિવ્યક્તિ સાચું છે.

113
00:05:15,770 --> 00:05:17,469
0 10 તેથી તે સાચું છે, કરતાં ઓછી છે.

114
00:05:17,469 --> 00:05:19,510
તેથી અમે આગળ વધવા માટે જઈ રહ્યાં છો
શરીર લૂપ.

115
00:05:19,510 --> 00:05:22,676
વસ્તુઓ લૂપ અંદર થાય છે, અને કરશે
અમે બંધ સર્પાકાર કે સામનો કરવો પડે ત્યારે

116
00:05:22,676 --> 00:05:25,660
તાણવું, આગામી વસ્તુ અમે
શું અમે હું વત્તા, વત્તા કહે છે.

117
00:05:25,660 --> 00:05:28,860
હું શૂન્ય હવે હું એક છે.

118
00:05:28,860 --> 00:05:33,100
પછી, અમે ફરીથી ની કિંમત તપાસો
મધ્યમાં બુલિયન અભિવ્યક્તિ.

119
00:05:33,100 --> 00:05:34,900
એક ઓછી કરતાં 10 છે.

120
00:05:34,900 --> 00:05:38,325
તેથી અમે આ મારફતે જાઓ પડશે
ફરીથી અને ફરીથી પ્રક્રિયા કરે છે.

121
00:05:38,325 --> 00:05:40,590
અમે બંધ મળશે
ફરી સર્પાકાર તાણવું.

122
00:05:40,590 --> 00:05:44,090
અમે હું વધારતી પડશે
1 થી 2 અને 2 થી 3.

123
00:05:44,090 --> 00:05:48,290
અને તેથી પર અને તેથી પર અને તેથી પર, ત્યાં સુધી
છેવટે હું કિંમત 10 બની જાય છે.

124
00:05:48,290 --> 00:05:49,950
10 10 કરતાં ઓછી છે?

125
00:05:49,950 --> 00:05:51,200
નંબર

126
00:05:51,200 --> 00:05:53,800
0 થી ગણતરી, અમે ચાલ્યા કર્યું
લૂપ 10 iterations દ્વારા.

127
00:05:53,800 --> 00:05:57,204
અમે હમણાં જ 10 વખત પુનરાવર્તન કર્યું
અમે સ્ક્રેચ બ્લોક હતી.

128
00:05:57,204 --> 00:05:59,370
અને તેથી તે મૂળભૂત રીતે માતાનો
ચાર લૂપ માટે પ્રક્રિયા.

129
00:05:59,370 --> 00:06:01,630
>> હવે દૂર લઈ
વાસ્તવિક કોડ અને મૂકી

130
00:06:01,630 --> 00:06:05,120
માત્ર કેટલાક પાયાના સામાન્ય નિવેદનો.

131
00:06:05,120 --> 00:06:06,550
અહીં શું થાય છે.

132
00:06:06,550 --> 00:06:09,290
બધા નિવેદનો
પ્રથમ ચલાવવામાં આવે છે શરૂ કરો.

133
00:06:09,290 --> 00:06:11,260
તમે એક કરતાં વધુ હોઈ શકે છે.

134
00:06:11,260 --> 00:06:13,440
પછી, બુલિયન અભિવ્યક્તિ ચકાસેલ છે.

135
00:06:13,440 --> 00:06:17,850
અભિવ્યક્તિ સાચું મૂલ્યાંકન, તો
શરીર લૂપ એક સમય ચલાવો.

136
00:06:17,850 --> 00:06:21,060
અભિવ્યક્તિ મૂલ્યાંકન તો
ખોટા કરવા માટે, અમે પૂર્ણ કરી રહ્યાં છો.

137
00:06:21,060 --> 00:06:23,040
અમે ચલાવવા નથી
બધા અંતે લૂપ શરીર.

138
00:06:23,040 --> 00:06:25,530
અમે ચલાવવામાં કર્યું પછી
શરીર લૂપ એક સમય,

139
00:06:25,530 --> 00:06:29,487
અમે પછી શું કરવું
ત્યાં ઈજાફો ભાગ છે.

140
00:06:29,487 --> 00:06:31,820
જે સામાન્ય રીતે હોવું રહ્યું છે
હું કંઈક પ્લસ, વત્તા

141
00:06:31,820 --> 00:06:34,510
કે જેમ કે કંઈક કે
એક કાઉન્ટર ચલ સુધારે.

142
00:06:34,510 --> 00:06:37,390
પછી, પછી અમે અમે વધારો
ફરી અભિવ્યક્તિ તપાસો

143
00:06:37,390 --> 00:06:41,120
અને ઉપર અને ઉપર તે પગલાંઓનું પુનરાવર્તન
અને અભિવ્યક્તિ છે ત્યાં સુધી

144
00:06:41,120 --> 00:06:42,890
લાંબા સમય સુધી સાચું.

145
00:06:42,890 --> 00:06:44,469
>> તેથી લૂપ માટે ઉપયોગ કિસ્સાઓમાં શું છે?

146
00:06:44,469 --> 00:06:46,760
તમે જ્યારે લૂપ વાપરો જ્યારે ઉપયોગ કરો
તમે લૂપ પુનરાવર્તન કરવા માંગો છો

147
00:06:46,760 --> 00:06:51,200
વખત અજ્ઞાત નંબર છે, પરંતુ
તે કદાચ બધા રન કરી શકે છે.

148
00:06:51,200 --> 00:06:53,940
એક ખરેખર સામાન્ય ઉદાહરણ
રહ્યાં જ્યારે ઉપયોગ કરવામાં

149
00:06:53,940 --> 00:06:56,480
રમત માટે કન્ટ્રોલ ફ્લો ચાલે છે.

150
00:06:56,480 --> 00:06:59,040
તમે જાણતા નથી શકે છે કેવી રીતે લાંબા સમય સુધી
વપરાશકર્તા રમી શકાય રહ્યું છે,

151
00:06:59,040 --> 00:07:01,440
પરંતુ તમે રાખવા માંગો છો
આ જ વાત કરી.

152
00:07:01,440 --> 00:07:04,970
સ્થિતિ સુધારી રહ્યા છીએ
બોર્ડ પર વિવિધ sprites.

153
00:07:04,970 --> 00:07:07,490
તમે વસ્તુઓ રાખવા માંગો છો
બધા સમયે ખસેડવાની,

154
00:07:07,490 --> 00:07:09,110
પરંતુ તમે જ્યારે ખબર નથી
વપરાશકર્તા રમતા રોકી રહ્યું છે

155
00:07:09,110 --> 00:07:10,450
અથવા તેઓ જઈ રહ્યાં છો ત્યારે
જીવન બહાર ચલાવવા માટે.

156
00:07:10,450 --> 00:07:12,741
તેથી જ્યારે લૂપ ખરેખર છે
કે કંઈક માટે સારી.

157
00:07:12,741 --> 00:07:14,130
તે એક સારો ઉપયોગ કેસ છે.

158
00:07:14,130 --> 00:07:16,230
>> એક ડુ જ્યારે લૂપ,
તે ખૂબ જ છે.

159
00:07:16,230 --> 00:07:19,746
તમે લૂપ અજ્ઞાત પુનરાવર્તન કરવા માંગો છો
વખત નંબર છે, પરંતુ ઓછામાં ઓછા એક વખત.

160
00:07:19,746 --> 00:07:22,370
તમે એક રમત માટે આ ઉપયોગ કરી શકે છે
પણ છે, પરંતુ ખરેખર સામાન્ય ઉપયોગ કેસ

161
00:07:22,370 --> 00:07:24,420
ઇનપુટ માટે વપરાશકર્તાને પૂછવાની છે.

162
00:07:24,420 --> 00:07:28,609
સામાન્ય રીતે, તમે કંઈક કહી શકે છે
જેમ કે, મને હકારાત્મક પૂર્ણાંક આપે છે,

163
00:07:28,609 --> 00:07:30,650
અને તમે તે મૂકી શકે
જ્યારે લૂપ ડુ અંદર.

164
00:07:30,650 --> 00:07:33,900
તેથી તે હંમેશા તેમને પૂછશે
ઓછા એક વખત હકારાત્મક પૂર્ણાંક માટે.

165
00:07:33,900 --> 00:07:36,850
તેઓ તમને હકારાત્મક પૂર્ણાંક આપે તો,
તમે લૂપ બહાર ભંગ કરી શકે છે.

166
00:07:36,850 --> 00:07:37,599
તમે કરી શકે છે.

167
00:07:37,599 --> 00:07:39,900
બુલિયન અભિવ્યક્તિ
આમ કરતી વખતે ખોટા હોઈ શકે છે.

168
00:07:39,900 --> 00:07:41,137
>> અને તમે તેમને ફરીથી પૂછો નહીં.

169
00:07:41,137 --> 00:07:44,470
તેઓ તમને એક નકારાત્મક સંખ્યા જ્યાં આપો તો
તેઓ કે જે અમુક શબ્દ અથવા કંઈક લખો

170
00:07:44,470 --> 00:07:46,630
ખરેખર ઉપયોગી નથી
તમે આ ઉપયોગ કરી શકે છે

171
00:07:46,630 --> 00:07:49,770
લૂપ પાછા જાઓ અને શું નથી જ્યારે
તે ફરીથી અને ફરીથી અને ફરીથી.

172
00:07:49,770 --> 00:07:52,410
તમે ચોક્કસપણે પૂછી શકો છો
તેમને એક વાર તમે એક નંબર આપે છે

173
00:07:52,410 --> 00:07:56,350
પરંતુ તમે કેવી રીતે ઘણી વખત ખબર નથી
કે પછી તેઓ જંતુઓ હોઈ શકે છે.

174
00:07:56,350 --> 00:08:00,540
અને તે એક મહાન ઉપયોગ શું તેથી, જ્યારે
ઇનપુટ માટે વપરાશકર્તાને પૂછવાની માટે કેસ.

175
00:08:00,540 --> 00:08:03,060
અને આંટીઓ માટે ઉપયોગ
કેસ ખાસ કરીને જ્યારે છે

176
00:08:03,060 --> 00:08:06,230
તમે લૂપ પુનરાવર્તન કરવા માંગો છો
વખત એક અલગ નંબર,

177
00:08:06,230 --> 00:08:08,230
છતાં તમે કદાચ
વખત નંબર ખબર

178
00:08:08,230 --> 00:08:10,040
ક્ષણ કાર્યક્રમ સંકલિત છે.

179
00:08:10,040 --> 00:08:15,510
>> તેથી, ઉદાહરણ તરીકે, કદાચ તમે એક કાર્યક્રમ છે
જ્યાં તમે એક નંબર માટે વપરાશકર્તા પૂછવા.

180
00:08:15,510 --> 00:08:17,660
અને તેઓ 100 દાખલ કરો.

181
00:08:17,660 --> 00:08:20,510
અને પછી તમારા લૂપ માટે કરશે
તે કિસ્સામાં 100 વખત ચાલે છે.

182
00:08:20,510 --> 00:08:22,480
અથવા કદાચ તેઓ દાખલ
તમારા કાર્યક્રમ 1000

183
00:08:22,480 --> 00:08:24,570
અને પછી લૂપ 1,000 વખત ચાલે છે.

184
00:08:24,570 --> 00:08:26,987
તે વખત ચોક્કસ સંખ્યા છે.

185
00:08:26,987 --> 00:08:28,820
તેઓ જરૂરી નથી
શું છે કે નંબર ખબર

186
00:08:28,820 --> 00:08:31,010
સંકલિત છે ક્ષણ કાર્યક્રમ છે.

187
00:08:31,010 --> 00:08:35,010
તે જ્યારે લૂપ જેવું નથી
જ્યાં તે અનંત હોઈ શકે છે.

188
00:08:35,010 --> 00:08:37,127
તે સંખ્યા બદલે છે
તમે માત્ર ખબર નથી.

189
00:08:37,127 --> 00:08:39,210
હવે હું કર્યું હોવા છતાં પણ
દર્શાવેલ આ બધા કિસ્સાઓમાં ઉપયોગ,

190
00:08:39,210 --> 00:08:41,501
તમે તે ખૂબ ખબર જોઈએ
ખૂબ દરેક સંજોગોમાં,

191
00:08:41,501 --> 00:08:44,110
તમે બધા ઇન્ટરચેન્જ કરી શકો છો
આ આંટીઓ ત્રણ.

192
00:08:44,110 --> 00:08:46,890
તમે લૂપ જ્યાં તમે માટે ઉપયોગ કરી શકો છો
અન્યથા જ્યારે લૂપ ઉપયોગ કરશે.

193
00:08:46,890 --> 00:08:49,860
તમે લૂપ ત્યાં માટે ઉપયોગ કરી શકો છો
તમે શું જ્યારે લૂપ અને તેથી પર ઉપયોગ કરશો.

194
00:08:49,860 --> 00:08:53,680
તે ક્યારેક થોડી મુશ્કેલ હોઈ શકે છે
તેથી સામાન્ય રીતે તે એક સારી પ્રથા છે

195
00:08:53,680 --> 00:08:55,140
એક લાક્ષણિક ઉપયોગ કેસ પાલન કરે છે.

196
00:08:55,140 --> 00:08:57,599
જ્યારે લૂપ ડુ જો તમે
ઓછામાં ઓછા એક વખત કંઈક માગે છે.

197
00:08:57,599 --> 00:09:00,514
તમે કરવા માંગો છો, તો લૂપ માટે ઉપયોગ
કંઈક વખત એક ચોક્કસ સંખ્યા.

198
00:09:00,514 --> 00:09:03,730
શા માટે ત્યાં બધા પછી, તે છે
આંટીઓ ત્રણ અલગ અલગ પ્રકારના.

199
00:09:03,730 --> 00:09:06,172
>> તેથી તેઓ ઉપયોગ કરી શકે
યોગ્ય સંદર્ભમાં.

200
00:09:06,172 --> 00:09:07,880
પરંતુ તમે ઇન્ટરચેન્જ કરી શકો છો
તેમને તમે ઇચ્છો છો.

201
00:09:07,880 --> 00:09:10,790
તમે જ્યારે આંટીઓ સાથે આરામદાયક લાગે તો
અને તમે હંમેશા જ્યારે આંટીઓ ઉપયોગ કરવા માંગો છો.

202
00:09:10,790 --> 00:09:12,623
તે કંઈક છે કે
તમે કરી શકો છો, તે છે, તેમ છતાં

203
00:09:12,623 --> 00:09:15,590
થોડી વાક્યરચના અનુસાર હોઈ શકે છે
મુશ્કેલ છે, જ્યાં માટે લૂપ

204
00:09:15,590 --> 00:09:17,850
વધુ ઘણો સરળ હશે.

205
00:09:17,850 --> 00:09:21,100
>> મારું નામ ડો લોયડ છે અને આ CS50 છે.

206
00:09:21,100 --> 00:09:22,688