1
00:00:00,000 --> 00:00:11,420

2
00:00:11,420 --> 00:00:13,590
>> Tianyu લિયુ: અરે, તે કેવી રીતે
તે દરેક વ્યક્તિ જઈને?

3
00:00:13,590 --> 00:00:20,250
અને આ iOS એપ છે
ઉદ્દેશ સી પરિસંવાદ ના પ્રોગ્રામિંગ.

4
00:00:20,250 --> 00:00:21,520
અને મારું નામ Tianyu લિયુ છે.

5
00:00:21,520 --> 00:00:26,114
હું હમણાં એક લોવેલ જુનિયર છું
કોમ્પ્યુટર વિજ્ઞાન ધ્યાન કેન્દ્રીત.

6
00:00:26,114 --> 00:00:28,030
તેથી આ પરિસંવાદ માં હું છું
જઈને તમે ગાય્ઝ શીખવે

7
00:00:28,030 --> 00:00:30,770
એક એપ્લિકેશન બનાવવા માટે કેવી રીતે વિશે થોડુંક.

8
00:00:30,770 --> 00:00:33,030
યે, તે માટે ઉત્સાહિત કરો.

9
00:00:33,030 --> 00:00:36,790
>> અમે પણ ડાઇવિંગ શરૂ કરો તે પહેલાં, તેથી
વાસ્તવિક પ્રોગ્રામિંગ બાજુ માં,

10
00:00:36,790 --> 00:00:41,840
વિશે વાત ઝડપથી માત્ર ખરેખર માતાનો દો
શા માટે તમે એક iOS એપ્લિકેશન બીલ્ડ કરવા માંગો છો શકે?

11
00:00:41,840 --> 00:00:43,940
શા iOS જેથી અદ્ભુત છે?

12
00:00:43,940 --> 00:00:47,250
પ્રથમ સમસ્યા તેથી, પ્રથમ
અમારા માટે ખરેખર અદ્ભુત છે કે વસ્તુ,

13
00:00:47,250 --> 00:00:51,190
ખાસ કરીને એક CS50 તરીકે
વિદ્યાર્થી, એટલે કે આઇઓએસ

14
00:00:51,190 --> 00:00:55,860
ઉદ્દેશ સી વેલ વાપરે છે, ત્યાં
સ્વીફ્ટ નામની એક નવી ભાષા,

15
00:00:55,860 --> 00:00:58,260
પરંતુ અમે નથી જઈ રહ્યાં છો
આ પરિસંવાદ માં કે વાપરો.

16
00:00:58,260 --> 00:01:01,540
તમે ત્યાં, સ્વિફ્ટ રસ ધરાવતા હો તો
તે વિશે એક સ્વતંત્ર પરિસંવાદ છે.

17
00:01:01,540 --> 00:01:05,590
પરંતુ ઉદ્દેશ સી મૂળભૂત છે
સી અર્થ એક superset

18
00:01:05,590 --> 00:01:10,230
તમે સી ઉપયોગ કે બધું કરી શકો
ઉદ્દેશ સી ભાષાંતર કરી

19
00:01:10,230 --> 00:01:11,630
ખૂબ જ સરળતાથી.

20
00:01:11,630 --> 00:01:15,730
>> તમે પછીથી, કે ખરેખર જોઈ શકો તરીકે
કેટલાક ખૂબ જ મૂળભૂત વાક્યરચના છે, ત્યાં

21
00:01:15,730 --> 00:01:19,790
મૂળભૂત રીતે બરાબર એ જ,
સી અને ઉદ્દેશ સી તેથી,

22
00:01:19,790 --> 00:01:22,860
તમે CS50 લીધો છે કારણ
આ અપ સુધી, તમે પહેલેથી

23
00:01:22,860 --> 00:01:26,500
ઓછામાં ઓછા 40% ઉદ્દેશ સી ખબર.

24
00:01:26,500 --> 00:01:30,720
પણ, એપલ એક ખરેખર છે
iOS માટે મજબૂત API.

25
00:01:30,720 --> 00:01:33,750
ખરેખર ક્રેઝી ઘણો હોય છે
વસ્તુઓ તમે તેની સાથે કરી શકો છો.

26
00:01:33,750 --> 00:01:36,760
જે પૈકી એક કોઈને છે
ખરેખર એક iOS એપ્લિકેશન બનાવવામાં

27
00:01:36,760 --> 00:01:40,600
નિયંત્રિત કાર, માટે જે
ખૂબ રસપ્રદ છે.

28
00:01:40,600 --> 00:01:42,610
કદાચ એક હેલિકોપ્ટર વધુ આકર્ષક છે.

29
00:01:42,610 --> 00:01:47,020
પરંતુ તે કેવી રીતે શક્તિશાળી છે
આ આઇઓએસ API હોઈ શકે છે.

30
00:01:47,020 --> 00:01:49,340
>> અને સાથે તમે હોઈ શકે છે
હમણાં બહાર figured,

31
00:01:49,340 --> 00:01:53,000
સ્ટેક ઓવરફ્લો કદાચ એક છે
સૌથી મહત્વપૂર્ણ ઓનલાઇન સ્ત્રોતો

32
00:01:53,000 --> 00:01:54,250
તમારા માટે ઉપલબ્ધ.

33
00:01:54,250 --> 00:01:58,090
અને સારા સમાચાર, માટે દરેક
તમે કદાચ કરી શકો છો એક સમસ્યા

34
00:01:58,090 --> 00:02:01,840
મકાન જ્યારે લાગે તમારી
ઉદ્દેશ સી અંતિમ પ્રોજેક્ટ,

35
00:02:01,840 --> 00:02:05,910
સ્ટેક ઓવરફ્લો જવાબ ભાગે છે.

36
00:02:05,910 --> 00:02:07,420
તે માત્ર અદ્ભુત છે.

37
00:02:07,420 --> 00:02:12,780
આ ઉપરાંત,
આઇઓએસ ખરેખર એક પ્લેટફોર્મ છે

38
00:02:12,780 --> 00:02:16,260
તમે એક વિશાળ પહોંચી શકે છે
થોડા પ્રયાસ સાથે પ્રેક્ષકો.

39
00:02:16,260 --> 00:02:20,170
તે એન્ડ્રોઇડ, જ્યાં જેમ નથી
બધું ખૂબ ફ્રેગમેન્ટ.

40
00:02:20,170 --> 00:02:22,540
>> બધું iOS એકીકૃત છે.

41
00:02:22,540 --> 00:02:25,920
અને જ્યાં સુધી તમે બનાવવા તરીકે
એક આઇફોન માટે એક એપ્લિકેશન,

42
00:02:25,920 --> 00:02:31,260
તમે કરી શકો છો ખૂબ જ સરળતાથી પોર્ટ આઇપેડ માટે કે,
આઇપેડ મિની, અથવા વિવિધ આઇફોન માપો.

43
00:02:31,260 --> 00:02:33,050
આ બધા ખરેખર અનુકૂળ છે.

44
00:02:33,050 --> 00:02:36,430
અને તે માત્ર ખરેખર સારી છે
તમારા મિત્રો છાપ માટે.

45
00:02:36,430 --> 00:02:38,920
તમે માત્ર એક આઇફોન સમાવી શકે છે
અને, હેય તમારા મિત્ર કહો

46
00:02:38,920 --> 00:02:40,250
આ હું કરી એપ્લિકેશન છે.

47
00:02:40,250 --> 00:02:43,860
જો તમે કોઇ માટે આ કરી શકો
જે સરસ છે ડેસ્કટોપ એપ્લિકેશન્સ,.

48
00:02:43,860 --> 00:02:48,870
>> બધા હક, હવે ચાલો ખરેખર વિચાર કરીએ
જો આ ભાષા ઉદ્દેશ સી માં

49
00:02:48,870 --> 00:02:52,910
તેથી શા માટે આપણે સાથે શરૂ નથી
કેટલાક ખરેખર મૂળભૂત વાક્યરચના.

50
00:02:52,910 --> 00:02:57,410
હું ઉદ્દેશ પહેલાં ઉલ્લેખ કર્યો છે
સી તે સી ના મૂળભૂત superset છે

51
00:02:57,410 --> 00:03:01,860
જેથી મૂળભૂત વાક્યરચના ઘણો છે
વાસ્તવમાં બરાબર એ જ.

52
00:03:01,860 --> 00:03:06,150
એક ચલ જાહેર અને
બે ચલો મળીને ઉમેરી રહ્યા

53
00:03:06,150 --> 00:03:09,440
અમે મારિયો કરવામાં આવ્યા તરીકે બરાબર છે.

54
00:03:09,440 --> 00:03:11,140
અહીં નવું કંઈ.

55
00:03:11,140 --> 00:03:17,370
>> લૂપ માટે એ જ રીતે, lodger
અને શરત કે જે સમાન છે.

56
00:03:17,370 --> 00:03:22,370
શું તમે ખરેખર તરીકે માત્ર લૂપ માટે શું કરી શકો છો
એક મારિયો [અશ્રાવ્ય] માં કર્યું છે.

57
00:03:22,370 --> 00:03:26,280
અને તમે શરતો શું કરી શકો છો
જેમ તમે શું

58
00:03:26,280 --> 00:03:29,240
તમારા પહેલાંના પૃ સેટમાં કરી દેવામાં આવી છે.

59
00:03:29,240 --> 00:03:33,400
જો કે, ઉદ્દેશ સી
, સી સંપૂર્ણપણે નથી

60
00:03:33,400 --> 00:03:36,640
અને કંઈક છે કે ત્યાં
વિચિત્ર પ્રકારની તે વિશે છે.

61
00:03:36,640 --> 00:03:42,340
>> પ્રથમ એક છે તમે છો જ્યારે કે
સી પ્રોગ્રામિંગ કરી, તમે સામાન્ય રીતે કૉલ

62
00:03:42,340 --> 00:03:46,310
સમાવેશ થાય છે અને પછી એક લાઈબ્રેરી નામ.

63
00:03:46,310 --> 00:03:49,860
પરંતુ ઉદ્દેશ સી તમે તે આયાત પર ફોન કરો.

64
00:03:49,860 --> 00:03:53,100
મૂળભૂત રીતે, કાર્યક્ષમતા કહેતા
માત્ર અલગ નામો.

65
00:03:53,100 --> 00:03:55,940
અને શબ્દમાળાઓ છે
વાસ્તવમાં થોડો વિચિત્ર.

66
00:03:55,940 --> 00:03:58,250
જો તમે પ્રથમ જોઈ શકો છો કે
વિચિત્ર પ્રકારની છે કે બાબત

67
00:03:58,250 --> 00:04:04,190
તમે એક સુંદર વિચિત્ર હોય છે
માફ કરશો તમે એક સુંદર વિચિત્ર એનએસ હોય

68
00:04:04,190 --> 00:04:04,960
અહીં પર સાઇન ઇન કરો.

69
00:04:04,960 --> 00:04:07,452

70
00:04:07,452 --> 00:04:09,160
અને બીજા વસ્તુ
કે વિચિત્ર પ્રકારની છે

71
00:04:09,160 --> 00:04:14,090
તમે પહેલાં સાઇન અંતે એક હોય થયેલ
વાસ્તવમાં શબ્દમાળા જાહેર.

72
00:04:14,090 --> 00:04:19,209
જેથી સાઇન અંતે મૂળભૂત નોંધે
શબ્દમાળા શબ્દમાળા માત્ર છે કે,

73
00:04:19,209 --> 00:04:20,880
તે ખરેખર એક પદાર્થ છે.

74
00:04:20,880 --> 00:04:22,780
અમે સમજાવવા રહ્યા છીએ
કે પછી તેથી ન કરતા

75
00:04:22,780 --> 00:04:25,800
દુઃખાવો તમે ન કરો તો
જે થાય તે સમજવા.

76
00:04:25,800 --> 00:04:29,980
અને કન્સોલ પર છાપકામ થોડુંક છે
વિવિધ કારણ અમે printf કૉલ સી,

77
00:04:29,980 --> 00:04:33,350
પરંતુ ઉદ્દેશ સી આપણે [અશ્રાવ્ય] પર ફોન કરો.

78
00:04:33,350 --> 00:04:35,640
>> તમે તે શું છે તે આશ્ચર્ય પામી રહ્યા હશો.

79
00:04:35,640 --> 00:04:38,070
કે, printf મૂળભૂત છે
માત્ર એક અલગ ભાષા.

80
00:04:38,070 --> 00:04:41,370
બરાબર એ જ વપરાશ,
બરાબર એ જ વિધેય.

81
00:04:41,370 --> 00:04:44,060
વેલ તે તારણ છે કે
ઉદ્દેશ સી વાસ્તવમાં

82
00:04:44,060 --> 00:04:50,040
એક એનએસ લગભગ માં પૂર્વગ છે
બધું, દરેક મૂળભૂત માહિતી પ્રકાર,

83
00:04:50,040 --> 00:04:52,690
NSDictionary, NSArray, NSString.

84
00:04:52,690 --> 00:04:56,340
આ કારણ છે એનએસ કે આવી
ખરેખર આગળ પગલું માટે વપરાય છે,

85
00:04:56,340 --> 00:04:59,980
જે એક કંપની છે કે
સ્ટીવ જોબ્સ, સ્થાપના કરી છે

86
00:04:59,980 --> 00:05:03,960
એક કંપની જે છે જ્યાં
ભાષા ઉદ્દેશ સી જન્મ થયો છે.

87
00:05:03,960 --> 00:05:06,140
તેથી આ મૂળભૂત પરંપરા છે.

88
00:05:06,140 --> 00:05:09,010
હું તેને થોડો ખબર
વિચિત્ર, પરંતુ તે એપલ છે.

89
00:05:09,010 --> 00:05:16,840
>> પણ weirder છે કે જેથી કંઈક
તે કરતાં એક કાર્ય જાહેરાત છે.

90
00:05:16,840 --> 00:05:22,600
આ અમે શું ઘણું અલગ છે
, સી જોવા અહીં તે ખરેખર કારણ

91
00:05:22,600 --> 00:05:25,190
હવે સી જેવું લાગતું નથી.

92
00:05:25,190 --> 00:05:28,810
તમે દ્વારા અહીં છે તે
આ એક બુલેટ બિંદુ નથી રસ્તો,

93
00:05:28,810 --> 00:05:30,690
આ એક બાદ નિશાની છે.

94
00:05:30,690 --> 00:05:36,440
જો તમે બાદ ચિહ્ન ફકરા હોય
રદબાતલ અને પછી વિધેય નામ.

95
00:05:36,440 --> 00:05:38,450
ચાલો માત્ર જો કહો કે અમે
પછી, હેલો વર્લ્ડ હોય

96
00:05:38,450 --> 00:05:42,820
પરત પ્રકાર રદબાતલ હશે
અમે કશું પરત કારણ કે.

97
00:05:42,820 --> 00:05:44,680
>> શું ખરેખર અદ્ભુત નહીં
તમે છો જ્યારે તે છે

98
00:05:44,680 --> 00:05:49,580
એક કરતાં વધુ પરિમાણ ધરાવતા
એક જ કાર્ય માં પસાર કે

99
00:05:49,580 --> 00:05:53,870
અહીં બતાવ્યા પ્રમાણે ખરેખર અદ્ભુત હશે.

100
00:05:53,870 --> 00:05:58,230
અમે એક પદ્ધતિ નામ છે,
માટે કહેવાય addInt [અશ્રાવ્ય]

101
00:05:58,230 --> 00:06:00,370
અને અમે એક પરિમાણ પસાર કરી રહ્યાં.

102
00:06:00,370 --> 00:06:05,170
પરંતુ તે પછી, અમે હોય
સાથે વધુ પદ્ધતિ નામ કોલ.

103
00:06:05,170 --> 00:06:08,500
અને સાથે પછી અમે પસાર કરી રહ્યાં
બીજા પરિમાણ.

104
00:06:08,500 --> 00:06:11,940
આ ખરેખર થોડુંક વિચિત્ર છે
પરંતુ આ તમામ કાર્ય જાહેરાતો

105
00:06:11,940 --> 00:06:14,770
આ તરીકે જ પેટર્ન અનુસરે છે.

106
00:06:14,770 --> 00:06:17,450
>> અમે સાથે શરૂ કરવા માટે એક બાદ ચિહ્ન હોય છે.

107
00:06:17,450 --> 00:06:21,550
આ બાદ ચિહ્ન એક વત્તા સાઇન હોઈ શકે
ક્યારેક પદ્ધતિ કેવા પ્રકારના પર આધારિત

108
00:06:21,550 --> 00:06:22,340
તે છે.

109
00:06:22,340 --> 00:06:25,000
પદ્ધતિ મૂળભૂત છે
કાર્ય માટે બીજું નામ.

110
00:06:25,000 --> 00:06:26,760
અને અમે રહ્યા છીએ
સમજાવો કે પછી જ્યારે

111
00:06:26,760 --> 00:06:30,580
અમે પદાર્થ વિશે વાત કરી રહ્યા છીએ
લક્ષી પ્રોગ્રામિંગ.

112
00:06:30,580 --> 00:06:34,300
તમે પ્રથમ પરત સ્પષ્ટ
અંદર કૌંસ લખો

113
00:06:34,300 --> 00:06:37,450
જે પછી પદ્ધતિ નામ આવે છે.

114
00:06:37,450 --> 00:06:40,310
તમે એક પરિમાણ પસાર કરી રહ્યાં.

115
00:06:40,310 --> 00:06:44,750
અને તમે વધુ પરિમાણો હોય તો
તમે પદ્ધતિ નામ વિસ્તારવા માટે જરૂર

116
00:06:44,750 --> 00:06:46,770
અને મૂળભૂત વધુ અહીં કંઈક લખો.

117
00:06:46,770 --> 00:06:48,090
>> તે તમે કરવા માંગો છો કંઈપણ હોઈ શકે છે.

118
00:06:48,090 --> 00:06:50,140
અમારા કિસ્સામાં તેની સાથે છે.

119
00:06:50,140 --> 00:06:56,160
પણ તમે કહી શકે અંતે, અથવા અથવા, અથવા
તમે ઇચ્છો ગમે abc સંપૂર્ણ બાર,.

120
00:06:56,160 --> 00:06:59,500
અને પછી તે પછી તમે છો
પરિમાણ બ પસાર.

121
00:06:59,500 --> 00:07:01,750
આ એક ખરેખર વિચિત્ર છે
સંમેલનમાં પરંતુ અમે છે

122
00:07:01,750 --> 00:07:05,800
એપલ ઇચ્છતા શા જોવા જઈ
ખૂબ જ ઝડપથી તે કરવા માટે.

123
00:07:05,800 --> 00:07:10,530
તેથી તમે કેવી રીતે કાર્ય કૉલ કરું?

124
00:07:10,530 --> 00:07:15,520
ઉદ્દેશ એક કાર્ય ફોન
સી પણ સી અલગ છે

125
00:07:15,520 --> 00:07:18,170
>> ખરેખર, ફોન એક
ઉદ્દેશ સી કાર્ય

126
00:07:18,170 --> 00:07:21,030
તમે કોઈને કરવાની વાત કરી રહ્યા છીએ, જેમ વધુ છે.

127
00:07:21,030 --> 00:07:27,030
અહીં અમે સ્વ, હોય છે જે
એક પદાર્થ કહેવાય છે.

128
00:07:27,030 --> 00:07:33,830
તમને મારાથી કહેવાની કરી રહ્યાં છો
કહેવું સ્વ વાંધો "હેલો વર્લ્ડ!"

129
00:07:33,830 --> 00:07:36,830
કે કાર્ય કૉલ કરવા માટે કેવી રીતે છે.

130
00:07:36,830 --> 00:07:41,690
એક પદાર્થ અને પદ્ધતિ નામ
એકબીજા સાથે જોડાઈ.

131
00:07:41,690 --> 00:07:49,600
અને આ છે જ્યાં વિચિત્ર એક્સટેન્સન છે
પદ્ધતિ નામ માટે ખરેખર નાટક આવે.

132
00:07:49,600 --> 00:07:52,150
>> માતાનો બીજો ઉદાહરણ જુઓ.

133
00:07:52,150 --> 00:07:56,780
અમે હમણાં જ કહેવાય પદ્ધતિ વ્યાખ્યાયિત
addInt સાથે મૂર્ખામી ભરેલી વાહિયાત વાત મૂર્ખામી ભરેલી વાહિયાત વાત મૂર્ખામી ભરેલી વાહિયાત વાત.

134
00:07:56,780 --> 00:08:00,066
તમે ફોન આવે ત્યારે આ કિસ્સામાં આવું
કે જે ચોક્કસ [? સંદેશ?] તે બનશે

135
00:08:00,066 --> 00:08:02,035
સ્વ addInt જેમ દેખાય છે: 10 સાથે: 2.

136
00:08:02,035 --> 00:08:05,410

137
00:08:05,410 --> 00:08:08,070
તે ઇંગલિશ જેવું વાગે છે.

138
00:08:08,070 --> 00:08:11,980
કાર્ય હોવા છતાં
કાર્ય જાહેરાત, વિચિત્ર છે

139
00:08:11,980 --> 00:08:15,600
ઉદ્દેશ સી માતાનો ના બિંદુ
પદ્ધતિ ઘોષણા પેટર્ન,

140
00:08:15,600 --> 00:08:18,830
તમે ફોન આવે ત્યારે તે છે
આ કાર્ય અથવા પદ્ધતિ

141
00:08:18,830 --> 00:08:21,980
તે વાસ્તવિક ઇંગલિશ જેમ અવાજ કરશે.

142
00:08:21,980 --> 00:08:25,270
તેથી તે ખૂબ જ સાહજિક છે
તમે તેને પ્રવેશ મેળવવા એક વાર.

143
00:08:25,270 --> 00:08:28,740
>> ખાસ કરીને આ કિસ્સામાં,
જ્યાં તમે મૂળભૂત કરી શકો

144
00:08:28,740 --> 00:08:33,010
કાર્ય નામ છે કે નહીં તે જોવા
સૉર્ટ પોતે દસ્તાવેજીકરણ.

145
00:08:33,010 --> 00:08:35,390
જો તમે કોઇ જરૂર નથી
વધુ સમજૂતી જોવા માટે

146
00:08:35,390 --> 00:08:42,770
બરાબર શું બની રહ્યું છે, શું
બરાબર એક પરિમાણ કરી.

147
00:08:42,770 --> 00:08:48,470
તે ઉપરાંત જવું, માતાનો થોડી વાત કરો
પદાર્થ કેન્દ્રિત પ્રોગ્રામિંગની વિશે બીટ.

148
00:08:48,470 --> 00:08:52,160
પદાર્થ કેન્દ્રિત પ્રોગ્રામિંગની છે
મૂળભૂત પ્રોગ્રામિંગ એક

149
00:08:52,160 --> 00:08:57,110
કે તકનીકો અથવા પેટર્ન
ઉદ્દેશ સી ઉદ્દેશ સી દ્વારા ઉપયોગ

150
00:08:57,110 --> 00:09:03,110
ઉદ્દેશ સી, ન કહેવામાં આવે
સી, ખરેખર સારા કારણ માટે.

151
00:09:03,110 --> 00:09:07,560
>> અમે પ્રવેશ મેળવવા પહેલાં જેથી
ઉદ્દેશ સી વાક્યરચના,

152
00:09:07,560 --> 00:09:11,670
માતાનો ખરેખર ઝડપથી જોવા દો
બરાબર શું એક પદાર્થ છે.

153
00:09:11,670 --> 00:09:15,480
અમે કદાચ કંઈક કર્યું
પહેલાં પદાર્થ જેવા કે જેના

154
00:09:15,480 --> 00:09:19,780
તમે છો જ્યારે સ્ટ્રક્ટ કહેવાય છે
એક વૃક્ષ અથવા સંકળાયેલી યાદી અમલીકરણ

155
00:09:19,780 --> 00:09:25,730
અથવા [? પ્રયાસ. ?] તેથી, તે છે
મૂળભૂત રીતે એક સ્ટ્રક્ટ જેવી,

156
00:09:25,730 --> 00:09:28,560
પરંતુ તે વધુ શક્તિશાળી કરતાં હોય છે.

157
00:09:28,560 --> 00:09:33,150
એક પદાર્થ પદ્ધતિઓ અને ગુણધર્મો ધરાવે છે.

158
00:09:33,150 --> 00:09:35,310
પદ્ધતિઓ મૂળભૂત વિધેયો છે.

159
00:09:35,310 --> 00:09:39,480
મૂળભૂત રીતે તે કાર્ય કરે
ચોક્કસ પદાર્થ માટે વિશિષ્ટ.

160
00:09:39,480 --> 00:09:45,440
>> અને ગુણધર્મો મારાથી છે
ક્ષેત્રમાં તમે સ્ટ્રક્ટ માં સ્પષ્ટ કરો.

161
00:09:45,440 --> 00:09:48,500
દરેક એક પદાર્થ માટે અત્યાર
અમે કેટલીક મિલકત છે

162
00:09:48,500 --> 00:09:53,160
કે કેટલાક ચલો છે, જે
પદાર્થ સંગત છે.

163
00:09:53,160 --> 00:09:57,170
અને અમે કેટલાક કાર્યો કરતા હોય છે કે જેના
પણ પદાર્થ સંગત છે.

164
00:09:57,170 --> 00:10:01,180
અને કાર્યો પદ્ધતિઓ કહેવામાં આવે
અને ચલો ગુણધર્મો કહેવામાં આવે છે.

165
00:10:01,180 --> 00:10:03,190
તે માત્ર એક ફેન્સી નામ છે.

166
00:10:03,190 --> 00:10:10,440
તમે હકીકતમાં, જ્યારે દરેક એક દૃશ્ય
તમે એક iOS એપ્લિકેશન ખોલવા જ્યારે તમે જુઓ છો

167
00:10:10,440 --> 00:10:17,720
, આપણે માત્ર પક્ષીએ ફેસબુક અથવા કહો
તમે જોઈ દરેક એક દૃશ્ય એક પદાર્થ છે.

168
00:10:17,720 --> 00:10:22,110
અને તે પણ સમગ્ર એપ્લિકેશન છે
એક પદાર્થ સાથે શરૂ કરવા માટે.

169
00:10:22,110 --> 00:10:25,340
અત્યંત રસપ્રદ ખ્યાલ.

170
00:10:25,340 --> 00:10:28,480
>> અને શા માટે આપણે પદાર્થ માંગો છો
પ્રોગ્રામિંગ લક્ષી?

171
00:10:28,480 --> 00:10:33,530
જેથી તમે કલ્પના કરી શકો છો જ્યારે તમે તે
કાર્યક્રમને તે સારુ જટીલ નહીં.

172
00:10:33,530 --> 00:10:36,400
ચાલો માત્ર તમે છો જ્યારે હવે કહો
ચેસબોર્ડ અમલીકરણ,

173
00:10:36,400 --> 00:10:40,020
તર્ક રહ્યું છે
ખરેખર જટીલ કરી.

174
00:10:40,020 --> 00:10:43,280
તમને 36 અલગ હોય
ટુકડાઓ, કે જેથી જો તમે

175
00:10:43,280 --> 00:10:48,370
બધા માટે તર્ક લખવા માંગો છો
ચેસ માં 36 અલગ ટુકડાઓ,

176
00:10:48,370 --> 00:10:52,150
કે ઘણો જ હશે
વિવિધ કાર્યો અને ચલો.

177
00:10:52,150 --> 00:10:54,070
તે મુશ્કેલી ઘણો છે.

178
00:10:54,070 --> 00:10:58,980
અને કદાચ તમે એક લખી રહ્યા છીએ
અલગ પદ્ધતિ અથવા અલગ કાર્ય

179
00:10:58,980 --> 00:11:03,950
માટે ભાગ દરેક માટે
બરાબર તેઓ શું નિયંત્રણ કરે છે.

180
00:11:03,950 --> 00:11:08,830
>> જો તમે કરો, તો પદાર્થ કેન્દ્રિત
પ્રોગ્રામિંગ, આ બધા ટુકડાઓ

181
00:11:08,830 --> 00:11:12,440
માં શૂન્યમનસ્ક કરી શકાય
એક જ પદાર્થ.

182
00:11:12,440 --> 00:11:16,111
અને પદાર્થ અમુક સામાન્ય હશે
ભાગ અને કેવા પ્રકારના જેવા ગુણધર્મો,

183
00:11:16,111 --> 00:11:16,610
તે છે?

184
00:11:16,610 --> 00:11:17,740
તે રંગ શું છે?

185
00:11:17,740 --> 00:11:19,480
તે કેવી ખસેડી શકો?

186
00:11:19,480 --> 00:11:24,660
અને તે રીતે તમે મોટા પ્રમાણમાં હોય
તે તર્ક સરળ.

187
00:11:24,660 --> 00:11:28,480
તેથી તે માત્ર એક ખરેખર સારો માર્ગ છે
જટિલ કાર્યક્રમો બનાવવા માટે,

188
00:11:28,480 --> 00:11:33,700
અને સ્તરીકરણ સંબંધો
આ કાર્યક્રમ અંદર, ખૂબ સરળ.

189
00:11:33,700 --> 00:11:36,800
અમે જોવા માટે જઈ રહ્યાં છો કારણ
શા ખૂબ જ ઝડપથી જ્યારે

190
00:11:36,800 --> 00:11:39,660
અમે ખરેખર કરી રહ્યા છીએ
અમે ખરેખર છો જ્યારે પ્રોગ્રામિંગ

191
00:11:39,660 --> 00:11:42,830
એક એસ કોડ કરવાનું
પાછળથી સત્ર પ્રોગ્રામિંગ.

192
00:11:42,830 --> 00:11:48,120
>> વેલ કે ઉપરાંત,
પદાર્થ કેન્દ્રિત પ્રોગ્રામિંગની

193
00:11:48,120 --> 00:11:50,030
મનોરંજન માત્ર ઘણો છે.

194
00:11:50,030 --> 00:11:51,990
તમે તમારા પોતાના પદાર્થ ડિઝાઇન કરવા મળી.

195
00:11:51,990 --> 00:11:56,080
તમને શું કરે ડિઝાઇન કરવા મળ્યું
તે જાતે દ્વારા જેવો.

196
00:11:56,080 --> 00:11:58,250
તે માટે કોઈ અધિકાર જવાબ નથી.

197
00:11:58,250 --> 00:12:02,940
અને તે તદ્દન રસપ્રદ છે.

198
00:12:02,940 --> 00:12:07,270
જેથી પદાર્થ કેન્દ્રિત પ્રોગ્રામિંગની માં,
બે મૂળભૂત ખ્યાલો

199
00:12:07,270 --> 00:12:10,130
વર્ગ અને હમણાં થઈ જશે.

200
00:12:10,130 --> 00:12:13,570
એક વર્ગ મૂળભૂત છે
પદાર્થ માટે એક નમૂનો.

201
00:12:13,570 --> 00:12:18,070
અને એક ઉદાહરણ મૂળભૂત છે
એક ચોક્કસ પદાર્થ.

202
00:12:18,070 --> 00:12:21,090
>> ચાલો માત્ર તમે એક કૂકી બનાવી રહ્યા છો કહે છે.

203
00:12:21,090 --> 00:12:24,800
આ કિસ્સામાં, દરેક એક
તમે ખરેખર સાથે અંત કૂકી

204
00:12:24,800 --> 00:12:27,310
એક પદાર્થ હોઈ ચાલે છે.

205
00:12:27,310 --> 00:12:35,830
પરંતુ કૂકી પ્લેટ તમે સાલે બ્રેઙ ઉપયોગ
તમામ કૂકીઝ એક વર્ગ હશે.

206
00:12:35,830 --> 00:12:37,880
એક વર્ગ મૂળભૂત નમૂનો છે.

207
00:12:37,880 --> 00:12:46,170
અને હમણાં એક ચોક્કસ હશે
પદાર્થ કે વર્ગ બહાર બનાવનાર.

208
00:12:46,170 --> 00:12:49,970
>> અને એક ઉદાહરણ બનાવાશે
વર્ગ ઘોષણા પર આધારિત,

209
00:12:49,970 --> 00:12:56,760
તરીકે અમે પાછળથી સ્લાઇડ્સ માં જોશો.

210
00:12:56,760 --> 00:13:00,010
તેથી આપણે ખરેખર ખરેખર એક કરવા દો
ઝડપી ઉદાહરણ [અશ્રાવ્ય].

211
00:13:00,010 --> 00:13:04,280
માતાનો અમે જાહેર કરી રહ્યાં છો હવે કહો
એક બિલાડી માટે એક ઑબ્જેક્ટ.

212
00:13:04,280 --> 00:13:07,930
પદાર્થ પાસે જોઈએ
બિલાડી વર્ગ જોઇએ

213
00:13:07,930 --> 00:13:11,260
કેટલાક ગુણધર્મો અને પદ્ધતિઓ હોય છે.

214
00:13:11,260 --> 00:13:17,300
ગુણધર્મો જોઈએ અને કેવા પ્રકારના
વર્ગ પાસે બિલાડી હોવી જોઇએ?

215
00:13:17,300 --> 00:13:20,580
>> જેમ કે, રંગ,
ઉંમર અને જાતિ, તે

216
00:13:20,580 --> 00:13:24,440
ચલો હશે કે
દરેક બિલાડી સંગત છે.

217
00:13:24,440 --> 00:13:27,790
અને તે કેટલીક વસ્તુઓ છે
અમે એક બિલાડી વર્ણન કરવા ઉપયોગ કરે છે.

218
00:13:27,790 --> 00:13:31,880
પદ્ધતિ અને કેવા પ્રકારના,
અથવા એક બિલાડી શું કરી શકો?

219
00:13:31,880 --> 00:13:37,160
કેટલાક ઝડપી ઉદાહરણો પીછો હશે
માઉસ, માછલી ખાય છે અથવા ફક્ત મેઓવ.

220
00:13:37,160 --> 00:13:40,900
આ એક ખરેખર ઝડપી છે
બિલાડી વર્ગના દાખલા.

221
00:13:40,900 --> 00:13:46,920
અને ખરેખર ચોક્કસ
બિલાડી પદાર્થ એક બિલાડી હશે

222
00:13:46,920 --> 00:13:50,930
આપણે સ્પષ્ટ જ્યાં
રંગ, આ ઉંમર અને જાતિ.

223
00:13:50,930 --> 00:13:53,790
>> તે કિસ્સામાં, અમારા પદાર્થ છે
લાંબા સમય સુધી એક વર્ગ હવે.

224
00:13:53,790 --> 00:14:00,010
અમે વર્ગ ના નમૂના નકલ કરો અને
અમે દરેક ચોક્કસ જાણકારી સ્પષ્ટ

225
00:14:00,010 --> 00:14:04,510
કે જે ચોક્કસ પદાર્થ માટે
તે સ્વતંત્ર બનાવવા માટે.

226
00:14:04,510 --> 00:14:09,350
અને તમે ફોન આવે ત્યારે
એક પદાર્થ અંદર એક પદ્ધતિ,

227
00:14:09,350 --> 00:14:16,640
તમે માત્ર, ઓબ્જેક્ટ પર મેઓવ કૉલ
જે તમે હમણાં બનાવેલ બિલાડી છે.

228
00:14:16,640 --> 00:14:19,020
>> કદાચ તમને છાપશે
"હેલો વર્લ્ડ કંઈક!

229
00:14:19,020 --> 00:14:20,000
મેઓવ. "

230
00:14:20,000 --> 00:14:22,110
ખૂબ સુંદર.

231
00:14:22,110 --> 00:14:24,500
બધા હક, ચાલો માત્ર દો
કેટલીક વિગતો પ્રવેશ મેળવવા

232
00:14:24,500 --> 00:14:30,650
અને બરાબર તે શું કરે છે તે જોવા
iOS પ્રોગ્રામિંગ કરવામાં અનુવાદ.

233
00:14:30,650 --> 00:14:36,500
આઇઓએસ દરેક એક પ્રોગ્રામિંગ જેથી માં
વર્ગ બે ફાઈલો અમલમાં આવશે.

234
00:14:36,500 --> 00:14:41,420
એક ફાઈલ અહીં છે, જે
આ ઈન્ટરફેસ કહેવામાં આવે છે.

235
00:14:41,420 --> 00:14:45,300
બીજી ફાઇલ, અહીં છે, કે જે
અમલીકરણ કહેવામાં આવે છે.

236
00:14:45,300 --> 00:14:48,890
>> સામાન્ય રીતે ઈન્ટરફેસ
extension.h હશે

237
00:14:48,890 --> 00:14:51,740
અમે સી લાઈબ્રેરીઓમાં જોઈ હોય તરીકે.

238
00:14:51,740 --> 00:14:56,340
અને અમલીકરણ ફાઇલ છે
extension.n છે જવું.

239
00:14:56,340 --> 00:14:57,260
તે વિચિત્ર પ્રકારની છે.

240
00:14:57,260 --> 00:15:01,270
પરંતુ ત્યાં કોઈ છે, સી ખરેખર એન અર્થ એ
તે વચ્ચે મૂળભૂત તફાવત

241
00:15:01,270 --> 00:15:02,100
બે.

242
00:15:02,100 --> 00:15:06,650
તેથી આ કિસ્સામાં, અમે અમે છો જોઈ શકો છો કે
ઑબ્જેક્ટ: ઇન્ટરફેસ, કેટ જાહેર.

243
00:15:06,650 --> 00:15:10,660

244
00:15:10,660 --> 00:15:13,760
કે વારસો કહેવાય છે.

245
00:15:13,760 --> 00:15:19,170
અમે મૂળભૂત રીતે વારસામાં રહ્યા છો
પદાર્થ વર્ગ માંથી બિલાડી વર્ગ.

246
00:15:19,170 --> 00:15:24,790
જેથી દરેક મિલકત અને પદ્ધતિ હતી કે
અગાઉ પદાર્થ વર્ગ વ્યાખ્યાયિત

247
00:15:24,790 --> 00:15:28,560
આપમેળે વ્યાખ્યાયિત કરવામાં આવશે
એક બિલાડી વર્ગ સાથે સાથે.

248
00:15:28,560 --> 00:15:35,900
>> આ ઉપરાંત, અમે રંગ વ્યાખ્યાયિત,
જાતિ, અને વય, ત્રણ ચલો.

249
00:15:35,900 --> 00:15:39,360
કે ખરેખર જેવું દેખાય
તમે પહેલાં કર્યું છે કંઈક.

250
00:15:39,360 --> 00:15:41,770
તે સ્ટ્રક્ટ જેવો દેખાય છે.

251
00:15:41,770 --> 00:15:44,950
જે સામાન્ય વાક્યરચના છે
સ્ટ્રક્ટ જાહેરાત માટે,

252
00:15:44,950 --> 00:15:47,710
અને તે તદ્દન સાચી છે.

253
00:15:47,710 --> 00:15:51,825
અને હું પહેલા ઉલ્લેખ થી,
તફાવત એક સ્ટ્રક્ટ

254
00:15:51,825 --> 00:15:53,960
અને એક પદાર્થ છે, જે એક
મૂળભૂત તફાવતો

255
00:15:53,960 --> 00:15:59,080
, એક પદાર્થ પદ્ધતિ ધરાવે છે
જ્યારે એક સ્ટ્રક્ટ જ ચલો છે.

256
00:15:59,080 --> 00:16:03,450
તેથી ગુણધર્મો ઉપરાંત અથવા
અમે પદાર્થ માટે બનાવી છે ચલો,

257
00:16:03,450 --> 00:16:05,700
અમે કેટલીક પદ્ધતિ સ્પષ્ટ કરો.

258
00:16:05,700 --> 00:16:09,720
>> ચાલો માત્ર અમારી પાસે અહીં હવે કહો
એક મેઓવ છે બે પદ્ધતિઓ,

259
00:16:09,720 --> 00:16:12,460
અન્ય એક પીછો માઉસ છે.

260
00:16:12,460 --> 00:16:18,600
અમે કદાચ એક પસાર કરવા માંગતા હો
અમારા અગાઉના પદ્ધતિ પર આધારિત પરિમાણ

261
00:16:18,600 --> 00:16:20,440
જાહેરાત પેટર્ન.

262
00:16:20,440 --> 00:16:22,160
તમે કદાચ માઉસ પસાર થવું હોય.

263
00:16:22,160 --> 00:16:25,180
અને તમે કદાચ છો પડશે
એક bool બતાવે પરત કરવા

264
00:16:25,180 --> 00:16:30,010
તમારા બિલાડી સફળતાપૂર્વક હોય તો
માઉસ કેચ નથી અથવા.

265
00:16:30,010 --> 00:16:33,170
>> આ ઈન્ટરફેસ છે, પરંતુ અમે આ કરી શકો
જુઓ કે વાસ્તવમાં ઈન્ટરફેસ

266
00:16:33,170 --> 00:16:35,150
કંઈપણ કરતું નથી.

267
00:16:35,150 --> 00:16:40,800
તે માત્ર એક કાર્યક્રમ કહે અસ્તિત્વમાં છે તે
શું બિલાડી વર્ગ અસ્તિત્વમાં છે.

268
00:16:40,800 --> 00:16:43,640
જેથી માટે ક્રમમાં
કાર્યક્રમને કંઈક કરવા,

269
00:16:43,640 --> 00:16:46,680
અમે અમલીકરણ ફાઇલો હોવું જરૂરી છે.

270
00:16:46,680 --> 00:16:51,940
અહીં, આપણે શું પ્રથમ વસ્તુ છે
દેખીતી આપણે ઈન્ટરફેસ આયાત કરો.

271
00:16:51,940 --> 00:16:56,470
આપણે ઈન્ટરફેસ આયાત કર્યા પછી,
અમે પદ્ધતિ વ્યાખ્યાયિત કરે છે.

272
00:16:56,470 --> 00:17:00,150
>> ચાલો માત્ર અહીં મેઓવ હવે કહો
માત્ર છાપે કરશે

273
00:17:00,150 --> 00:17:01,740
"હેલો વર્લ્ડ!" કન્સોલ પર.

274
00:17:01,740 --> 00:17:04,319

275
00:17:04,319 --> 00:17:08,460
અને અમલીકરણ બાદ
ફાઇલ, અમે ખૂબ ખૂબ પૂર્ણ કરી.

276
00:17:08,460 --> 00:17:14,530
આ મૂળભૂત એક વર્ગ છે
એક વર્ગ માટે જાહેરાત.

277
00:17:14,530 --> 00:17:19,970
તેથી હવે પ્રશ્ન, બને
તમે કેવી રીતે એક ચલ જાહેર કરી શકું?

278
00:17:19,970 --> 00:17:26,880
જે રીતે તમે એક બનાવવા માટે એક વર્ગ ઉપયોગ
ઉદ્દેશ સી પદાર્થ અહીં લખાયેલ છે.

279
00:17:26,880 --> 00:17:30,730
>> તમારે પ્રથમ તે સ્પષ્ટ
આ, એક બિલાડી નિર્દેશક છે

280
00:17:30,730 --> 00:17:38,700
ઉદ્દેશ સી દરેક પદાર્થ કારણ
છેલ્લે એક નિર્દેશક તરીકે લાગુ પાડવામાં આવે છે.

281
00:17:38,700 --> 00:17:46,210
અને તમે વર્ગ કહી, તેમને ફોન
મૂળભૂત રીતે malloc છે, જે alloc, કારણ,

282
00:17:46,210 --> 00:17:51,220
ઓપરેટિંગ સિસ્ટમ કહેવાની કે તમે
આ પદાર્થ માટે અમુક મેમરી જગ્યાની જરૂર.

283
00:17:51,220 --> 00:17:55,780
કે પછી તમે એક પદાર્થ હોય
પહેલેથી અને તમે માત્ર તેને પ્રારંભ.

284
00:17:55,780 --> 00:17:56,780
આ માત્ર સંમેલનમાં છે.

285
00:17:56,780 --> 00:17:59,390

286
00:17:59,390 --> 00:18:04,410
હું થોડો વિચિત્ર છે તે છે ખબર છે, પરંતુ
આ એપલ સામગ્રી કરે છે વાસ્તવમાં કેવી રીતે છે.

287
00:18:04,410 --> 00:18:07,130
>> ગુણધર્મો થયેલ સોંપણી
વાસ્તવમાં ખૂબ સરળ.

288
00:18:07,130 --> 00:18:09,250
તે ખૂબ સમાન છે
તમે ત્યારે શું કરી રહ્યા છીએ

289
00:18:09,250 --> 00:18:13,780
તમે અમુક ચોક્કસ સોંપણી કરી રહ્યાં
સ્ટ્રક્ટ ની અંદર ક્ષેત્ર.

290
00:18:13,780 --> 00:18:16,830
તમે માત્ર ચલ હોય
, આ મિલકત નામ નામ આપો,

291
00:18:16,830 --> 00:18:20,140
અને તે માટે એક ચોક્કસ કિંમત સોંપી.

292
00:18:20,140 --> 00:18:24,120
અને એક પદ્ધતિ કૉલ ખૂબ સમાન છે.

293
00:18:24,120 --> 00:18:29,080
આ ફોન એક પદ્ધતિ છે
મૂળભૂત રીતે હું વિશે વાત શું

294
00:18:29,080 --> 00:18:32,390
ઉદ્દેશ સી માં કોઇ પદ્ધતિ બોલાવવા માટે

295
00:18:32,390 --> 00:18:36,660
>> તમે સાઇન, એક પદાર્થ પસાર કરી રહ્યાં
આ કિસ્સામાં તે, myCat જ હશે

296
00:18:36,660 --> 00:18:42,490
અને તમે પદ્ધતિ નામ પસાર કરી રહ્યાં.

297
00:18:42,490 --> 00:18:47,130
તમે પદાર્થ સાથે વાત કરી રહ્યાં છો તેમ,
તમે મેઓવ જોઈએ કે myCat,.

298
00:18:47,130 --> 00:18:48,570
તે સારુ રસપ્રદ છે.

299
00:18:48,570 --> 00:18:52,010

300
00:18:52,010 --> 00:18:55,680
કે પછી, એક છે
વધુ જરૂરી ડિઝાઇન પેટર્ન

301
00:18:55,680 --> 00:18:59,940
અમે વિશે વાત કરવા જેવી
વાસ્તવિક એસ કોડ માટે મેળવવામાં પહેલાં.

302
00:18:59,940 --> 00:19:03,300
કે ડિઝાઇન પેટર્ન કહેવામાં આવે
ઘટના પ્રોગ્રામિંગ ચલાવાય.

303
00:19:03,300 --> 00:19:09,660
આ પણ સૌથી કદાચ એક છે
iOS પ્રોગ્રામિંગ માં મૂળભૂત વિચારો.

304
00:19:09,660 --> 00:19:14,410
>> તેથી તમે કદાચ બરાબર શું ખબર નથી
આ ઘટના આધારિત પ્રોગ્રામિંગ, છે

305
00:19:14,410 --> 00:19:16,990
પરંતુ તે ખરેખર છે કે ડરામણી નથી.

306
00:19:16,990 --> 00:19:20,400
સાથે સાથે વાસ્તવમાં, તમારી પાસે
પહેલાથી જ તે પહેલાં કરવામાં.

307
00:19:20,400 --> 00:19:24,894
આ તમને કદાચ કર્યું લીટીઓ એક છે
પહેલેથી જો છેલ્લા [અશ્રાવ્ય] લખવામાં

308
00:19:24,894 --> 00:19:26,810
CS50 ના,
google.maps.event.addListener (માર્કર,

309
00:19:26,810 --> 00:19:27,810
)} {), કાર્ય ("ક્લિક કરો" :.

310
00:19:27,810 --> 00:19:32,410

311
00:19:32,410 --> 00:19:37,620
તમે છે આ વાક્ય ફોન દ્વારા
અનિવાર્યપણે કમ્પ્યુટર કહેવાની

312
00:19:37,620 --> 00:19:42,650
ઘટના કહેવાય જ્યારે કે
, માર્કર પર થાય "ક્લિક કરો"

313
00:19:42,650 --> 00:19:43,630
તે કાર્ય વાપરો.

314
00:19:43,630 --> 00:19:46,910

315
00:19:46,910 --> 00:19:50,950
>> આ ખૂબ જ અલગ છે
તમે mario.c માં કરી શું.

316
00:19:50,950 --> 00:19:56,670
Mario.c માં તમે માત્ર કાર્યક્રમ ચલાવો
એક વખત, તે તમને એક આઉટપુટ આપે છે,

317
00:19:56,670 --> 00:19:58,590
અને તમે પૂર્ણ કરી રહ્યાં છો.

318
00:19:58,590 --> 00:20:02,590
આ પ્રકારના જેવા છે
એક શોટ કાર્યક્રમો.

319
00:20:02,590 --> 00:20:05,830
ઘટના આધારિત કાર્યક્રમો
ખૂબ, ખૂબ જ અલગ છે.

320
00:20:05,830 --> 00:20:10,230
ફેસબુક એક છે તો, ચાલો કલ્પના કરીએ
શોટ પ્રોગ્રામ તે ખરેખર સારું નથી.

321
00:20:10,230 --> 00:20:13,750
તમે માત્ર ફેસબુક પર જાઓ
એકવાર અને તે થાય છે.

322
00:20:13,750 --> 00:20:16,700
તે તમને કેટલાક આઉટપુટ આપે
અને તમે પાછા તે મળ્યું નથી.

323
00:20:16,700 --> 00:20:19,380
તમે વધુ કાંઇ મળી નથી.

324
00:20:19,380 --> 00:20:23,880
>> અહીં, ખાસ કરીને
અમે ઉપયોગ પેટર્ન છે

325
00:20:23,880 --> 00:20:26,940
ઘટના કે જેથી ચલાવાય
દરેક કાર્ય કરશે

326
00:20:26,940 --> 00:20:31,480
પર આધારિત ઝડપાઈ શું
ઇવેન્ટ થયું છે.

327
00:20:31,480 --> 00:20:34,670
ઉદાહરણ તરીકે, અમે હોય તો
એક બટન અને અમે સ્પષ્ટ કરી

328
00:20:34,670 --> 00:20:39,870
તે બટન ક્લિક થયેલ હોય ત્યારે કે,
કહેવાય કાર્ય કૉલ "હેલો વર્લ્ડ!"

329
00:20:39,870 --> 00:20:47,810
આ રીતે આપણે ખરેખર આ કરી શકો
કાર્ય તર્ક વ્યવસ્થા

330
00:20:47,810 --> 00:20:50,560
અત્યંત સાનુકૂળ રીતે પ્રવાહ.

331
00:20:50,560 --> 00:20:55,840
વપરાશકર્તાને કરી અથવા કાર્ય કહી શકો
કે પહેલેથી કહેવાય છે.

332
00:20:55,840 --> 00:20:59,900
તે સંપૂર્ણપણે વપરાશકર્તાઓ કરવું તેના પર આધારિત છે છે.

333
00:20:59,900 --> 00:21:04,080
>> તેથી અમે આ છે કે જે જોઈ શકે
mario.c કરતા ખરેખર ખૂબ સારી.

334
00:21:04,080 --> 00:21:07,190
અને સારા સમાચાર તે છે કે છે
ખરેખર નથી એક નવી વિભાવના.

335
00:21:07,190 --> 00:21:12,140
તમે ગાય્ઝ પહેલાથી જ આ કરી
કે છેલ્લા સમસ્યા માં સુયોજિત કરો.

336
00:21:12,140 --> 00:21:16,640
તેથી ઉદ્દેશ સી હોય છે
ત્રણ અલગ અલગ આકૃતિઓ

337
00:21:16,640 --> 00:21:19,030
ઘટના આધારિત પ્રોગ્રામિંગ માટે.

338
00:21:19,030 --> 00:21:21,970
પ્રથમ રેખાકૃતિ છે
લક્ષ્ય ક્રિયા કહેવાય,

339
00:21:21,970 --> 00:21:26,990
જ્યાં તમે બટનને બાંધવા
અમુક કાર્ય સાથે દબાવો.

340
00:21:26,990 --> 00:21:31,590
તમે ક્લિક ત્યારે આપણે માત્ર, હવે કહો
કેટલાક બટન, તમે અમુક કાર્ય કૉલ.

341
00:21:31,590 --> 00:21:33,620
આ ખૂબ જ સરળ લક્ષ્ય ક્રિયા છે.

342
00:21:33,620 --> 00:21:35,580
>> બીજા એક છે
ખરેખર ખૂબ સખત એક,

343
00:21:35,580 --> 00:21:38,450
તે પ્રોટોકોલ પર પ્રતિનિધિમંડળ કહેવાય છે.

344
00:21:38,450 --> 00:21:41,800
અમે સમજાવવા રહ્યા છીએ
મહાન વિગતવાર પાછળથી કે.

345
00:21:41,800 --> 00:21:44,420
અને ત્રીજા રીતે સૂચન છે.

346
00:21:44,420 --> 00:21:46,770
આ વાસ્તવમાં નથી
ખૂબ મહત્વનું સુધી

347
00:21:46,770 --> 00:21:50,920
અમે ચિંતિત રહ્યા છો, કારણ કે તક છે કારણ કે
તમે સૂચના વાપરી રહ્યા છીએ કે

348
00:21:50,920 --> 00:21:53,310
તમારી અંતિમ પ્રોજેક્ટ માં ખૂબ ઓછી છે.

349
00:21:53,310 --> 00:21:56,440
તેથી અમે તે ભાગ છોડી દો રહ્યા છીએ.

350
00:21:56,440 --> 00:21:59,460
>> અને અમે ડાઇવ રહ્યા છીએ
પ્રોટોકોલ પર પ્રતિનિધિમંડળ માં.

351
00:21:59,460 --> 00:22:02,380

352
00:22:02,380 --> 00:22:04,470
જેથી બરાબર એક પ્રોટોકોલ શું છે?

353
00:22:04,470 --> 00:22:06,450
અથવા એક પ્રતિનિધિમંડળ બરાબર શું છે?

354
00:22:06,450 --> 00:22:09,670
માતાનો સાથે શરૂ પ્રોટોકોલ વિશે વાત કરો.

355
00:22:09,670 --> 00:22:13,360
પ્રોટોકોલ ઘટનાઓ કશું પણ હોય છે.

356
00:22:13,360 --> 00:22:19,230
પરંતુ આ ઘટનાઓ માટે આપવામાં આવે છે
એપલ દ્વારા તમારી સાથે શરૂ કરવા માટે.

357
00:22:19,230 --> 00:22:22,640
જેમ કે, હું નથી
તમે કેટલા સંપૂર્ણપણે ખાતરી

358
00:22:22,640 --> 00:22:27,930
ગાય્ઝ એપલના મૂળ ઉપયોગ
એપ્લિકેશન મેલ અથવા સંપર્ક,

359
00:22:27,930 --> 00:22:32,180
પરંતુ દર વખતે તમે સ્ક્રોલ
ટેબલ અને ચોક્કસ કોષ દબાવો

360
00:22:32,180 --> 00:22:36,130
ટેબલ પર, કે જે ઘટના છે.

361
00:22:36,130 --> 00:22:38,330
>> અને તમે શું કરવા માંગો છો
તમારી જાતને દ્વારા તે ઘટના,

362
00:22:38,330 --> 00:22:40,410
તે ખરેખર એક થોડો મુશ્કેલ છે.

363
00:22:40,410 --> 00:22:44,880
તેથી એપલ પણ છે કે તમે આપવામાં આવી છે
તમે માત્ર સીધી ઉપયોગ કરી શકો છો કે જેથી

364
00:22:44,880 --> 00:22:49,610
ઘટના તમારા પોતાના પર કંઈક કરવું.

365
00:22:49,610 --> 00:22:52,980
પ્રોટોકોલ ખરેખર છે
ખરેખર, ખરેખર વ્યાપક ઉપયોગ

366
00:22:52,980 --> 00:22:58,320
માં ઉદ્દેશ સી વેલ માં
હકીકતમાં, દરેક એક એપ્લિકેશન

367
00:22:58,320 --> 00:23:00,870
કંઈક પડેલા એપ્લિકેશન પ્રતિનિધિ છે.

368
00:23:00,870 --> 00:23:06,330
નાજુક ની અંદર તમામ છે
એપ્લિકેશન લોડ કરવા માટે પ્રોટોકોલ.

369
00:23:06,330 --> 00:23:12,470
>> ચાલો માત્ર છે હવે કહો
એપ્લિકેશન માટે એક ઇવેન્ટ લોડ કર્યું.

370
00:23:12,470 --> 00:23:18,200
તમે કરેલા બાદ તેથી શું થાય કરીશું
એક એપ્લિકેશન બનાવનાર, તમે એપ્લિકેશન ખોલો બાદ,

371
00:23:18,200 --> 00:23:22,630
પછી તમે પછી એપ્લિકેશન બંધ, અથવા
તમે ઊંઘ આઇફોન મૂકો.

372
00:23:22,630 --> 00:23:27,480
આ છે કે જે બધી ઘટનાઓ છે
પહેલેથી જ તમારા માટે આપવામાં આવી.

373
00:23:27,480 --> 00:23:34,730
અને મૂળ આ કણો અંદર
કોઈ અમલીકરણ થશે.

374
00:23:34,730 --> 00:23:39,750
એપલ માત્ર આ કાર્ય કે તમે કહ્યું
કેટલાક ઘટના બને ત્યારે શું થશે,

375
00:23:39,750 --> 00:23:44,380
પરંતુ તમે તે સાથે શું શું
કાર્ય તમારા પર સંપૂર્ણપણે છે.

376
00:23:44,380 --> 00:23:49,290
>> પ્રતિનિધિમંડળ મૂળભૂત છે
વર્ગ કહેવાની

377
00:23:49,290 --> 00:23:53,060
તમે આ પ્રોટોકૉલ્સ હેન્ડલ જોઈએ કે.

378
00:23:53,060 --> 00:23:55,340
તે થોડો છે
ગૂંચવણમાં છે, પરંતુ તે જ થશે

379
00:23:55,340 --> 00:23:59,380
અમે શું છે જ્યારે ખૂબ સ્પષ્ટ
ક્રિયા માં ઓ કોડ.

380
00:23:59,380 --> 00:24:04,760
પ્રોટોકોલ પર પ્રતિનિધિમંડળ ખરેખર એક છે
અર્થમાં અત્યંત મજબૂત પદ્ધતિ

381
00:24:04,760 --> 00:24:08,160
કે અમે પ્રતિનિધિમંડળ કરો તો
ચોક્કસ વર્ગ માટે,

382
00:24:08,160 --> 00:24:12,400
અમે અનિવાર્યપણે સંભાળી શકે
ઘટનાઓ તમામ પ્રકારના

383
00:24:12,400 --> 00:24:17,040
અમે હોય કોઇપણ વર્ગ ઉપયોગ કરીને,
ખૂબ અનુકૂળ સાધન.

384
00:24:17,040 --> 00:24:21,530
>> તેથી એક ઝડપી ઉદાહરણ માટે
પ્રોટોકોલ પર પ્રતિનિધિમંડળ

385
00:24:21,530 --> 00:24:24,120
હું માત્ર વિશે વાત કરી છે તે જ થશે.

386
00:24:24,120 --> 00:24:26,720

387
00:24:26,720 --> 00:24:30,890
આ પ્રોટોકોલ ખાસ કહેવાય છે
tableview [અશ્રાવ્ય] ભૂમિકા પસંદ

388
00:24:30,890 --> 00:24:35,480
[અંતે? ઇન્ડેક્સ?] [? ભૂતકાળમાં. ?] તેથી આ એક
કેચ આવશે ઇવેન્ટ જ્યારે તમે

389
00:24:35,480 --> 00:24:39,710
ખરેખર એક ચોક્કસ પર ટેપ
તમારા tableview માં સેલ,

390
00:24:39,710 --> 00:24:43,570
ચાલો માત્ર તમારા મેલ માં કહેવું
અથવા તમારા સંપર્કો એપ્લિકેશનમાં.

391
00:24:43,570 --> 00:24:48,180
>> એક કાર્ય અંદર આવી હતી
મૂળ કંઇ કરી.

392
00:24:48,180 --> 00:24:51,950
કાર્ય ન કરે
મૂળભૂત રીતે કંઈ પણ કરવા.

393
00:24:51,950 --> 00:24:55,540
પણ તમે સ્પષ્ટ કરી શકો છો
કાર્ય શું કરે છે,

394
00:24:55,540 --> 00:24:59,610
તમે તમારી એપ્લિકેશન બહાર શું કરવા માંગો છો આપવામાં.

395
00:24:59,610 --> 00:25:01,610
ખૂબ અનુકૂળ સાધન.

396
00:25:01,610 --> 00:25:06,840
અને બધા સાથે કે
, હું મૂળભૂત કહ્યું રહી

397
00:25:06,840 --> 00:25:11,430
કેટલાક ખૂબ જ મૂળભૂત વાક્યરચના આવરી અને
ઉદ્દેશ સી માટે મૂળભૂત ખ્યાલ

398
00:25:11,430 --> 00:25:15,860
પ્રોગ્રામિંગ, અને અમે કેટલાક ઓ કોડ કરી શકો છો.

399
00:25:15,860 --> 00:25:17,980
વધુ ઉત્તેજક.

400
00:25:17,980 --> 00:25:21,070
તેથી ઓ કોડ ખરેખર એક છે
થોડુંક જબરજસ્ત

401
00:25:21,070 --> 00:25:23,330
તમે પ્રથમ વખત તેને ખોલવા ત્યારે.

402
00:25:23,330 --> 00:25:26,640
>> એક ઝડપી નોંધ, જેથી તમે તો
iOS વિકાસ કરવા માંગો છો,

403
00:25:26,640 --> 00:25:29,630
હું ખૂબ તમે મેક હોય ભલામણ કરીએ છીએ.

404
00:25:29,630 --> 00:25:33,930
પર iOS વિકાસ કરી કારણ
વિન્ડોઝ ખરેખર હાર્ડ, ખરેખર છે.

405
00:25:33,930 --> 00:25:37,560
તે doable છે, પરંતુ તે ખરેખર મુશ્કેલ છે.

406
00:25:37,560 --> 00:25:40,610
અને તમે ચોક્કસપણે કરવું
ત ફેરફાર વાપરવા માંગતા નથી.

407
00:25:40,610 --> 00:25:47,950
તેથી ઓ કોડમાં અમે હોય
કેટલાક વિવિધ વિસ્તારોમાં.

408
00:25:47,950 --> 00:25:53,050
તમે પ્રથમ ઓ ખોલો ત્યારે કોડ
જો તમે સંશોધન વિસ્તારમાં જોશે,

409
00:25:53,050 --> 00:25:57,470
જે મૂળભૂત રીતે તમે બધા બતાવે
તમારી વર્તમાન પ્રોજેક્ટમાં છે કે ફાઈલો.

410
00:25:57,470 --> 00:26:03,590
>> જો તમે ટૂલબાર વિસ્તાર, હોય છે જે
મૂળભૂત જોવાઈ વ્યવસ્થા છે,

411
00:26:03,590 --> 00:26:08,570
અથવા કેટલાક ઓછી ઝડપી
ઓ કોડ પોતે વિશે સાધનો.

412
00:26:08,570 --> 00:26:11,140
અને આ વાસ્તવિક સંપાદક વિસ્તાર છે.

413
00:26:11,140 --> 00:26:15,900
આ વિસ્તાર ખૂબ સમાન ત ફેરફાર છે,
ત ફેરફાર કરતા પણ વધુ સારી.

414
00:26:15,900 --> 00:26:21,150
અને આ અધિકાર વિસ્તારમાં, છે
ઉપયોગિતા વિસ્તારમાં કહેવાય.

415
00:26:21,150 --> 00:26:27,170
આ વિસ્તારમાં જ્યારે ખરેખર સરળ બની જાય
તમે ઈન્ટરફેસ બનાવવા અથવા સ્પષ્ટ કરી રહ્યા છીએ

416
00:26:27,170 --> 00:26:30,070
તમારી એપ્લિકેશન માટે કેટલાક ઝડપી સુયોજનો.

417
00:26:30,070 --> 00:26:34,570
>> અને અંતિમ વિસ્તાર ડિબગીંગ છે.

418
00:26:34,570 --> 00:26:37,970
આ વિસ્તારમાં કન્સોલ સમાવે છે.

419
00:26:37,970 --> 00:26:43,170
તેથી તમે printf કહે જ્યારેપણ,
અથવા અમારા કિસ્સામાં nslog

420
00:26:43,170 --> 00:26:47,330
તમારા બધા પરિણામો છે
જઈને અહીં છપાશે.

421
00:26:47,330 --> 00:26:48,260
બધા હક?

422
00:26:48,260 --> 00:26:52,090
હું અમે ખરેખર ઝડપથી કરી શકો ધારી
iOS પ્રોગ્રામિંગ માટે એક ઉદાહરણ.

423
00:26:52,090 --> 00:26:54,220
અને ચાલો ખરેખર અપ ઓ કોડ ખોલીએ.

424
00:26:54,220 --> 00:26:57,210

425
00:26:57,210 --> 00:27:01,346
તેથી તમે અપ ઓ કોડ ખોલવા દર વખતે, તે છે
તે કંઈક બતાવવા માટે જવાનું.

426
00:27:01,346 --> 00:27:03,220
તે તમને પૂછી બનશે
તમે શું કરવા માંગો છો?

427
00:27:03,220 --> 00:27:06,830
તમે કંઈક શરૂ કરવા માંગો છો
મૂળભૂત રીતે રેન્ડમ, એક રમતનું મેદાન, તમે

428
00:27:06,830 --> 00:27:11,250
ફક્ત વિના કોડ ચકાસી શકે
વાસ્તવમાં કોઈપણ એપ્લિકેશન માટે સંગ્રહવાથી.

429
00:27:11,250 --> 00:27:13,020
>> તમે એક નવો પ્રોજેક્ટ બનાવવા માંગો છો?

430
00:27:13,020 --> 00:27:16,660
અથવા શું તમે ચાલુ રાખવા માંગો છો
હાલના પ્રોજેક્ટ પર કામ?

431
00:27:16,660 --> 00:27:20,270
અમારા કિસ્સામાં અમે રહ્યા છીએ
એક નવો પ્રોજેક્ટ બનાવવા માટે.

432
00:27:20,270 --> 00:27:22,980
તેથી તે ખરેખર સરસ રહ્યું છે
કોડ વાસ્તવમાં પહેલેથી છે

433
00:27:22,980 --> 00:27:26,820
કેટલાક નમૂનાઓ તમે આપવામાં
વસ્તુઓ બનાવવા માટે.

434
00:27:26,820 --> 00:27:32,680
તમે રમત કરવા માંગો છો, કોડ ઓ
ખરેખર તમારા માટે એક રમત નમૂનો છે,

435
00:27:32,680 --> 00:27:36,890
, પાનું આધારિત કાર્યક્રમો છે
ટૅબ આધારિત કાર્યક્રમ.

436
00:27:36,890 --> 00:27:39,280
આ કિસ્સામાં, અમે રહ્યા છીએ
ખૂબ સરળ કંઈક કરવા,

437
00:27:39,280 --> 00:27:43,230
અને અમે એક ઉપયોગ જઈ રહ્યાં છો
એક દૃશ્ય અરજી.

438
00:27:43,230 --> 00:27:48,270
>> કે પછી માત્ર તમે કૉલ કરવા માંગો છો
તમારા ઉત્પાદન, અને, તમારું નામ શું છે

439
00:27:48,270 --> 00:27:52,760
શું તમારી ઓળખકર્તા છે, અને
તમે શું ભાષા વાપરવા માંગતા.

440
00:27:52,760 --> 00:27:57,060
અહીં અમે નથી માંગતા
કોર ડેટા ઉપયોગ કરીને તપાસો.

441
00:27:57,060 --> 00:28:00,170
કોર ડેટા મૂળભૂત databasing આઇઓએસ છે.

442
00:28:00,170 --> 00:28:05,360
તમે કોર ડેટા કરો તો, ઓ
કોડ વ્યાખ્યાયિત રહ્યું છે

443
00:28:05,360 --> 00:28:07,710
તમારા માટે ઘણો વધુ જટિલ વર્ગો.

444
00:28:07,710 --> 00:28:12,740
તેથી અમે છો, સરળ બધું રાખવા
ફક્ત કોર ડેટા વિના કરવા જઇ

445
00:28:12,740 --> 00:28:15,290
હમણાં.

446
00:28:15,290 --> 00:28:18,030
>> અમે પ્રયત્ન જઈ રહ્યાં છો સમસ્યા
નો ઉપયોગ કરીને આ સમસ્યા થાય કે છે

447
00:28:18,030 --> 00:28:23,770
અમે બનાવવા કરી રહ્યું છે જઈ રહ્યાં છો અમે તે
મૂળભૂત સી થી મારિયો આયાત કરવા માંગો છો

448
00:28:23,770 --> 00:28:25,437
એક iOS એપ્લિકેશન માટે.

449
00:28:25,437 --> 00:28:26,645
તેથી આપણે મારિયો-આઇઓએસ કે કૉલ કરો.

450
00:28:26,645 --> 00:28:31,230

451
00:28:31,230 --> 00:28:34,880
અલબત્ત તમે તમને તે સ્પષ્ટ કરેલ
તમારા પ્રોજેક્ટ માં મૂકવા માંગો છો.

452
00:28:34,880 --> 00:28:37,870
અને ત્યાં અમે જાઓ.

453
00:28:37,870 --> 00:28:41,390
>> તેથી આ થોડો છે
જબરજસ્ત છે, પરંતુ આ ખરેખર છે

454
00:28:41,390 --> 00:28:43,540
શું અમે ફક્ત સ્લાઇડ્સ પર જોવા મળી હતી.

455
00:28:43,540 --> 00:28:49,710
અને પ્રથમ વિસ્તારમાં અમે હમણાં જોવા
મૂળભૂત પ્રોજેક્ટ રૂપરેખાંકન છે.

456
00:28:49,710 --> 00:28:53,390
તેથી બધું તમે કરવા માંગો છો
પ્રોજેક્ટ, ઉપકરણ કયા પ્રકારની,

457
00:28:53,390 --> 00:28:58,810
ચાલો માત્ર કહે દો ઉપકરણ કયા પ્રકારની
તમે તમારી એપ્લિકેશન પર જોવા માંગો છો?

458
00:28:58,810 --> 00:29:01,280
તે આઇફોન, આઈપેડ અથવા સાર્વત્રિક છે?

459
00:29:01,280 --> 00:29:04,660
ઉપકરણ ઓરિએન્ટેશન, આ તમામ સામગ્રી જેથી.

460
00:29:04,660 --> 00:29:08,490
ખૂબ મહત્વનું નથી,
પરંતુ પ્રયત્ન છે, પરંતુ આ શક્યા

461
00:29:08,490 --> 00:29:11,050
તમે સુયોજિત છે તે સ્થળ છે
તમારા પ્રોજેક્ટ માટે તમે જો ખરેખર

462
00:29:11,050 --> 00:29:15,180
એપલ સ્ટોર પર જમાવવા માટે કરવા માંગો છો.

463
00:29:15,180 --> 00:29:20,420
>> બધા હક, ચાલો જોવા દો
અમારી કોડ અંદર છે કે જે કંઈક.

464
00:29:20,420 --> 00:29:22,360
ચાલો આ ફાઇલ નેવિગેટર મારફતે જાઓ.

465
00:29:22,360 --> 00:29:30,140
અને આ બધી ફાઇલોને કે પહેલેથી જ છે
ખૂબ જ સરસ નમૂનો, સાથે આવેલ.

466
00:29:30,140 --> 00:29:35,980
તેથી અમે એક તેમને ક્લિક કરો ત્યારે
આ તે શું લાગે છે.

467
00:29:35,980 --> 00:29:38,530
ત ફેરફાર કરો ખૂબ સમાન.

468
00:29:38,530 --> 00:29:41,340
પરંતુ તમે જોઈ શકો છો કે
સિન્ટેક્સ હાઇલાઇટિંગ કદાચ છે

469
00:29:41,340 --> 00:29:42,780
થોડુંક માટે NICER.

470
00:29:42,780 --> 00:29:45,610
અને તે ખરેખર ખૂબ વધુ છે
ત સંપાદન કરતા શક્તિશાળી.

471
00:29:45,610 --> 00:29:49,970
અને તમે સ્વતઃપૂર્ણ કરી શકો
તમારા માટે વસ્તુઓ ઘણો,

472
00:29:49,970 --> 00:29:52,370
અમે ખૂબ જ ઝડપથી જોશો તરીકે.

473
00:29:52,370 --> 00:29:54,100
>> માતાનો તેમજ ડિબગીંગ વિસ્તારમાં ખોલો.

474
00:29:54,100 --> 00:30:02,790

475
00:30:02,790 --> 00:30:07,000
બધા હક, અમે જોઈ શકો છો,
કન્સોલ અહીં છે.

476
00:30:07,000 --> 00:30:13,840
આ તમને જ્યાં જોવા જઈ રહ્યાં છે તે છે
તમે printf અથવા કંઈક nsloging છો.

477
00:30:13,840 --> 00:30:17,155
વધુ હેરાનગતિ વિના, તેથી, ખરેખર માતાનો દો
એપ્લિકેશન કમ્પાઇલ અને જુઓ શું થાય.

478
00:30:17,155 --> 00:30:20,000

479
00:30:20,000 --> 00:30:23,410
એક આવશ્યક લક્ષણ માટે
ઓ કોડ છે, કે ઓ કોડ છે

480
00:30:23,410 --> 00:30:25,850
એક આઇફોન સિમ્યુલેટર સાથે આવે છે.

481
00:30:25,850 --> 00:30:29,820
જેથી તમે એક હોય તે જરૂરી નથી
આઇફોન, તમારા પ્રોજેક્ટ પ્રયાસ કરવા

482
00:30:29,820 --> 00:30:34,440
ઓ કોડ માટે કે અનુકરણ કરી શકે છે
જો તમે તરીકે અમે હમણાં જોઈ શકો છો.

483
00:30:34,440 --> 00:30:36,406
>> તે સારુ સારું છે.

484
00:30:36,406 --> 00:30:38,640
તે થોડી લેતી છે
સમય બીટ કમ્પાઇલ

485
00:30:38,640 --> 00:30:43,040
અને મૂળભૂત અમે હોય
ખાલી એપ્લિકેશન,

486
00:30:43,040 --> 00:30:44,640
જે ખરેખર કંઈ કરતું નથી.

487
00:30:44,640 --> 00:30:46,175
પરંતુ તે કમ્પાઇલ.

488
00:30:46,175 --> 00:30:47,380
તે ખરેખર અદ્ભુત છે.

489
00:30:47,380 --> 00:30:50,200
તે ઓહ, સી કરતાં વધુ સારી છે?

490
00:30:50,200 --> 00:30:52,130
બધા હક છે, તો પછી ચાલો
કંઈક ઉમેરવા માટે પ્રયાસ કરો.

491
00:30:52,130 --> 00:30:56,050

492
00:30:56,050 --> 00:31:02,650
થોડુંક છે કે એક ફાઇલ
અહીં અલૌકિક સ્ટોરીબોર્ડ કહેવામાં આવે છે.

493
00:31:02,650 --> 00:31:08,020
આ ખરેખર એક મહાન છે
ઓ કોડ માટે ભયાનક લક્ષણ.

494
00:31:08,020 --> 00:31:14,170
કારણ ઓ કોડમાં, તમે ડ્રેગ ખરેખર આ કરી શકો
અને ઈન્ટરફેસ પર તત્વો છોડો

495
00:31:14,170 --> 00:31:17,430
અને તે સીધી બતાવવામાં આવશે.

496
00:31:17,430 --> 00:31:18,055
ચાલો કે પ્રયાસ કરીએ.

497
00:31:18,055 --> 00:31:21,230

498
00:31:21,230 --> 00:31:27,236
>> અમે અહીં "હેલો વર્લ્ડ !!!" લેબલ છોડો

499
00:31:27,236 --> 00:31:29,740
અમે તે કેન્દ્ર શકો છો.

500
00:31:29,740 --> 00:31:30,970
સરસ.

501
00:31:30,970 --> 00:31:33,915
હવે ચાલો આ સ્ટોપ સિમ્યુલેશન ચલાવો.

502
00:31:33,915 --> 00:31:36,940

503
00:31:36,940 --> 00:31:38,700
અહીં આપણે "હેલો વર્લ્ડ !!!" હોય

504
00:31:38,700 --> 00:31:40,810
અમે પણ હજુ સુધી કોઈપણ કોડિંગ ન કર્યું.

505
00:31:40,810 --> 00:31:42,750
હેક શું થઈ રહ્યું છે?

506
00:31:42,750 --> 00:31:45,880
આ કેવી રીતે શક્તિશાળી છે
ઈન્ટરફેસ બિલ્ડર બની શકે છે.

507
00:31:45,880 --> 00:31:48,030
કોઇની પણ કહ્યું હતું કે
તમે કરી શકો છો કદાચ માત્ર

508
00:31:48,030 --> 00:31:52,800
લેખન વગર એક એપ્લિકેશન પૂર્ણ
કોડના કદાચ એક હજાર રેખાઓ

509
00:31:52,800 --> 00:31:54,820
ફક્ત ઈન્ટરફેસ બિલ્ડર ઉપયોગ કરીને.

510
00:31:54,820 --> 00:31:59,680
પરંતુ તે કદાચ નથી
શ્રેષ્ઠ માર્ગ તે કરવા.

511
00:31:59,680 --> 00:32:01,670
>> હવે ચાલો ખરેખર કોડિંગ માટે નીચે વિચાર કરીએ.

512
00:32:01,670 --> 00:32:04,860

513
00:32:04,860 --> 00:32:08,330
ફાઇલ માટે બંધારણ જેથી
વાસ્તવમાં ખરેખર રસપ્રદ છે

514
00:32:08,330 --> 00:32:15,610
, કારણ કે તમે જોઈ શકો, કારણ કે ત્યાં
ગમે ત્યાં કોઈ મુખ્ય કાર્ય છે.

515
00:32:15,610 --> 00:32:17,466
જુઓ?

516
00:32:17,466 --> 00:32:19,340
અમે પહેલાં સૂચવાયેલ,
જો તમે આ જોઈ શકો છો કે

517
00:32:19,340 --> 00:32:22,830
એક અમલીકરણ ફાઇલ છે
ચોક્કસ વર્ગ માટે.

518
00:32:22,830 --> 00:32:25,690
પરંતુ કોઈ મુખ્ય ગમે ત્યાં નથી.

519
00:32:25,690 --> 00:32:27,490
તેથી જ્યાં મુખ્ય છે?

520
00:32:27,490 --> 00:32:31,970
ખરેખર, ત્યાં એક મુખ્ય છે, પરંતુ
મુખ્ય ખરેખર તમે માંથી છુપાયેલ છે.

521
00:32:31,970 --> 00:32:34,560
મુખ્ય અહીં છે.

522
00:32:34,560 --> 00:32:37,120
કે પરિચિત લાગે છે.

523
00:32:37,120 --> 00:32:41,000
>> જેથી મૂળભૂત શું iOS
મુખ્ય અંદર કરવાનું છે

524
00:32:41,000 --> 00:32:43,540
મુખ્ય છે જ્યારે તે છે
મૂળભૂત રીતે, કે જે કહેવાય

525
00:32:43,540 --> 00:32:49,000
આ એપ્લિકેશન, તે ચલાવવામાં આવે છે જ્યારે
AppDelegate કહેવાય પદાર્થ બનાવે છે.

526
00:32:49,000 --> 00:32:52,980

527
00:32:52,980 --> 00:32:57,350
હું પહેલાં સૂચવાયેલ, સમગ્ર
એપ્લિકેશન ખરેખર પોતાના દ્વારા એક પદાર્થ છે.

528
00:32:57,350 --> 00:33:02,270
મારાથી, આ રીતે અત્યાર
iOS એપ્લિકેશન કમ્પાઇલર કહેવાની છે

529
00:33:02,270 --> 00:33:05,540
કે બરાબર, હું બનાવવા જઈ રહી છું
AppDelegate કહેવાય ઉત્પાદન,

530
00:33:05,540 --> 00:33:07,620
અને તે મારા એપ્લિકેશન હોઈ ચાલે છે.

531
00:33:07,620 --> 00:33:09,640
તેથી તમે પણ જરૂર
કે AppDelegate દ્વારા

532
00:33:09,640 --> 00:33:12,040
અને તે વ્યક્તિ કરી રહ્યો છે તે જોવા.

533
00:33:12,040 --> 00:33:14,850
મારી નોકરી મારા માટે કરવામાં આવે છે.

534
00:33:14,850 --> 00:33:22,070
>> અને AppDelegate માં તમે તે જોઈ શકો છો
કેટલાક ખરેખર અલૌકિક કાર્યો છે,

535
00:33:22,070 --> 00:33:25,290
સાથે સાથે વાસ્તવમાં પદ્ધતિઓ, કે
એપલ પહેલેથી જ તમારા આપ્યો છે.

536
00:33:25,290 --> 00:33:27,464
આ શું છે?

537
00:33:27,464 --> 00:33:31,010
આ ખરેખર માત્ર પ્રોટોકોલ છે
કે હું વિશે વાત કરવામાં આવી હતી.

538
00:33:31,010 --> 00:33:35,670
તેથી આ ઘટનાઓ છે કે એપલ
સાથે શરૂ કરવા માટે આપી છે.

539
00:33:35,670 --> 00:33:38,050
કંઇ કેટલાક ત્યાં છે
હમણાં કાર્યોને,

540
00:33:38,050 --> 00:33:40,820
પરંતુ અમે પ્રારંભ કરવા માંગો છો
અમારા એપ્લિકેશન માટે કંઈક

541
00:33:40,820 --> 00:33:46,140
પ્રદર્શિત પ્રવેશ મેળવવામાં પહેલાં
કોઈ પણ દૃશ્ય, અમે અહીં આ કરી.

542
00:33:46,140 --> 00:33:51,150
>> તમે માત્ર નામ વાંચી શકે છે અને હું માનું
ઘટના ખરેખર ખરેખર સ્પષ્ટ છે.

543
00:33:51,150 --> 00:33:54,160

544
00:33:54,160 --> 00:33:58,350
તેથી હવે મુખ્ય બનાવી છે
AppDelegate માટે એક ઑબ્જેક્ટ.

545
00:33:58,350 --> 00:34:05,220
અને AppDelegate કરી રહ્યું છે શું
વાસ્તવમાં પણ તમે માંથી છુપાયેલ છે.

546
00:34:05,220 --> 00:34:09,250
આ AppDelegate શરૂ થઈ રહ્યું છે
આ ViewController સ્ટોક લોડ.

547
00:34:09,250 --> 00:34:13,170
તેથી તે મૂળભૂત રીતે શરૂ બનશે
કે તમારી પાસે બધા જોવાઈ લોડ

548
00:34:13,170 --> 00:34:17,500
અને માત્ર દેખાવ રેન્ડર
આ વંશવેલો પર આધારિત છે.

549
00:34:17,500 --> 00:34:21,280
>> તેથી આ કિસ્સામાં અમે માત્ર હોય
અહીં છે જે એક દૃશ્ય,.

550
00:34:21,280 --> 00:34:25,060
તેથી કે આ જ દૃશ્ય છે
કે કહી શકાય બનશે.

551
00:34:25,060 --> 00:34:28,159
આ ViewController તર્ક અહીં છે.

552
00:34:28,159 --> 00:34:32,159
આ સૂચવે છે કે વાસ્તવમાં કોડ છે
અમે ફક્ત જોવા મળી દેખાવ નિયંત્રિત કરે છે.

553
00:34:32,159 --> 00:34:33,679
બધા હક, ચાલો અહીં કંઈક દો.

554
00:34:33,679 --> 00:34:44,030

555
00:34:44,030 --> 00:34:50,560
તેથી viewDidLoad એક ઘટના જેવું સંભળાય છે,
જ્યારે આ પણ એક પ્રતિનિધિ છે હકીકતમાં,

556
00:34:50,560 --> 00:34:52,500
આ પણ એક પ્રોટોકોલ છે.

557
00:34:52,500 --> 00:34:56,350
>> જેથી દૃશ્ય, લેવાય છે ગમે
આ કાર્ય અંદર બધું

558
00:34:56,350 --> 00:34:57,920
કહેવાય આવશે.

559
00:34:57,920 --> 00:35:02,840
આ કિસ્સામાં અમે હેલો "જોવા જોઈએ
Tianyu! "અમે કાર્યક્રમ ચલાવો તો.

560
00:35:02,840 --> 00:35:09,820

561
00:35:09,820 --> 00:35:12,842
તે થોડો ધીમી મેળવવામાં આવ્યું
સ્ટોરીબોર્ડ ફાઇલો કમ્પાઇલ.

562
00:35:12,842 --> 00:35:15,440

563
00:35:15,440 --> 00:35:18,190
સાથે સાથે ખરેખર, અમે તેને માટે એક આઉટપુટ જુઓ છો.

564
00:35:18,190 --> 00:35:20,720
તે સરસ છે.

565
00:35:20,720 --> 00:35:22,000
હવે ચાલો ખરેખર મારિયો કરવા દો.

566
00:35:22,000 --> 00:35:25,400

567
00:35:25,400 --> 00:35:27,625
હું વ્યાખ્યાયિત જાઉં છું
ખૂબ જ ઝડપથી કાર્ય.

568
00:35:27,625 --> 00:35:31,510

569
00:35:31,510 --> 00:35:54,245
marioWithLevels: (પૂર્ણાંક) સ્તર પરિણામો.

570
00:35:54,245 --> 00:36:01,120

571
00:36:01,120 --> 00:36:06,410
>> બધા હક છે, આ ખરેખર અદ્ભુત છે
ઓ કોડ ઓટો પૂર્ણ લક્ષણ.

572
00:36:06,410 --> 00:36:10,680
તેથી તમારા માટે લખી અને એન્ટર લખો ત્યારે,
તે પહેલાથી નમૂના અપ આપ્યો છે

573
00:36:10,680 --> 00:36:12,325
તમારા માટે, જે સરસ છે.

574
00:36:12,325 --> 00:36:50,480

575
00:36:50,480 --> 00:36:52,850
કે ખરેખર જોવા જોઈએ
તમે ગાય્ઝ પરિચિત.

576
00:36:52,850 --> 00:36:55,940

577
00:36:55,940 --> 00:36:59,680
માફ કરશો, તે મારા દોષ છે.

578
00:36:59,680 --> 00:37:15,790

579
00:37:15,790 --> 00:37:18,120
બધા હક, ઠંડી.

580
00:37:18,120 --> 00:37:22,710
કે તર્ક ખરેખર પરિચિત જોવું જોઈએ
તમે ગાય્ઝ, ખાસ કરીને માત્ર મારિયો માટે.

581
00:37:22,710 --> 00:37:26,140
>> પરંતુ અમે હવે કરો છાપશે
કન્સોલ દરેક એક સમય,

582
00:37:26,140 --> 00:37:29,280
અમે અચાનક રાખવા માંગો કારણ
અમે છાપવા કરી રહ્યા છે તે પર નજર.

583
00:37:29,280 --> 00:37:31,810
આપણે ઉપયોગ જઈ રહ્યાં છો
બાદમાં કોઈક પરિણમે,

584
00:37:31,810 --> 00:37:35,010
પ્રિન્ટ પ્રદર્શિત કરવા
બહાર વપરાશકર્તા માટે પરિણમી.

585
00:37:35,010 --> 00:37:37,730
તેથી તેના બદલે આપણે માત્ર છો
બધું nslogging,

586
00:37:37,730 --> 00:37:42,410
જે અમે બધું સ્ટોર કરી રહ્યાં
એક વિધેય કોલ પરિણામ માં,

587
00:37:42,410 --> 00:37:44,070
પરંતુ તર્ક બરાબર જ છે.

588
00:37:44,070 --> 00:37:48,030

589
00:37:48,030 --> 00:37:51,800
અમે તેને, અમે સમાપ્ત કર્યા પછી
માત્ર અમારી પરિણામો છાપવા.

590
00:37:51,800 --> 00:37:59,330

591
00:37:59,330 --> 00:38:04,970
>> અને અહીં બદલે બહાર છાપવા મારા
નામ, અમે એક કાર્ય કહી રહ્યા છીએ.

592
00:38:04,970 --> 00:38:15,340

593
00:38:15,340 --> 00:38:18,090
માતાનો જુઓ શું થાય દો.

594
00:38:18,090 --> 00:38:21,240
અરે, દેખીતી.

595
00:38:21,240 --> 00:38:24,320
અમે એક સરસ હોય
અહીં બહાર થોડી પિરામિડ.

596
00:38:24,320 --> 00:38:28,370
આ મૂળભૂત સી હોય, તો અમે છો માત્ર
તમે કાર્ય કહી જ્યાં હેરફેર

597
00:38:28,370 --> 00:38:30,010
અને કેવી જેમ કાર્ય લાગતું નથી.

598
00:38:30,010 --> 00:38:31,560
વિવિધ કશું જ નથી.

599
00:38:31,560 --> 00:38:34,040
પરંતુ આ ખરેખર છે
નથી ખૂબ જ આકર્ષક અહીં,

600
00:38:34,040 --> 00:38:37,500
અમે જોયા નથી, કારણ
આઇફોન એપ્લિકેશન કશું.

601
00:38:37,500 --> 00:38:42,120
>> તેથી તમે ખરેખર app-- એક આઇફોન હોય તો
તમે ખરેખર મારિયો iOS અધિકાર છે તો

602
00:38:42,120 --> 00:38:45,080
હવે, તમે નથી જઈ રહ્યાં છો
કંઈપણ જોવા માટે કે

603
00:38:45,080 --> 00:38:49,450
કારણ મારિયો સાથે જે કાંઈ છે
કન્સોલ માં તમામ તે આઉટપુટ

604
00:38:49,450 --> 00:38:51,620
વપરાશકર્તા માંથી છુપાયેલ છે.

605
00:38:51,620 --> 00:38:53,850
આ રીતે, તમે તે જોવા માટે શું છે
જે "હેલો વર્લ્ડ !!!" છે

606
00:38:53,850 --> 00:38:55,720
સારી નથી.

607
00:38:55,720 --> 00:39:03,090
હવે આપણે વપરાશકર્તાને જોવા બનાવવા પ્રયાસ કરીએ
બરાબર શું અમે બહાર છાપવા કરી રહ્યાં છો.

608
00:39:03,090 --> 00:39:06,000
તેથી અમે હવે લેબલ માટે જરૂર નથી.

609
00:39:06,000 --> 00:39:09,800
માતાનો પ્રયાસ કરીએ અને કંઈક બહાર આકૃતિ
બીજું કે ઉપયોગી હોઈ શકે છે.

610
00:39:09,800 --> 00:39:12,140
>> ખરેખર એક છે
કહેવાય છે કે તત્વ

611
00:39:12,140 --> 00:39:16,460
લખાણ ક્ષેત્રમાં, જે કરી શકે
અમારા માટે ખૂબ ઉપયોગી સાબિત થઈ.

612
00:39:16,460 --> 00:39:19,880
તે વાસ્તવમાં એક પ્રદેશ દર્શાવે
ટેક્સ્ટની ફેરફાર કરી શકો છો કે જે.

613
00:39:19,880 --> 00:39:22,320
જેથી ખરેખર મદદરૂપ જુએ છે.

614
00:39:22,320 --> 00:39:23,810
હવે આપણે ખેંચો અને તેને મૂકવા દો.

615
00:39:23,810 --> 00:39:26,880

616
00:39:26,880 --> 00:39:32,670
વાહ, અમે એક ટેક્સ્ટ દૃશ્ય હોય
અમારા દૃશ્યમાં, ખરેખર ફેન્સી.

617
00:39:32,670 --> 00:39:35,430
કે થોડુંક ખૂબ મોટી છે.

618
00:39:35,430 --> 00:39:38,150
ચાલો તે નાના બનાવે છે.

619
00:39:38,150 --> 00:39:40,290
કેન્દ્ર માં મૂકો.

620
00:39:40,290 --> 00:39:43,760
સાથે સાથે તે નાના બનાવે છે.

621
00:39:43,760 --> 00:39:50,110
>> હવે અમે જે અમે કરી શકે છે, એક ટેક્સ્ટ દૃશ્ય હોય
અમારા અંતિમ પરિણામ પ્રદર્શિત કરવા માટે વાપરી શકાય.

622
00:39:50,110 --> 00:39:52,860
પરંતુ હમણાં તે છે
ચોક્કસપણે કામ ચાલી રહ્યું નથી

623
00:39:52,860 --> 00:39:56,970
આ no-- કારણ કે ત્યાં
ViewController આપણે માત્ર

624
00:39:56,970 --> 00:40:03,010
કે ખબર નથી વ્યાખ્યાયિત
ત્યાં બહાર એક ટેક્સ્ટ દૃશ્ય છે.

625
00:40:03,010 --> 00:40:06,550
તેથી અમે કોઈક માટે જરૂર
લખાણ દૃશ્ય લિંક આપણે માત્ર

626
00:40:06,550 --> 00:40:11,660
આ વર્ગ સાથે બનાવવામાં કે
પહેલેથી અમારી સાથે આવી ગયો છે.

627
00:40:11,660 --> 00:40:14,860
>> અમે તે કરી માર્ગ છે
ખરેખર ખરેખર જાદુઈ.

628
00:40:14,860 --> 00:40:18,190
જેથી સ્ટોરીબોર્ડ ખોલો.

629
00:40:18,190 --> 00:40:22,220
ત્યાં એક ખાસ [અશ્રાવ્ય]
[કહેવાય? મદદનીશ?] [અશ્રાવ્ય].

630
00:40:22,220 --> 00:40:25,190
તમે તે ક્લિક કરો ત્યારે, તે છે
બે ફાઈલો ખોલવા જઈ.

631
00:40:25,190 --> 00:40:29,425
એક એક વર્ગ અને બીજો એક છે
તેના માટે અનુરૂપ દેખાવ છે.

632
00:40:29,425 --> 00:40:31,920
તે ખૂબ, ખૂબ મદદરૂપ છે.

633
00:40:31,920 --> 00:40:35,950
અને આપણે માત્ર આ ક ફાઇલ જાય દો.

634
00:40:35,950 --> 00:40:39,110
નિયંત્રણ, આ [અશ્રાવ્ય] તર્ક છે.

635
00:40:39,110 --> 00:40:47,280
પ્રેસ નિયંત્રણ અને ખેંચો એ
જાહેરાત માં ટેક્સ્ટ દૃશ્ય.

636
00:40:47,280 --> 00:40:48,780
અમે તે outputView કહી રહ્યા છીએ.

637
00:40:48,780 --> 00:40:52,189

638
00:40:52,189 --> 00:40:53,670
કનેક્ટ કરો.

639
00:40:53,670 --> 00:40:59,420
અહીં અમે નવા જાહેર કરી છે
અમારા ViewController વર્ગ માટે મિલકત.

640
00:40:59,420 --> 00:41:02,300
અને નવા મિલકત
માત્ર લખાણ દેખાવ છે

641
00:41:02,300 --> 00:41:05,000
આપણે ઈન્ટરફેસ બિલ્ડિંગમાં બનાવી છે.

642
00:41:05,000 --> 00:41:07,990
તે રીતે અમે કરી શકે છે તેથી
ઍક્સેસ તમામ માહિતી

643
00:41:07,990 --> 00:41:13,630
અને અંદર છે કે બધું ચાલાકી
ભયાનક છે, કે જે એ આઉટપુટ જુઓ,.

644
00:41:13,630 --> 00:41:19,260
>> અમારા વાસ્તવિક કોડ એટલી
માતાનો તેની સાથે કંઈક કરીએ.

645
00:41:19,260 --> 00:41:23,810
તેથી આ સમય અમે પ્રિન્ટીંગ જેવા છે ત્યારે
અંતિમ પરિણામ બહાર મારિયો માટે,

646
00:41:23,810 --> 00:41:28,020
આપણે કંઈ પ્રવેશ ન કરશો.

647
00:41:28,020 --> 00:41:30,080
હું અમે ચાલુ રાખી શકે એમ થાય
આ લોગીંગ નિવેદન.

648
00:41:30,080 --> 00:41:41,490
આ ઉપરાંત, અમે
આ readout મોકલો આપણે માત્ર

649
00:41:41,490 --> 00:41:47,622
આઉટપુટ જુઓ, માટે બનાવવામાં જેમાં
અમે ફક્ત બનાવનાર TextView એક UI છે.

650
00:41:47,622 --> 00:41:48,746
હવે આપણે શું થાય છે તે જોવા દો.

651
00:41:48,746 --> 00:41:54,470

652
00:41:54,470 --> 00:41:56,620
વાહ.

653
00:41:56,620 --> 00:41:59,130
અમે હમણાં એપ્લિકેશનમાં એક પિરામીડ છે.

654
00:41:59,130 --> 00:42:06,720
>> વપરાશકર્તાને અમારા આઉટપુટ કારણ જોઈ શકે છે તેથી
અમે અમારી કોડ માંથી આઉટપુટ નકલ કરેલ છે

655
00:42:06,720 --> 00:42:08,045
અમારા ઈન્ટરફેસમાં.

656
00:42:08,045 --> 00:42:10,950
તે ખૂબ સારી છે.

657
00:42:10,950 --> 00:42:14,990
તે ખરેખર છે કે નથી
ઉત્તેજક અમે can-- કારણ

658
00:42:14,990 --> 00:42:18,250
તમામ એપ્લિકેશન થયેલ કરવાનું છે
તમને એક પિરામીડ દર્શાવે,

659
00:42:18,250 --> 00:42:20,520
અને તમે તે વિશે શું કરી શકો છો કંઇ નથી.

660
00:42:20,520 --> 00:42:22,330
તે ખાસ કરીને આકર્ષક નથી.

661
00:42:22,330 --> 00:42:27,840
તેથી હવે આપણે એક બટન બનાવવા દો
કે જોવાઈ સાફ કરશે.

662
00:42:27,840 --> 00:42:30,290
એક બટન મદદરૂપ થશે કે લાગે છે.

663
00:42:30,290 --> 00:42:33,270
ખેંચો અને છોડો.

664
00:42:33,270 --> 00:42:33,900
બટન એક.

665
00:42:33,900 --> 00:42:36,730

666
00:42:36,730 --> 00:42:37,320
બટન બે.

667
00:42:37,320 --> 00:42:49,170

668
00:42:49,170 --> 00:42:52,052
>> તેથી અમે ડાબી ક્લિક કરો ત્યારે
બટન, દેખાવ સાફ કરીશું.

669
00:42:52,052 --> 00:42:53,635
સ્ક્રીન પર કશું જ હોવું જોઈએ.

670
00:42:53,635 --> 00:42:56,970
અને અમે ક્લિક કરો ત્યારે
જમણી બટન, મારિયો,

671
00:42:56,970 --> 00:42:59,740
દૃશ્ય ફરી દેખાય રહ્યું છે.

672
00:42:59,740 --> 00:43:05,510
જેથી આ રીતે આપણે પણ કરવું
જાદુ સામગ્રી, નિયંત્રણ અને ખેંચો

673
00:43:05,510 --> 00:43:08,740
વર્ગ ઘોષણા કરવા
મદદનીશ director-- માં

674
00:43:08,740 --> 00:43:11,600
મદદનીશ દર્શક માં.

675
00:43:11,600 --> 00:43:18,620
આ કિસ્સામાં અમે સ્પષ્ટ કરી રહ્યા
કે જે એક ક્રિયા પ્રયત્ન કરીશું.

676
00:43:18,620 --> 00:43:19,120
clearMario.

677
00:43:19,120 --> 00:43:21,650

678
00:43:21,650 --> 00:43:26,830
>> અહીં અમે પહેલાથી બનાવેલ હોય
clearMario નામની એક ક્રિયા,

679
00:43:26,830 --> 00:43:34,210
જે કહેવાય છે કે જે પદ્ધતિ છે
અમે બટન સ્પષ્ટ દબાવો જ્યારે પણ.

680
00:43:34,210 --> 00:43:41,030
અમારા વાસ્તવમાં કોડ તેથી, માત્ર દો
આઉટપુટ લખાણ અને આઉટપુટ દૃશ્ય મૂકી

681
00:43:41,030 --> 00:43:44,620
કંઇ માં, અને તે રીતે
તે સ્પષ્ટ થઈ દેખાશે.

682
00:43:44,620 --> 00:43:47,500

683
00:43:47,500 --> 00:43:57,230
આ ઉપરાંત, માતાનો બનાવવા દો
runMario કહેવાય અન્ય પદ્ધતિ.

684
00:43:57,230 --> 00:44:00,140

685
00:44:00,140 --> 00:44:03,436
ઓહ માફ કરશો, મિલકત કે ન હોવી જોઈએ.

686
00:44:03,436 --> 00:44:12,107

687
00:44:12,107 --> 00:44:13,940
બધા હક છે, કે જોઈએ
સાથે સાથે એક ક્રિયા થઈ.

688
00:44:13,940 --> 00:44:25,780

689
00:44:25,780 --> 00:44:34,740
>> અને તે કાર્ય હોય ત્યારે
કહેવાય, અમે માત્ર મારિયો દસ ચલાવો.

690
00:44:34,740 --> 00:44:37,620

691
00:44:37,620 --> 00:44:39,780
આસ્થાપૂર્વક કે દંડ થશે.

692
00:44:39,780 --> 00:44:41,120
તે કમ્પાઇલ કરે છે?

693
00:44:41,120 --> 00:44:43,920
હા.

694
00:44:43,920 --> 00:44:45,090
હવે અમે એક દૃશ્ય હોય છે.

695
00:44:45,090 --> 00:44:46,560
અમે એક આઉટપુટ છે.

696
00:44:46,560 --> 00:44:50,040
અને આપણે માત્ર જુઓ શું થાય દો.

697
00:44:50,040 --> 00:44:52,590
કે ગઇ છે.

698
00:44:52,590 --> 00:44:54,500
તે ફરી પાછા છે.

699
00:44:54,500 --> 00:44:57,620
અહીં અમે સ્પષ્ટ કરેલ છે
કાર્ય અને કેવા પ્રકારના

700
00:44:57,620 --> 00:45:00,400
જ્યારે કહેવાશે
અમે કંઈક લખો,

701
00:45:00,400 --> 00:45:03,160
અમે ચોક્કસ બટન દબાવો ત્યારે.

702
00:45:03,160 --> 00:45:07,890
આ મારાથી છે
લક્ષ્ય ક્રિયા યોજના

703
00:45:07,890 --> 00:45:12,510
ઇવેન્ટ માટે ચલાવાય
ઉદ્દેશ સી માં પ્રોગ્રામીંગ

704
00:45:12,510 --> 00:45:15,030
>> આ ઉપરાંત,
તે ખૂબ જ ઉત્તેજક નથી

705
00:45:15,030 --> 00:45:19,810
અમે ખરેખર બદલી શકતા નથી કારણ કે
પિરામિડ કેવી ઊંચી હશે,

706
00:45:19,810 --> 00:45:23,640
તેથી અમે કદાચ કોઈક માંગતા
વપરાશકર્તા તરફથી ઇનપુટ વિચાર

707
00:45:23,640 --> 00:45:29,490
અને જ્યારે ટોચ બદલવા
પિરામિડ તેઓ શું આઉટપુટ પર આધારિત છે.

708
00:45:29,490 --> 00:45:32,900
તેથી અમે તે કરવા જઇ રહ્યા છો.

709
00:45:32,900 --> 00:45:38,720
તેથી અમે runMario કૉલ કરો ત્યારે આ સમય,
અમે ફક્ત મારિયો સીધા નથી કહેતો.

710
00:45:38,720 --> 00:46:06,280

711
00:46:06,280 --> 00:46:07,000
આ એક શીર્ષક.

712
00:46:07,000 --> 00:46:22,180

713
00:46:22,180 --> 00:46:23,700
>> પ્રતિનિધિ.

714
00:46:23,700 --> 00:46:25,160
આ ખૂબ જ રસપ્રદ છે.

715
00:46:25,160 --> 00:46:26,720
પ્રતિનિધિ શું છે?

716
00:46:26,720 --> 00:46:28,950
હું અહીં સ્વ મૂકી જાઉં છું.

717
00:46:28,950 --> 00:46:31,038
અને અમે જોવા જઈ રહ્યાં છો
શું કે પછી થાય છે.

718
00:46:31,038 --> 00:46:46,380

719
00:46:46,380 --> 00:46:51,120
અહીં અમે મૂળભૂત રીતે રચના કરી છે એક
ચોક્કસ દાખલા એક UI ચેતવણી કહેવાય

720
00:46:51,120 --> 00:46:52,210
દૃશ્ય.

721
00:46:52,210 --> 00:46:54,440
એક UI ચેતવણી દેખાવ છે
મૂળભૂત રીતે શું તમે કરશે

722
00:46:54,440 --> 00:46:58,940
દર વખતે કંઈક પોપ્સ જોવા
ઈનપુટ માટે પૂછે છે અને અપ,

723
00:46:58,940 --> 00:47:03,080
તમે પ્રયાસ કરી રહ્યા છો ત્યારે શું થશે જેવી
એક એપ્લિકેશન સ્ટોર પર કંઈક ખરીદી માટે.

724
00:47:03,080 --> 00:47:14,250
>> આ ઉપરાંત, તમે પછી
તે બનાવવા માટે, અમે ફક્ત ચેતવણી બતાવવા.

725
00:47:14,250 --> 00:47:20,090

726
00:47:20,090 --> 00:47:22,568
બધા હક છે, માત્ર ઝડપથી ચાલો
ટેસ્ટ કે કામ અથવા નથી.

727
00:47:22,568 --> 00:47:31,105

728
00:47:31,105 --> 00:47:32,140
કે ખૂબ જ ઠંડી છે.

729
00:47:32,140 --> 00:47:55,370

730
00:47:55,370 --> 00:47:59,120
હવે આપણે ખરેખર એક બનાવવા દો
આ UI એ ચેતવણી માટે ઇનપુટ ક્ષેત્ર.

731
00:47:59,120 --> 00:48:01,170
આ અમે તે કરવા કેવી રીતે છે.

732
00:48:01,170 --> 00:48:07,490
અને અમે એક હોવા જોઈએ
ચેતવણી માટે ઇનપુટ દૃશ્ય.

733
00:48:07,490 --> 00:48:09,020
ખૂબ જ ઠંડી.

734
00:48:09,020 --> 00:48:12,330
ચાલો માત્ર 10 કહે છે.

735
00:48:12,330 --> 00:48:14,900
>> તે અધિકાર કંઇ કરવાનું નથી
હવે કોલ ખરેખર કારણ

736
00:48:14,900 --> 00:48:17,770
મારિયો ચલાવવા માટે બદલી ન હતી.

737
00:48:17,770 --> 00:48:23,470
તેથી આ થોડી બની છે
થોડી વિચિત્ર જ્યારે પણ કારણ

738
00:48:23,470 --> 00:48:30,790
અમે જ્યારે પણ અમે નીચે એક બટન દબાવો
ચેતવણી દૃશ્યમાં એક બટન દબાવો,

739
00:48:30,790 --> 00:48:35,560
કંઈક, થાય કરીશું
પરંતુ તે ન થાય.

740
00:48:35,560 --> 00:48:37,220
અમે તે કેવી પકડી શકું?

741
00:48:37,220 --> 00:48:41,280
કેવી રીતે અમે એક વપરાશકર્તા જાણો છો કે
ચેતવણી દૃશ્ય બરતરફ કરી છે

742
00:48:41,280 --> 00:48:45,630
અને પહેલેથી કારણ કે સંખ્યાબંધ દાખલ થયો
હમણાં કશું ખરેખર શું થઈ રહ્યું.

743
00:48:45,630 --> 00:48:50,450
>> સારું, તમે અનુમાન લગાવ્યું છે શકે
તે હક, પ્રતિનિધિમંડળની.

744
00:48:50,450 --> 00:48:55,440
જેથી તમામ ઉપરાંત
આ જાહેરાતો,

745
00:48:55,440 --> 00:49:03,190
અમે નવા પ્રતિનિધિમંડળ માટે ઉમેરવાની જરૂર
તે યુઆઇ ચેતવણી દૃશ્ય પ્રતિનિધિ કહેવાય.

746
00:49:03,190 --> 00:49:06,440
દરેક એક કે જેથી
ક્રિયાપ્રતિક્રિયા અથવા ઘટના

747
00:49:06,440 --> 00:49:10,190
અમે હોય રહ્યા છીએ કે
આ UI એ ચેતવણી અર્થે

748
00:49:10,190 --> 00:49:14,100
નિયંત્રિત કરી રહ્યું છે
સાથે સાથે અમારા વર્ગ દ્વારા.

749
00:49:14,100 --> 00:49:26,297
>> જેથી ઉપરાંત, હશે
અનુક્રમણિકા પર ચેતવણી દૃશ્ય ક્લિક કરો બટન.

750
00:49:26,297 --> 00:49:34,260

751
00:49:34,260 --> 00:49:37,730
આ પહોંચી છે.

752
00:49:37,730 --> 00:49:42,020
અમે હોય તે કિસ્સામાં આવું
પહેલેથી તેથી અમે હોય

753
00:49:42,020 --> 00:49:46,210
એ પ્રોટોકોલ બહાર આવ્યું છે કે
જ્યારે ઘટના નિયંત્રિત કરશે

754
00:49:46,210 --> 00:49:51,320
આપણે ગયું બટન ક્લિક
ચેતવણી દૃશ્ય પર.

755
00:49:51,320 --> 00:49:55,976
જેથી દર વખતે આપણે બરતરફ
ચેતવણી દૃશ્ય, આ શું કરવું જોઈએ.

756
00:49:55,976 --> 00:49:57,350
મને માત્ર ખૂબ જ ઝડપથી તે ચકાસવા દો.

757
00:49:57,350 --> 00:50:16,220

758
00:50:16,220 --> 00:50:19,300
સાથે સાથે ખરેખર, આપણે અહીં પહોંચી ગયા છો.

759
00:50:19,300 --> 00:50:22,210
>> અહીં, અમે શું નહીં કરે
વાસ્તવમાં ખરેખર છે વિચાર

760
00:50:22,210 --> 00:50:43,120
તેથી અમે બહાર વિચાર કરવા માંગો છો કરવું વિચાર
અમે અગાઉ હોય છે કે જે લખાણ

761
00:50:43,120 --> 00:50:45,350
ચેતવણી દૃશ્યમાં દાખલ થયો હતો.

762
00:50:45,350 --> 00:50:48,505
અને લખાણ પર આધારિત છે, અમે છો
મારિયો પ્રદર્શિત કરવા જઈ રહી છે.

763
00:50:48,505 --> 00:50:52,336

764
00:50:52,336 --> 00:50:55,480
આ ખૂબ જ ઝડપથી બહાર કરે
તે ખરેખર કામ કરે છે કે નહીં જો.

765
00:50:55,480 --> 00:50:59,476
તે કિસ્સામાં તેથી, અમે ઇનપુટ તો
અમે 10 જોવા જોઈએ, 10, ચાલો કહે.

766
00:50:59,476 --> 00:51:02,740

767
00:51:02,740 --> 00:51:05,210
>> ખૂબ જ સારી, અમે અહીં સંખ્યાબંધ ધરાવે છે.

768
00:51:05,210 --> 00:51:06,470
તે ખૂબ સારી છે.

769
00:51:06,470 --> 00:51:16,840
હવે જો છેલ્લા પગલું તેથી હોઈ કરશે
છેલ્લું પગલું અમે હમણાં શું કરવાની જરૂર

770
00:51:16,840 --> 00:51:21,100
માત્ર એક સાથે મારિયો કૉલ આવે
સ્તર ઇનપુટ પર આધારિત

771
00:51:21,100 --> 00:51:23,270
કે અમે ચેતવણી દૃશ્ય માં મૂકી છે.

772
00:51:23,270 --> 00:51:26,920
તેથી અમે કન્વર્ટ કરવાની જરૂર
iOS માં આ શબ્દમાળાને.

773
00:51:26,920 --> 00:51:33,820

774
00:51:33,820 --> 00:51:35,496
સ્ટેટિક ઓવરફ્લો ખૂબ ભયાનક છે.

775
00:51:35,496 --> 00:51:44,930

776
00:51:44,930 --> 00:51:51,182
અને પછી અમે માત્ર સ્વ કૉલ
marioWithLevels મૂલ્ય.

777
00:51:51,182 --> 00:51:54,550

778
00:51:54,550 --> 00:51:56,284
માતાનો ચાલશે કે નહીં તે જોવા દો
ખરેખર કામ નથી અથવા.

779
00:51:56,284 --> 00:51:59,070

780
00:51:59,070 --> 00:52:01,550
>> અમે પહેલાથી જ એક પિરામીડ આપવામાં રહ્યા છો.

781
00:52:01,550 --> 00:52:04,785
માતાનો ઊંચાઇ બદલવા માટે પ્રયાસ કરીએ.

782
00:52:04,785 --> 00:52:06,530
કે ખરેખર કામ કરે છે.

783
00:52:06,530 --> 00:52:07,610
તે સરસ છે.

784
00:52:07,610 --> 00:52:10,420
કે હવે તમે કરી શકો છો તેથી માત્ર
ઇનપુટ તમે ઇચ્છો તે કોઇપણ કિંમત.

785
00:52:10,420 --> 00:52:12,440
ચાલો માત્ર ચાર કહે છે.

786
00:52:12,440 --> 00:52:14,260
કે ખરેખર અદ્ભુત છે.

787
00:52:14,260 --> 00:52:17,090
તેથી આ મૂળભૂત છે
ખરેખર ઝડપી ઉદાહરણ

788
00:52:17,090 --> 00:52:23,170
માટે ઓ કોડમાં એક પ્રોજેક્ટ બનાવવા માટે કેવી રીતે
અને ખરેખર ઝડપથી વાયર માટે કેવી

789
00:52:23,170 --> 00:52:26,220
કેટલાક ખરેખર સરળ ઘટનાઓ અને કાર્યો.

790
00:52:26,220 --> 00:52:28,840
>> તેથી સ્ત્રોત રહ્યું છે
પછીથી અમને મૂકી શકાય.

791
00:52:28,840 --> 00:52:33,400
જો તમને રસ છો, તેથી જો
આઇઓએસ મારિયો કેવી રીતે કામ કરે છે,

792
00:52:33,400 --> 00:52:38,360
હું બરાબર એ જ મૂકી જાઉં છું
પાછળથી આ CS50 વેબસાઇટ પર પ્રોજેક્ટ.

793
00:52:38,360 --> 00:52:41,260
અમે મૂળભૂત રીતે પૂર્ણ કરી
ઉનાળામાં, અમે અને સમાપ્ત પહેલાં

794
00:52:41,260 --> 00:52:45,190
હું માત્ર તમને ગાય્ઝ નિર્દેશ કરવા માંગો છો
કેટલાક ખરેખર અદ્ભુત સંસાધનો કે

795
00:52:45,190 --> 00:52:47,550
ઓનલાઈન ઉપલબ્ધ છે.

796
00:52:47,550 --> 00:52:52,270
>> દેખીતી એપલ દસ્તાવેજીકરણ
ખૂબ મદદરૂપ થઈ રહ્યું છે.

797
00:52:52,270 --> 00:52:57,630
પરંતુ તે ઉપરાંત, હું ખાસ કરીને
ચાર સ્ત્રોતો, કોડ શાળા ભલામણ

798
00:52:57,630 --> 00:53:02,120
વૃક્ષ ઘર, AppCoda અને WWDC વિડિઓઝ.

799
00:53:02,120 --> 00:53:07,270
કોડ શાળા અને વૃક્ષ ઘર છે
બે ઓનલાઇન શિક્ષિત વેબસાઇટ્સ,

800
00:53:07,270 --> 00:53:10,210
જે ખાસ ધ્યાન કેન્દ્રિત
સોફ્ટવેર એન્જિનિયરિંગ પર.

801
00:53:10,210 --> 00:53:16,930
ખાસ કરીને કોડ શાળા માટે, તેઓ
iOS પર ખરેખર સારું ટ્યુટોરીયલ છે.

802
00:53:16,930 --> 00:53:19,550
>> કે તેના માટે ખરેખર ઝડપી ઉદાહરણ છે.

803
00:53:19,550 --> 00:53:22,980
તેઓ ખરેખર એક ખરેખર cute-- બનાવી
કે થોડું પહોંચેલું આઇફોન જોવા

804
00:53:22,980 --> 00:53:24,920
ત્યાં પર વરણાગિયું માણસ, તે ખરેખર અદ્ભુત છે.

805
00:53:24,920 --> 00:53:31,010
અને જે રીતે તેઓ ઉદ્દેશ સમજાવે
સી વાક્યરચના સંપૂર્ણપણે સ્પષ્ટ છે.

806
00:53:31,010 --> 00:53:32,230
વૃક્ષ ઘર જ છે.

807
00:53:32,230 --> 00:53:34,660
અને AppCoda એક મંચ છે.

808
00:53:34,660 --> 00:53:38,130
તે વાસ્તવમાં ચાલી હતી કે બ્લોગ છે
ખરેખર અનુભવ ઉદ્દેશ સી દ્વારા

809
00:53:38,130 --> 00:53:39,120
પ્રોગ્રામર.

810
00:53:39,120 --> 00:53:43,950
અને AppCoda માં તે બધા ટ્યુટોરિયલ્સ છે
ખૂબ ટૂંકા અને અમલ કરવા માટે સરળ,

811
00:53:43,950 --> 00:53:45,390
ખૂબ આગ્રહણીય.

812
00:53:45,390 --> 00:53:47,700
>> અને જો તમે વિકાસકર્તા છો,
ચોક્કસપણે શકો જવા

813
00:53:47,700 --> 00:53:55,660
કેવી રીતે WWDC વિડિઓઝ જ્યાં તમે કરી શકો છો
તાજેતરની iOS પ્રોગ્રામિંગ વિશે જાણવા

814
00:53:55,660 --> 00:53:58,250
યુકિતઓ, API નો અને લાઈબ્રેરીઓ.

815
00:53:58,250 --> 00:54:02,850
જેથી ખૂબ ખૂબ છે
આ પરિસંવાદ માટે.

816
00:54:02,850 --> 00:54:03,820
ખૂબ આભાર.

817
00:54:03,820 --> 00:54:08,040
અને હું તમને મજા હોય છે આશા
તમારા પોતાના iOS એપ્લિકેશન બનાવવા.

818
00:54:08,040 --> 00:54:09,302