1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [સેમિનાર] [iOS: એક બોસ જેમ Apps લેખન]

2
00:00:02,000 --> 00:00:04,000
[ટોમી MacWilliam] [હાર્વર્ડ યુનિવર્સિટી]

3
00:00:04,000 --> 00:00:08,000
[આ CS50 છે.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> અધિકાર બધા, દરેકને, iOS પર આપનું સ્વાગત છે: એક બોસ જેવી Apps લેખન.

5
00:00:12,000 --> 00:00:16,000
આ પરિસંવાદ માટે આઇફોન માટે એપ્લિકેશન્સ લખી રહ્યું છે

6
00:00:16,000 --> 00:00:19,000
અને છેવટે આઇપેડ માટેની એપ્લિકેશન્સ લેખન, અને તેથી અમે મૂળભૂત માટે લઈ જવામાં જઈ રહ્યાં છો

7
00:00:19,000 --> 00:00:23,000
કેવી રીતે એપ્લિકેશન બનાવવા માટે એક દંપતિ અલગ ઉદાહરણો માટે, ચહેરાના ટેક ટો જેવું સરળ રમત,

8
00:00:23,000 --> 00:00:26,000
અથવા જો તમે વધુ સમાચાર વાચક અમુક પ્રકારના જેવા એપ્લિકેશન બનાવવા રસ છો

9
00:00:26,000 --> 00:00:30,000
અથવા કંઈક કે જે ઈન્ટરનેટ હું પણ તે વિષે સાથે ક્રિયાપ્રતિક્રિયા કરે છે.

10
00:00:30,000 --> 00:00:32,000
અહીં અમારા સંક્ષિપ્ત કાર્યસૂચિ છે.

11
00:00:32,000 --> 00:00:36,000
>> આઇઓએસ એપ્લિકેશન્સ ઉદ્દેશ C-કહેવાય ભાષામાં લખવામાં આવે છે,

12
00:00:36,000 --> 00:00:39,000
અને તેથી આ થોડો સી માટે સમાન છે, પરંતુ ખરેખર ન બીટ છે,

13
00:00:39,000 --> 00:00:41,000
તેથી અમે ભાષા પોતાના વિશે થોડુંક કરી વાત કરીશું

14
00:00:41,000 --> 00:00:45,000
અને પછી આઇફોન આ એપ્લિકેશન XCode કહેવાય કાર્યક્રમ વાપરી એપ્લિકેશંસ બનાવવા કેવી રીતે,

15
00:00:45,000 --> 00:00:48,000
જે જો તમે તેને હજુ સુધી ડાઉનલોડ કર્યું હોય ડાઉનલોડ હવે શરૂ મફત લાગે.

16
00:00:48,000 --> 00:00:50,000
તે ઘણા ગીગાબાઇટ્સ છે.

17
00:00:50,000 --> 00:00:54,000
તે એપ સ્ટોર પર મુક્ત છે, કે જેથી તમારે માટે મેક હોય જરૂર પડશે

18
00:00:54,000 --> 00:00:57,000
આદર્શ OS X વિતરણ શક્ય ની તાજેતરની આવૃત્તિ ચલાવી

19
00:00:57,000 --> 00:00:59,000
જો તમે નથી, તો સમસ્યા નં.

20
00:00:59,000 --> 00:01:02,000
અમે તમારા ઉપયોગ માટે વિજ્ઞાન ઉપલબ્ધ કેન્દ્ર મેક્સ છે

21
00:01:02,000 --> 00:01:05,000
સાથે XCode સ્થાપિત કરો, અને તેથી વિકાસ માટે તે ઉપયોગ મફત લાગે.

22
00:01:05,000 --> 00:01:07,000
જો તમે એપ્લિકેશન બનાવવા માંગો છો, પરંતુ તમારી પાસે એક મેક નથી, ચિંતા ન કરશો.

23
00:01:07,000 --> 00:01:09,000
કેમ્પસમાં સ્રોતો માટે પુષ્કળ છે.

24
00:01:09,000 --> 00:01:15,000
અને તેથી તે પછી અમે વિવિધ એપ્લિકેશન્સ તમે કરી શકો 2 મોટા ઉદાહરણો આવરી રહ્યા છીએ.

25
00:01:15,000 --> 00:01:19,000
ઉદ્દેશ C-ટેકનિકલી એ છે જે સી એક સુપર સેટ કહેવાય છે

26
00:01:19,000 --> 00:01:24,000
તેનો અર્થ એ છે કે જે કોઈપણ સી કોડ પણ માન્ય કોડ ઉદ્દેશ C-છે.

27
00:01:24,000 --> 00:01:29,000
એટલે કે અમે નળી પ્રકારની સી માટે કેટલીક વધારાની સુવિધાઓ પર ટેપ

28
00:01:29,000 --> 00:01:33,000
આમાંની કેટલીક સુવિધાઓ માટે ક્યારેય malloc ફરીથી લખી નથી કર્યા સમાવેશ થાય છે, ભગવાન આભાર,

29
00:01:33,000 --> 00:01:36,000
કોઈ તે મૂર્ખ પોઇંટરો ચિંતા કર્યા અને તેમને મુક્ત અને તે તમામ સામગ્રી

30
00:01:36,000 --> 00:01:40,000
તમે સી વિશે નફરત, અને તે પ્રકારની ઉદ્દેશ C-ઇનમાં.

31
00:01:40,000 --> 00:01:43,000
>> હવે, ઉદ્દેશ C-પણ ખૂબ મોટા સ્ટાન્ડર્ડ લાઇબ્રેરી છે,

32
00:01:43,000 --> 00:01:47,000
તેથી ઘણો વધુ કાર્યક્ષમતા તમે ઉદ્દેશ C-મુક્ત અંદર માટે વિચાર છે.

33
00:01:47,000 --> 00:01:50,000
યાદ રાખો જ્યારે અમે PHP લખી હતી અમે નોંધ્યું છે કે અમે ના ગયા

34
00:01:50,000 --> 00:01:54,000
આ નાનું આ બધી ઉન્મત્ત વસ્તુઓ તમે કરી શકો છો વિશાળ પુસ્તકાલય માટે ભાષા.

35
00:01:54,000 --> 00:01:56,000
આ જ વસ્તુ iOS બને.

36
00:01:56,000 --> 00:01:59,000
ત્યાં બૌદ્ધ કૅલેન્ડર જેવી વસ્તુઓ માટે પદાર્થો છે, અને ખરેખર કંઈપણ

37
00:01:59,000 --> 00:02:05,000
તમે કદાચ કદાચ એ ઉદ્દેશ્ય C-અમલીકરણ પહેલાથી જ અસ્તિત્વમાં છે વિચાર કરી શકો છો.

38
00:02:05,000 --> 00:02:08,000
ઉદ્દેશ C-હેતુ ભાગ કંઈક સંદર્ભ આપે છે

39
00:02:08,000 --> 00:02:11,000
પ્રોગ્રામિંગ ઑબ્જેક્ટ-ઓરિએન્ટેડ કહેવાય છે.

40
00:02:11,000 --> 00:02:14,000
આ નવી વિભાવના પ્રકારની હોય છે, પરંતુ અમે ખરેખર મોટે ભાગે શીખી કર્યું છે

41
00:02:14,000 --> 00:02:17,000
આ વિચારોનું પહેલેથી ઘણું.

42
00:02:17,000 --> 00:02:19,000
ઑબ્જેક્ટ-ઓરિએન્ટેડ પ્રોગ્રામિંગ પાછળ વિચાર છે કે જે તમે માળખું જઈ રહ્યાં છો

43
00:02:19,000 --> 00:02:23,000
આ બધી વસ્તુઓ આસપાસ તમારો કોડ ઘણો વર્ગો કહેવાય છે,

44
00:02:23,000 --> 00:02:26,000
અને આ વર્ગો ખરેખર સ્ટ્ર્ક્ટ્સ વિશાળ છે.

45
00:02:26,000 --> 00:02:30,000
એક સ્ટ્રક્ટ ની અંદર અમે મૂળભૂત રીતે અહીં જણાવ્યું હતું કે એક વસ્તુ છે,

46
00:02:30,000 --> 00:02:32,000
અને આ બાબત સભ્યો ધરાવી શકે છે.

47
00:02:32,000 --> 00:02:35,000
ઉદાહરણ તરીકે, એક કડી થયેલ યાદીમાં નોડ અન્ય વસ્તુઓ કરી શકે છે

48
00:02:35,000 --> 00:02:38,000
કિંમત જેમ, યાદીમાં બીજા ગાંઠ પર એક નિર્દેશક,

49
00:02:38,000 --> 00:02:44,000
અને સાથે મળીને કે નિર્દેશક અને કિંમત એક સ્ટ્રક્ટ આ એક ઉદાહરણ બનેલા હોય છે.

50
00:02:44,000 --> 00:02:47,000
વર્ગો ખૂબ સમાન છે સિવાય

51
00:02:47,000 --> 00:02:50,000
વર્ગો પણ તેમને અંદર કાર્યો કરી શકે છે.

52
00:02:50,000 --> 00:02:54,000
જ્યારે અમે સ્ટ્રક્ટ જાહેર, અમે માત્ર પૂર્ણાંક n અથવા નોડ આગામી * કહેવું શકે છે.

53
00:02:54,000 --> 00:02:57,000
>> હવે ઉદ્દેશ-C સાથે આપણે ખરેખર વિધેયો મૂકી શકો છો

54
00:02:57,000 --> 00:02:59,000
અંદર તે બાબતો.

55
00:02:59,000 --> 00:03:03,000
અન્ય ચીજ છે કે વર્ગો કરી શકે છે તેઓ અન્ય વર્ગોની માહિતી મેળવી શકતો નથી.

56
00:03:03,000 --> 00:03:07,000
ઉદાહરણ તરીકે, અમે ઉદ્દેશ C-વર્ગો આંતરિક સમૂહ જોઈ આવશે.

57
00:03:07,000 --> 00:03:11,000
તેમાંથી એક વર્ગ છે કે જે સ્ક્રિન માટે દષ્ટિકોણ રજૂ હોઇ શકે છે,

58
00:03:11,000 --> 00:03:14,000
અને તેથી એવું કહેતા હું મારી પોતાની દૃશ્ય અમલ કરવા માંગો છો

59
00:03:14,000 --> 00:03:18,000
અમે મૂળભૂત એપલ અંતે ઉપર, કોઈને કદાચ ખરેખર સરસ લોકો કહે છે,

60
00:03:18,000 --> 00:03:21,000
મારા માટે આ વર્ગ લખ્યું, અને તેને બટનો પ્રદર્શિત જેવી વસ્તુઓ સંભાળે

61
00:03:21,000 --> 00:03:25,000
અથવા સ્ક્રીન રેન્ડર છે, અને અમે ખરેખર pained હશે

62
00:03:25,000 --> 00:03:28,000
કે બધા વિધેયો જાતને અમલમાં મૂકવા માટે, અને તેથી ફક્ત દ્વારા

63
00:03:28,000 --> 00:03:31,000
માહિતી વારસામાં અમે બધું કે જે તમને વર્ગ કર્યું હતું કહેવું કરી શકો છો

64
00:03:31,000 --> 00:03:34,000
હું પણ મારા વર્ગ ની અંદર કરવા માંગો છો, અને પછી હું કેટલાક અન્ય સામગ્રી કરવા જાઉં છું,

65
00:03:34,000 --> 00:03:37,000
એટલે કે એક એપ્લિકેશન અમલ.

66
00:03:37,000 --> 00:03:40,000
કે કે શબ્દ વારસો શું અર્થ થાય છે. અમે વધુ નક્કર ઉદાહરણ જોશો.

67
00:03:40,000 --> 00:03:42,000
>> અને છેલ્લે, ઑબ્જેક્ટ-ઓરિએન્ટેડ પ્રોગ્રામિંગ સાથે કી છે કે

68
00:03:42,000 --> 00:03:45,000
તે માહિતી પડતો થાય છે.

69
00:03:45,000 --> 00:03:48,000
અમારી સમસ્યા અમુક સુયોજિત કરે છે અમે આ મોટા, વૈશ્વિક ચલો કરી શકે છે

70
00:03:48,000 --> 00:03:51,000
અને દરેક જગ્યાએ globals, અને તે કેવી રીતે અમે રાજ્ય ટ્રૅક રાખવા માંગો છો.

71
00:03:51,000 --> 00:03:55,000
વર્ગો સાથે અમે એક પદાર્થ ની અંદર માહિતી પ્રાવૃત શરૂ કરી શકો છો.

72
00:03:55,000 --> 00:03:58,000
જો અમે અમારી એપ્લિકેશન પર એક સ્ક્રીન છે, તો અમે ખરેખર કોઇ પણ માહિતી હોય છે જરૂર નથી

73
00:03:58,000 --> 00:04:01,000
અમારા કે એપ્લિકેશન અંદર બીજા સ્ક્રીન,

74
00:04:01,000 --> 00:04:04,000
અને તેથી વર્ગો અંદર વસ્તુઓ પ્રાવૃત દ્વારા આ ખરેખર તરફ દોરી જાય છે

75
00:04:04,000 --> 00:04:08,000
વધુ સારું કોડ ડિઝાઇન, અને આ વધારાના કેટલાક લક્ષણો સાથે શક્ય છે

76
00:04:08,000 --> 00:04:11,000
ઉદ્દેશ C-છે.

77
00:04:11,000 --> 00:04:15,000
Forewarning, ઉદ્દેશ C-માટે સિન્ટેક્ષ કેળા છે.

78
00:04:15,000 --> 00:04:19,000
તે કશું અમે પહેલા જોયેલા જેવું છે,

79
00:04:19,000 --> 00:04:22,000
તેથી તે શીખવા વળાંક માટે વપરાય રહ્યું એક થોડો છે

80
00:04:22,000 --> 00:04:24,000
શું હેક આ અર્થ છે?

81
00:04:24,000 --> 00:04:27,000
પરંતુ એક વાર તમે ભૂતકાળમાં વિચાર પ્રારંભિક શિક્ષણ વળાંક છે કે તે ખરેખર, ખરેખર સરળ છે

82
00:04:27,000 --> 00:04:29,000
માટે એપ્લિકેશન્સ લખવાનું શરૂ કરો.

83
00:04:29,000 --> 00:04:33,000
>> એક વર્ગ જાહેર, અહીં કહેવું મારા વર્ગ છે તે હાજર હોય,,

84
00:04:33,000 --> 00:04:35,000
અને કદાચ અહીં કેટલીક વસ્તુઓ છે કે જે હું પાછળથી વ્યાખ્યાયિત જાઉં છું છે,

85
00:04:35,000 --> 00:04:38,000
હું @ ઈન્ટરફેસ કહેવું જાઉં છું.

86
00:04:38,000 --> 00:04:41,000
હું @ ઈન્ટરફેસ કહેવું જાઉં છું. હું મારી વર્ગ એક નામ આપો જાઉં છું.

87
00:04:41,000 --> 00:04:43,000
અને પછી પાછળથી બીજે ક્યાંક હું @ ઓવરને કહેવું જાઉં છું,

88
00:04:43,000 --> 00:04:46,000
તે @ ઈન્ટરફેસ અને તે @ ઓવરને વચ્ચે બધું અને

89
00:04:46,000 --> 00:04:48,000
છે મારા વર્ગ હશે.

90
00:04:48,000 --> 00:04:51,000
કે પ્રયત્ન શું અમારી ક. ફાઈલોની અંદર જાય છે.

91
00:04:51,000 --> 00:04:55,000
જેમ સી અમારા ક. ફાઈલો મૂળભૂત અહીં જણાવ્યું હતું કે, કેટલીક બાબતો છે જે અસ્તિત્વમાં હોય છે.

92
00:04:55,000 --> 00:04:57,000
હું કરવાથી તમને જણાવું છું કે તેઓ શું હજુ સુધી કરવા માટે,

93
00:04:57,000 --> 00:04:59,000
પરંતુ કમ્પાઇલર ખબર પડી કે તેઓ અસ્તિત્વ જરૂર છે.

94
00:04:59,000 --> 00:05:04,000
બાદમાં અંદરના અમારા મી. ની ફાઈલો કારણ કે ઉદ્દેશ C-માટે મીટર

95
00:05:04,000 --> 00:05:08,000
તો અમે ખરેખર જ્યાં વ્યાખ્યા આ વર્ગો શું રહ્યા છીએ.

96
00:05:08,000 --> 00:05:11,000
અમારા સી. ફાઈલો જેમ જ, અમે વિધેયો માટે અમલીકરણ પાડવામાં આવેલ છે.

97
00:05:11,000 --> 00:05:15,000
ઇનસાઇડ અમારી ફાઈલ એમ. આપણે અહીં કહી રહ્યા છીએ છે બધા વિધેયોને શું

98
00:05:15,000 --> 00:05:18,000
મારું વર્ગ શું તેઓ તમામ કરવા ની અંદર.

99
00:05:18,000 --> 00:05:22,000
અને છેલ્લે, અંદર સ્ટ્રક્ટ આપણે અંદર તે સર્પાકાર કૌંસ કહેવા શકે

100
00:05:22,000 --> 00:05:25,000
પૂર્ણાંક n અથવા નોડ * આગામી,

101
00:05:25,000 --> 00:05:28,000
અને ઉદ્દેશ C-માં અમે કીવર્ડ @ મિલકત વાપરવા જઈ રહ્યાં છો,

102
00:05:28,000 --> 00:05:31,000
અને આ છે શું ગુણધર્મો વ્યાખ્યાયિત ચાલી રહ્યું છે,

103
00:05:31,000 --> 00:05:36,000
અથવા બિન વિધેયો કે મારા વર્ગો એક ભાગ છે.

104
00:05:36,000 --> 00:05:40,000
>> ઉદ્દેશ C-કાર્યો કૉલ પણ કેળા.

105
00:05:40,000 --> 00:05:43,000
જ્યારે અમે સી કાર્યો જાહેર અમે પૂર્ણાંક foo કંઈક કહ્યું હતું

106
00:05:43,000 --> 00:05:46,000
અને કૌંસ ઓપન અને પછી તેને દલીલો યાદી આપી હતી.

107
00:05:46,000 --> 00:05:51,000
આ એ છે જે પદ્ધતિઓ અથવા કાર્યો જાહેર ઉદ્દેશ C-જેમ દેખાય છે.

108
00:05:51,000 --> 00:05:54,000
જો હું કોઇ કાર્ય અથવા પદ્ધતિ જાહેર કરવા માંગો છો

109
00:05:54,000 --> 00:05:58,000
જ્યાં હું પદ્ધતિ કહી રહ્યો છું ખરેખર માત્ર એક કાર્ય છે કે જે વર્ગ સભ્ય છે છે,

110
00:05:58,000 --> 00:06:01,000
વિનિમયક્ષમ પ્રકારની છે, પરંતુ ખરેખર નથી તેથી,

111
00:06:01,000 --> 00:06:03,000
જેથી અંદર મારા પદ્ધતિ મને નવી પદ્ધતિ બનાવવા માંગો છો.

112
00:06:03,000 --> 00:06:06,000
તે કશું પરત ચાલી રહ્યું છે, તેથી તેને રદબાતલ પ્રકાર ની જ હશે.

113
00:06:06,000 --> 00:06:08,000
આ મારું કાર્ય પરત પ્રકાર છે.

114
00:06:08,000 --> 00:06:11,000
હવે અમે parens અહીં છે કારણ કે હું નથી જાણતો.

115
00:06:11,000 --> 00:06:14,000
આગામી મારા કાર્ય નું નામ હોવું રહ્યું છે,

116
00:06:14,000 --> 00:06:17,000
અને પછી છેવટે અમે અમે સી હતી જેમ જ અર્ધવિરામ છે

117
00:06:17,000 --> 00:06:19,000
નવા અહીં શું આ અહીં વ્યક્તિની છે.

118
00:06:19,000 --> 00:06:22,000
આ ભાગીદારી તૂટી ખરેખર જરૂરી છે, અને આ કહે છે કે

119
00:06:22,000 --> 00:06:26,000
આ અહીં પદ્ધતિ વર્ગ ઉદાહરણ કહેવામાં હોવું જ જોઈએ.

120
00:06:26,000 --> 00:06:29,000
>> પછી અમે અમારી સ્ટ્ર્ક્ટ્સ જાહેર અમે કદાચ કંઈક જેવા જણાવ્યું

121
00:06:29,000 --> 00:06:32,000
સ્ટ્રક્ટ નોડ n એ, અને ખરેખર બનાવનાર કે

122
00:06:32,000 --> 00:06:35,000
અથવા એક તે સ્ટ્ર્ક્ટ્સ ઓફ instantiated કે જેથી હું ખરેખર કામ શરૂ કરી શકે છે

123
00:06:35,000 --> 00:06:38,000
તે અંદર સાથે, તેથી આ આડંબર અર્થ એ છે કે અમે હોય

124
00:06:38,000 --> 00:06:41,000
વર્ગ instantiate માત્ર અમે instantiated જેવા કે સ્ટ્રક્ટ

125
00:06:41,000 --> 00:06:43,000
પહેલાં અમે તેના પર આ પદ્ધતિ કહી શકો છો.

126
00:06:43,000 --> 00:06:46,000
જો હું મારી પદ્ધતિઓ દલીલો ઉમેરીને પ્રારંભ કરવા માગો છો

127
00:06:46,000 --> 00:06:48,000
તે હજુ પણ વધુ કેળા નોંધાયો નહીં.

128
00:06:48,000 --> 00:06:50,000
અહીં મારા પદ્ધતિ નામ છે.

129
00:06:50,000 --> 00:06:53,000
પછી હું પડેલ હોય જાઉં છું, અને આ કોલોન પછી તે અહીં કહે કેટલાક દલીલો આવે છે.

130
00:06:53,000 --> 00:06:56,000
આ પદ્ધતિ એક દલીલ લે છે.

131
00:06:56,000 --> 00:06:59,000
તેની દલીલ પ્રકાર પૂર્ણાંક છે, અને તે દલીલ નામ છે

132
00:06:59,000 --> 00:07:03,000
અથવા ચલ કે હું પદ્ધતિ ની અંદર ની મદદથી શરૂ જાઉં છું હું કહેવામાં આવે છે.

133
00:07:03,000 --> 00:07:05,000
ફરીથી, આ પદ્ધતિ છે. તે એક દલીલ લે છે.

134
00:07:05,000 --> 00:07:10,000
>> જો તમે વધુ દલીલો ઉમેરીને પ્રારંભ કરવા માગો છો તે વધુ કેળા નોંધાયો નહીં

135
00:07:10,000 --> 00:07:13,000
કે અમે આ કોલોન કે અહીં કહે દલીલો મારા યાદી આવે છે.

136
00:07:13,000 --> 00:07:15,000
આ પ્રથમ દલીલ એ પૂર્ણાંક છે.

137
00:07:15,000 --> 00:07:17,000
હવે, આ બીજી દલીલ રસપ્રદ છે.

138
00:07:17,000 --> 00:07:20,000
આ ચલ કે હું અંદર મારા કાર્ય ઉપયોગ કરી જાઉં છું

139
00:07:20,000 --> 00:07:23,000
છે એફ કહેવાય છે, જેથી અંદર હું મારા કાર્ય કહેવા શકે

140
00:07:23,000 --> 00:07:25,000
એફ + 1 = અથવા કંઈક.

141
00:07:25,000 --> 00:07:30,000
આ અહીં વસ્તુ મૂળભૂત છે કે દલીલ અથવા પરિમાણ માટે કી છે.

142
00:07:30,000 --> 00:07:34,000
જેમ અમે કી કિંમત જોડીઓને હતી અને JSON અથવા સાહચર્યાત્મક એરે કંઈક

143
00:07:34,000 --> 00:07:37,000
ઉદ્દેશ C-કરવા માટે કહે છે, ઠીક નિર્ણય કર્યો હતો, એ જ છે કે તે ખરેખર સ્પષ્ટ છે

144
00:07:37,000 --> 00:07:39,000
જ્યારે તમે પદ્ધતિ આ બધા પરિમાણો શું છે કૉલ

145
00:07:39,000 --> 00:07:41,000
હું ખરેખર તેમને બધા નામ જાઉં છું.

146
00:07:41,000 --> 00:07:45,000
જ્યારે તમે કૉલ પદ્ધતિ, તમે ખરેખર andFloat કહેવું પડશે,

147
00:07:45,000 --> 00:07:47,000
અને પછી તમે તેને પસાર સાઇન પડશે

148
00:07:47,000 --> 00:07:50,000
>> રસપ્રદ રીતે, આ એક નામ આપવામાં આવ્યું નથી, પરંતુ તે અન્ય પરિમાણો બધા છે,

149
00:07:50,000 --> 00:07:53,000
તેથી જો આપણે એક 3 જી દલીલ હતી હું andFloat કહેવું શકે

150
00:07:53,000 --> 00:07:56,000
અને અન્ય ફ્લોટ અને તેથી.

151
00:07:56,000 --> 00:08:01,000
જ્યારે હું આ પદ્ધતિઓ કહી તે અભ્યાસક્રમ કેળા છે,

152
00:08:01,000 --> 00:08:04,000
તેથી જો હું પદાર્થ હોય છે, અને હું foo કહેવાય પદ્ધતિ વ્યાખ્યાયિત,

153
00:08:04,000 --> 00:08:09,000
અને હું તેને કૉલ બદલે foo ઓપન / બંધ parens કહેતા માંગો છો

154
00:08:09,000 --> 00:08:11,000
હું એક કૌંસ ખોલવા જઈ રહ્યો છું.

155
00:08:11,000 --> 00:08:13,000
અહીં મારા પદ્ધતિના નામ છે.

156
00:08:13,000 --> 00:08:17,000
હું કૌંસ બંધ જાઉં છું, અને આ પદાર્થ હું તેના પર કૉલ છું છે.

157
00:08:17,000 --> 00:08:20,000
યાદ રાખો, આ બધી જ પદ્ધતિઓનો વર્ગો માં હાજર

158
00:08:20,000 --> 00:08:23,000
કારણ કે તેમને વર્ગો ની અંદર વ્યાખ્યાયિત પદ્ધતિઓ હોઈ શકે છે.

159
00:08:23,000 --> 00:08:26,000
>> અહીં હું આપખુદ કેટલાક વર્ગ એક પદાર્થ બનાવ્યું છે,

160
00:08:26,000 --> 00:08:28,000
અને આ જે માટે વાક્યરચના છે.

161
00:08:28,000 --> 00:08:31,000
ત્યાં એક પદાર્થ બનાવવા માટે પગલાંઓ 2 છે.

162
00:08:31,000 --> 00:08:34,000
પ્રથમ પગલું કહે હું જગ્યા ફાળવી માંગો છો.

163
00:08:34,000 --> 00:08:37,000
આ એક malloc ની સમકક્ષ છે. અમે malloc હવે કહેવું નથી.

164
00:08:37,000 --> 00:08:42,000
અમે મીટર ગઇ, તે alloc કર્યો હતો, અને એમ. સાથે સી. લીધું.

165
00:08:42,000 --> 00:08:47,000
અમે alloc કંઈક કર્યા પછી અમે પછી તે પ્રારંભ કરવાની જરૂર છે.

166
00:08:47,000 --> 00:08:49,000
મૂળભૂત રીતે જ્યારે તમે વસ્તુઓ બનાવવા માટે તમે કેટલાક તર્ક હોય છે શકો છો

167
00:08:49,000 --> 00:08:53,000
કે ચલાવે છે જ્યારે તેઓ બનાવનાર કરી રહ્યાં છો, જેથી તમે કેટલાક મૂળભૂત કિંમતો પસાર કરી શકો છો

168
00:08:53,000 --> 00:08:57,000
અથવા તે કંઈક, અને તેથી આ init પદ્ધતિ છે જે વાસ્તવમાં પદાર્થ બનાવે છે.

169
00:08:57,000 --> 00:08:59,000
અમે પ્રથમ જગ્યા ફાળવી, જેમ આપણે સી હતી,

170
00:08:59,000 --> 00:09:04,000
અને પછી અમે તેને આરંભ કરવા માટે, જે કરવું અથવા સંપૂર્ણ ઘણો શકે નહિં.

171
00:09:04,000 --> 00:09:07,000
ત્યાર બાદ અમે એક ઑબ્જેક્ટ ઓ આ વસ્તુ પરત કરી રહ્યાં છો.

172
00:09:07,000 --> 00:09:09,000
ત્યાં એક તારો અહીં છે કારણ કે આ ટેકનિકલી નિર્દેશક છે,

173
00:09:09,000 --> 00:09:12,000
પરંતુ, ચિંતા ન પોઇંટરો કે ઉદ્દેશ C-મોટો સોદો કંઈ પણ નથી.

174
00:09:12,000 --> 00:09:15,000
>> હવે અમે આ NSObject કહેવાતા વર્ગ instantiated કરી લીધી છે,

175
00:09:15,000 --> 00:09:19,000
અને આ માત્ર એક રેન્ડમ વર્ગ કે એપલે છે.

176
00:09:19,000 --> 00:09:22,000
અમે આ instantiated કર્યા છે, અને હવે હું આ વર્ગ એક ઉદાહરણ છે

177
00:09:22,000 --> 00:09:25,000
આ ઑબ્જેક્ટ ઓ માં, કે જેથી અર્થ એ થાય કે જો હું વ્યાખ્યાયિત

178
00:09:25,000 --> 00:09:29,000
આ પદ્ધતિઓ હું તેમને આ જેવા કહી શકે છે.

179
00:09:29,000 --> 00:09:31,000
તેવી જ રીતે, જો હું એક દલીલ સાથે પદ્ધતિ કૉલ માગે છે

180
00:09:31,000 --> 00:09:34,000
તેથી આ બાર પદ્ધતિ છે, કે જે એક દલીલ લે છે,

181
00:09:34,000 --> 00:09:38,000
અને અહીં baz છે: qux પદ્ધતિ છે, જેથી આ 2 દલીલો લે છે.

182
00:09:38,000 --> 00:09:44,000
આ પદાર્થ ઓ પર એક કાર્ય કૉલ કરે છે.

183
00:09:44,000 --> 00:09:46,000
અર્થમાં બનાવીએ?

184
00:09:46,000 --> 00:09:50,000
વાક્યરચના અર્થમાં બનાવવા જોઇએ, પરંતુ તમારે પ્રકારની તે વપરાય છે.

185
00:09:50,000 --> 00:09:54,000
>> ઠીક છે, ચાલો થોડી વસ્તુઓ છે કે જે ઉદ્દેશ C-માં સમાયેલ છે તે વિશે વાત

186
00:09:54,000 --> 00:09:56,000
તે જરૂરી સી માં બનાવવામાં આવ્યા હતા

187
00:09:56,000 --> 00:09:59,000
સી અમે પ્રકારની આ મૂર્ખ અક્ષર એરે તરીકે શબ્દમાળાઓ સાથે કામ કર્યું હતું,

188
00:09:59,000 --> 00:10:01,000
અને તે ખરેખર હેરાન થઈ જાય છે.

189
00:10:01,000 --> 00:10:04,000
ઉદ્દેશ C-બધા આપણા માટે માં બાંધવામાં તે ધરાવે છે, અને તેને બનેલ છે

190
00:10:04,000 --> 00:10:06,000
આ NSString કહેવાતા વર્ગ મદદથી.

191
00:10:06,000 --> 00:10:10,000
જ્યારે હું એક NSString અમે વધુ arcane વાક્યરચના છે બનાવવા માંગો છો.

192
00:10:10,000 --> 00:10:15,000
તેના બદલે "cs50" અમે @ "cs50" કહેવું કહેતા કરતાં

193
00:10:15,000 --> 00:10:17,000
અને આ માત્ર ઉદ્દેશ C-માં શબ્દમાળાઓ જાહેર માટે વાક્યરચના છે.

194
00:10:17,000 --> 00:10:21,000
આ અત્યંત સરળ છે ભૂલી જાઓ, જેથી નથી.

195
00:10:21,000 --> 00:10:24,000
હવે એક વાર હું આ છે, આ એક સ્ટ્રિંગ છે, પરંતુ નોટિસ

196
00:10:24,000 --> 00:10:26,000
તે ખરેખર એક માત્ર ઉદ્દેશ છે.

197
00:10:26,000 --> 00:10:30,000
મેં કહ્યું NSString, જેનો અર્થ છે મને વર્ગ instantiated

198
00:10:30,000 --> 00:10:32,000
NSString છે, કે જે બીજા કોઈને મારા માટે લખ્યું કહેવાય છે,

199
00:10:32,000 --> 00:10:35,000
અને તેઓ ખૂબ સરસ હતી, અને તેથી હવે

200
00:10:35,000 --> 00:10:37,000
હું તેના પર પદ્ધતિઓ કૉલ શરૂ કરી શકો છો.

201
00:10:37,000 --> 00:10:40,000
જો હું આ પદાર્થ ઓ પર પદ્ધતિ લંબાઈ કૉલ

202
00:10:40,000 --> 00:10:43,000
તે મને શબ્દમાળા લંબાઈ પાછા જવાનું છે.

203
00:10:43,000 --> 00:10:45,000
આ સી માં strlen જેમ જ છે

204
00:10:45,000 --> 00:10:47,000
આ 4 પરત ફરશે.

205
00:10:47,000 --> 00:10:51,000
>> એ જ રીતે, અન્ય પદ્ધતિ હું વિશે કાળજી શકો છો આ characterAtIndex છે.

206
00:10:51,000 --> 00:10:54,000
આ એક પદ્ધતિ છે કે જે આ શબ્દમાળા ઓ પર કહે છે

207
00:10:54,000 --> 00:10:57,000
હું તમને zeroth અક્ષર વિચાર કરવા માંગો છો,

208
00:10:57,000 --> 00:10:59,000
અને તેથી આ મારા અક્ષર કો પરત ફરશે,

209
00:10:59,000 --> 00:11:02,000
અને ત્યાં આ પદ્ધતિઓનો સંપૂર્ણ વધુ ટોળું કે જે તમે ખરેખર સરળતાથી Google કરી શકો છો.

210
00:11:02,000 --> 00:11:07,000
એપલના દસ્તાવેજીકરણ મહાન છે, અને અમે થોડી કે પર એક નજર પડશે.

211
00:11:07,000 --> 00:11:09,000
તે શબ્દમાળાઓ છે.

212
00:11:09,000 --> 00:11:11,000
અમે પણ ચલ કદ એરે નિહિત છે

213
00:11:11,000 --> 00:11:13,000
સી યાદ રાખો જ્યારે અમે ઝાકઝમાળ જાહેર

214
00:11:13,000 --> 00:11:16,000
અમે કહી તમે 5 તત્વો, વાર્તા ઓવરને પડી.

215
00:11:16,000 --> 00:11:18,000
જ્યારે અમે જાવાસ્ક્રિપ્ટ અને PHP માટે મળ્યું અમે શરૂ કરી શકે છે

216
00:11:18,000 --> 00:11:20,000
એલિમેન્ટ ઉમેરતાં અથવા તત્વો ખસેડવાની જેવી વસ્તુઓ કરવાનું.

217
00:11:20,000 --> 00:11:22,000
અમે ઉદ્દેશ C-એ જ કરી શકો છો.

218
00:11:22,000 --> 00:11:26,000
બદલે સામાન્ય સી રીતે એક એરે બનાવો

219
00:11:26,000 --> 00:11:30,000
અમે ફરીથી બીજા NSMutableArray કહેવાતા વર્ગ હોય છે.

220
00:11:30,000 --> 00:11:33,000
ત્યાં પણ NSArray છે,

221
00:11:33,000 --> 00:11:35,000
અને આ માટે મૂળભૂત રીતે કેટલાક એરે પ્રાવૃત રહ્યું છે.

222
00:11:35,000 --> 00:11:38,000
આ કહે છે કે પ્રથમ વસ્તુ હું કરવા માંગો છો છે હું ફાળવી માંગો છો

223
00:11:38,000 --> 00:11:41,000
નવી એરે માટે જગ્યા છે, અને પછી હું તેને ફાળવો

224
00:11:41,000 --> 00:11:43,000
હું પછી તે પ્રારંભ કરવાની જરૂર છે.

225
00:11:43,000 --> 00:11:45,000
ફરીથી, માત્ર આ 2 પદ્ધતિઓ કહે છે.

226
00:11:45,000 --> 00:11:48,000
હવે આ પદાર્થ કે અંદર એનો અર્થ એ થાય

227
00:11:48,000 --> 00:11:50,000
હું એક ખાલી એરે ત્યાં બેસવું છે.

228
00:11:50,000 --> 00:11:54,000
જો હું આ એરે કંઈક ઉમેરવા માંગો છો, હું addObject પદ્ધતિ કહી શકો છો.

229
00:11:54,000 --> 00:11:59,000
હું એરે માટે એક ઑબ્જેક્ટ ઍડ કરવા માંગો છો, અને હું CS50 શબ્દમાળા ઍડ કરવા માંગો છો.

230
00:11:59,000 --> 00:12:02,000
જો હું તેનાથી દૂર કે હું કહી શકો છો ઇચ્છતા હું કરવા માંગો છો

231
00:12:02,000 --> 00:12:09,000
એરે પર પ્રથમ સ્થાને ઓબ્જેક્ટ દૂર કરો અથવા વિરોધી હતા.

232
00:12:09,000 --> 00:12:11,000
>> અર્થમાં બનાવીએ?

233
00:12:11,000 --> 00:12:14,000
ઠીક છે, તમે પ્રકારની કરો આ ચોરસ કૌંસ વસ્તુ માટે થાય છે.

234
00:12:14,000 --> 00:12:18,000
જો કે, એપલના લાઈબ્રેરીઓ ઘણો ની અંદર તમે આ એનએસ જોશો.

235
00:12:18,000 --> 00:12:21,000
આ એનએસ વાસ્તવમાં આગામી પગલું છે, જે એક સ્ટીવ જોબ્સ પ્રથમ કંપનીઓમાંની એક હતી માટે વપરાય છે,

236
00:12:21,000 --> 00:12:24,000
અને જ્યાં તેમણે ખરેખર કોડ ઘણો લખવાનું શરૂ કર્યું

237
00:12:24,000 --> 00:12:27,000
મેક ઓએસ એક્સ અને અન્ય સામગ્રી બધા માટે આધાર પ્રકારની તરીકે,

238
00:12:27,000 --> 00:12:32,000
અને તેથી આ એનએસ છે અને આ સરસ વારસો પ્રકારની એક અગાઉના કંપનીઓ માટે પોકાર

239
00:12:32,000 --> 00:12:34,000
પાછા જ્યારે એપલે પ્રથમ બહાર શરૂ કરવામાં આવી હતી.

240
00:12:34,000 --> 00:12:36,000
તે દરેક જગ્યાએ છે.

241
00:12:36,000 --> 00:12:41,000
ચાલો, એક વધુ સાકલ્યવાદી ઉદાહરણ ઉદ્દેશ C-પર એક નજર.

242
00:12:41,000 --> 00:12:44,000
અહીં હું XCode ની અંદર છું.

243
00:12:44,000 --> 00:12:47,000
અહીં વિચાર, હું પ્રથમ એપ સ્ટોર પરથી XCode ડાઉનલોડ

244
00:12:47,000 --> 00:12:50,000
તે ખોલી છે, અને તે પછી મેં ગયા ફાઈલ કરવા માટે અહીં,

245
00:12:50,000 --> 00:12:54,000
અહીં ઉપર નવી અને પછી પ્રોજેક્ટ.

246
00:12:54,000 --> 00:12:57,000
પછી હું કે હું આ બધા વિકલ્પો હું શું બનાવવા માંગો તો

247
00:12:57,000 --> 00:12:59,000
અને તેથી અમે આ વિકલ્પો પર એક નજર પાછળથી લેવા પડશે,

248
00:12:59,000 --> 00:13:03,000
પરંતુ આ ઉદાહરણ માટે જ છે, કારણ કે આપણે ખરેખર એક એપ્લિકેશન હજુ સુધી નથી જઈ રહ્યાં છો,

249
00:13:03,000 --> 00:13:06,000
હું નીચે અહીં આવ્યા, અને હું આદેશ વાક્ય સાધન જણાવ્યું હતું કે,

250
00:13:06,000 --> 00:13:09,000
અને આ એપ્લિકેશન કે હું આદેશ વાક્ય પર ચલાવવા શકે છે

251
00:13:09,000 --> 00:13:12,000
જેમ અમે સી કરવામાં ચાલી કર્યા છે

252
00:13:12,000 --> 00:13:16,000
કે કેવી રીતે હું આ પ્રોજેક્ટ છે, અને તેથી હવે હું અહીં છું,

253
00:13:16,000 --> 00:13:20,000
તેથી આ ફાઇલ પ્રથમ દેખાવ દો, અને આ ખૂબ પરિચિત દેખાવી જોઈએ.

254
00:13:20,000 --> 00:13:24,000
હું પૂર્ણાંક નામ છે. ત્યાં મારા મિત્ર argc, મારા અન્ય સાથી argv છે.

255
00:13:24,000 --> 00:13:30,000
અને તેથી અમે જોઈ શકે છે કે આ મારી પ્રથમ અરજી ઉદ્દેશ C-માટે પ્રવેશ બિંદુ છે.

256
00:13:30,000 --> 00:13:32,000
અહીં અમે હવે માટે આ અવગણી શકો છો.

257
00:13:32,000 --> 00:13:35,000
આ મૂળભૂત અમુક મેમરી વ્યવસ્થાપન સામગ્રી છે કે તમે ખરેખર નહીં કરે

258
00:13:35,000 --> 00:13:37,000
ક્યારેય ચિંતા કરવાની જરૂર નથી.

259
00:13:37,000 --> 00:13:39,000
>> ચાલો આ પ્રથમ બ્લોક પર અહીં જુઓ.

260
00:13:39,000 --> 00:13:46,000
આ પ્રથમ લીટી, જો હું કહું છું વિદ્યાર્થી * એલિસ = [[વિદ્યાર્થી alloc આરંભ]] શું છે કે આમ?

261
00:13:46,000 --> 00:13:50,000
આ પ્રથમ અહીં વિદ્યાર્થી, આ કદાચ એક એવો વર્ગ છે.

262
00:13:50,000 --> 00:13:54,000
આ એક વર્ગ છે કે એપલ લખ્યું નથી, પરંતુ તે એક વર્ગ છે કે હું લખી હતી.

263
00:13:54,000 --> 00:13:57,000
પ્રથમ વાત હું કરવા માંગો છો છે મને નવા વિદ્યાર્થી માટે જગ્યા ફાળવી માંગો છો,

264
00:13:57,000 --> 00:14:00,000
અને પછી હું તેને પ્રારંભ કરવા માંગો છો, તેથી આ મને આપે પાછા

265
00:14:00,000 --> 00:14:05,000
આ નવી વિદ્યાર્થી પદાર્થ છે, અને હું એલિસ કહેવાય ચલ આ સ્ટોર છું.

266
00:14:05,000 --> 00:14:07,000
જ્યાં તે વર્ગના માંથી આવ્યા હતા?

267
00:14:07,000 --> 00:14:12,000
વેલ, ડાબી બાજુ પર અહીં પર આ મારા પ્રોજેક્ટ ની અંદર વિવિધ બધી ફાઈલોને છે.

268
00:14:12,000 --> 00:14:16,000
અમે અહીં જોવા હું Student.h અને Student.m હોઈ શકે છે.

269
00:14:16,000 --> 00:14:20,000
આ ક. ફાઈલ યાદ, છે જ્યાં હું બધું જાહેર

270
00:14:20,000 --> 00:14:22,000
કે વર્ગ અંદર અસ્તિત્વ ધરાવતી નથી.

271
00:14:22,000 --> 00:14:25,000
>> ચાલો કે પર એક નજર.

272
00:14:25,000 --> 00:14:29,000
બધા હક, અહીં આપણે આ @ ઈન્ટરફેસ છે, અને આ કહે છે કે અહીં આવે છે

273
00:14:29,000 --> 00:14:33,000
બધું મારું વર્ગ અંદર અસ્તિત્વમાં કરશે ઘોષણાઓ.

274
00:14:33,000 --> 00:14:36,000
પછી હું પડેલ છે. પછી હું આ NSObject વસ્તુ છે.

275
00:14:36,000 --> 00:14:40,000
આ કોલોન કે વારસો બીટ અમે થોડો અગાઉ ચર્ચા કરવામાં આવી હતી નોંધે છે.

276
00:14:40,000 --> 00:14:43,000
આ કહે છે બધું એક NSObject કરી શકો છો

277
00:14:43,000 --> 00:14:46,000
જ્યાં NSObject આ કોઈ બીજા દ્વારા પરચૂરણ વર્ગ છે,

278
00:14:46,000 --> 00:14:50,000
બધું આ NSObject કરી શકે છે હું કે શું કરવાનો પ્રયત્ન કરવા માંગો છો.

279
00:14:50,000 --> 00:14:54,000
કહેતા દ્વારા: NSObject કે અર્થ એ થાય કે હું મૂળભૂત

280
00:14:54,000 --> 00:14:58,000
અન્ય વર્ગ ના બધા વિધેયો વારસાગત.

281
00:14:58,000 --> 00:15:02,000
કે ખરેખર મને વિવિધ પદ્ધતિઓ અને ગુણધર્મો કે હું ઉપયોગ કરી શકો છો સંપૂર્ણ જથ્થો આપ્યો હતો.

282
00:15:02,000 --> 00:15:05,000
નીચે અહીં હું 2 ગુણધર્મો બનાવી રહ્યો છું.

283
00:15:05,000 --> 00:15:08,000
કે મારા વિદ્યાર્થી અર્થ થાય છે, જો કે આ એક સ્ટ્રક્ટ હતા, આ 2 વસ્તુઓ હશે

284
00:15:08,000 --> 00:15:11,000
મારા સ્ટ્રક્ટ ની અંદર, જેથી દરેક વિદ્યાર્થી એક નામ ધરાવે છે

285
00:15:11,000 --> 00:15:14,000
કે એક સ્ટ્રિંગ છે, અને એક વિદ્યાર્થી પણ એક ગ્રેડ છે,

286
00:15:14,000 --> 00:15:17,000
જે પૂર્ણાંક છે.

287
00:15:17,000 --> 00:15:23,000
>> છેલ્લે, નીચે અહીં હું મારા વિદ્યાર્થી માટે એક પદ્ધતિ બનાવવા માટે જાઉં છું.

288
00:15:23,000 --> 00:15:26,000
હું મારા પદ્ધતિ કહેવાય છે, initWithName, અને તે એક દલીલ લે છે,

289
00:15:26,000 --> 00:15:31,000
અને તે દલીલ એક સ્ટ્રિંગ છે, અને હું કહેવાય તેને નામ.

290
00:15:31,000 --> 00:15:35,000
હવે આપણે અમે કેવી રીતે વાસ્તવમાં આ વર્ગ અમલમાં જુઓ.

291
00:15:35,000 --> 00:15:38,000
અહીં, હવે હું મારા એમ. ફાઈલની અંદર છું,

292
00:15:38,000 --> 00:15:40,000
અમલીકરણ માટે મીટર, હું માનું.

293
00:15:40,000 --> 00:15:44,000
હું મારા અમલીકરણ છે, મારા અંત, અને અહીં છે જ્યાં હું ખરેખર વ્યાખ્યાયિત છું

294
00:15:44,000 --> 00:15:47,000
initWithName શું કરે છે.

295
00:15:47,000 --> 00:15:50,000
હું initWithName, મારા પરિમાણ એ નામ, અને પછી આ છે

296
00:15:50,000 --> 00:15:53,000
છે જ્યાં હું ખરેખર એક વિદ્યાર્થી બનાવવા છું,

297
00:15:53,000 --> 00:15:56,000
અને તેથી આ થોડો છુપાયેલું છે, પરંતુ આ boilerplate પ્રકારની છે

298
00:15:56,000 --> 00:15:58,000
તમે તમારા બાંધનારો શામેલ કરવા માંગો છો.

299
00:15:58,000 --> 00:16:02,000
આ આરંભ અહીં કાર્ય, initWithName, બાંધનાર એક પ્રકાર છે.

300
00:16:02,000 --> 00:16:05,000
તમે મૂળભૂત રીતે નવી વિદ્યાર્થી પદાર્થ બાંધવા કરી રહ્યાં છો

301
00:16:05,000 --> 00:16:07,000
અને કદાચ તે અંદર અમુક માહિતી મોકલી.

302
00:16:07,000 --> 00:16:11,000
પ્રથમ વાત હું કરવા માંગો છો છે હું આ સુપર વસ્તુ પર init કૉલ કરવા માંગો છો.

303
00:16:11,000 --> 00:16:15,000
>> યાદ રાખો કે જ્યારે હું ક. ફાઈલમાં અહીં જણાવ્યું હતું કે,

304
00:16:15,000 --> 00:16:21,000
કે બધું એક NSObject એક વિદ્યાર્થી પણ ધરાવે છે.

305
00:16:21,000 --> 00:16:24,000
તેનો અર્થ એ કે જ્યારે હું એક વિદ્યાર્થી હું પણ જરૂર શું છે બનાવો

306
00:16:24,000 --> 00:16:28,000
ખાતરી કરો કે જે NSObject કે હું કે માહિતી બધી વારસામાં છું

307
00:16:28,000 --> 00:16:32,000
છે પણ યોગ્ય રીતે આરંભ.

308
00:16:32,000 --> 00:16:36,000
હું કહેવા જરૂર શું આ સુપર છે વાસ્તવમાં પિતૃ વર્ગ સંદર્ભ લો રહ્યું છે

309
00:16:36,000 --> 00:16:39,000
કે મને વારસામાં છું, જેથી હું તેની ખાતરી કરવા માટે હું પ્રારંભ કરવા માંગો છો

310
00:16:39,000 --> 00:16:43,000
બધું છે કે હું તેના પર આધાર રાખીને છું તે પહેલાં હું તેનો ઉપયોગ કરવાનો પ્રયાસ શરૂ કરો.

311
00:16:43,000 --> 00:16:46,000
પછી જો કે આરંભ સાચી રીતે આ કહેતા જેમ જ છે જો malloc

312
00:16:46,000 --> 00:16:50,000
નહોતી નલ પાછા નથી તો મને કેટલાક ગુણધર્મો સુયોજિત શરૂ કરી શકો છો.

313
00:16:50,000 --> 00:16:54,000
>> જાવાસ્ક્રીપ્ટ અને PHP માં અમે આ કીવર્ડ આ કહેવાય હતી,

314
00:16:54,000 --> 00:16:58,000
અને આ વર્ગ એ વર્તમાન ઉદાહરણ માટે ઓળખવામાં આવે છે.

315
00:16:58,000 --> 00:17:00,000
ઉદ્દેશ C-અમે આ સ્વ કૉલ કરો.

316
00:17:00,000 --> 00:17:04,000
જ્યારે હું self.name કહે છે કે અર્થ એ થાય કે પદાર્થ

317
00:17:04,000 --> 00:17:07,000
મેં હમણાં જ બનાવેલ છે જ્યારે હું જણાવ્યું હતું કે વિદ્યાર્થી alloc init,

318
00:17:07,000 --> 00:17:09,000
કે મને આપી ફરી એક ઑબ્જેક્ટ બનશે.

319
00:17:09,000 --> 00:17:12,000
તેનો અર્થ એ કે હું પદાર્થ નું નામ સુયોજિત કરવા માંગો છો

320
00:17:12,000 --> 00:17:15,000
ગમે મેં હમણાં સાઇન પસાર

321
00:17:15,000 --> 00:17:18,000
જસ્ટ સી માંગો, અમે આ કોઈ સાથે સભ્યો ઍક્સેસ કરવા માટે,

322
00:17:18,000 --> 00:17:21,000
જેથી self.name વિદ્યાર્થી પદાર્થ નું નામ કહે છે

323
00:17:21,000 --> 00:17:24,000
હવે પ્રયત્ન ગમે તમે હમણાં સાઇન પસાર થઈ રહ્યું છે

324
00:17:24,000 --> 00:17:28,000
અને તેથી છેવટે, હું તેને પાછા જેથી હું ખરેખર કંઈક પાછું મેળવી શકો છો.

325
00:17:28,000 --> 00:17:30,000
>> પ્રશ્નો?

326
00:17:30,000 --> 00:17:34,000
ઠીક છે, તેથી આ સ્વ = સુપર init,

327
00:17:34,000 --> 00:17:37,000
જો તમે સંપૂર્ણપણે વારસો સામગ્રી નથી સમજી નથી ચિંતા કરશો નહિ.

328
00:17:37,000 --> 00:17:40,000
જસ્ટ ખબર છે કે જો તમે ક્યારેય તમારા પોતાના આરંભ પદ્ધતિ બનાવવા માંગો છો કે માત્ર

329
00:17:40,000 --> 00:17:42,000
કે કરે છે, અને તમે જવા માટે પ્રયત્ન કરીશું.

330
00:17:42,000 --> 00:17:44,000
યાહ >> [વિદ્યાર્થી]. તો શું સ્વ સરેરાશ કરે છે?

331
00:17:44,000 --> 00:17:49,000
આનો અર્થ એ થાય કે જ્યારે અમે કંઈક આપણે હંમેશા ચકાસાયેલ જો તે નલ માટે સમાન હતી malloc,

332
00:17:49,000 --> 00:17:51,000
અને જો તે નલ હતી, તો પછી અમે બહાર નીકળ્યા.

333
00:17:51,000 --> 00:17:55,000
આ એક જ વસ્તુ છે, કારણ કે આ વળતર નલ જો, તો પછી અમે કદાચ seg ખામી માટે જઈ રહ્યાં છો

334
00:17:55,000 --> 00:17:57,000
જો અમે તેને ચાલાકી કરવાનો પ્રયાસ શરૂ કરો.

335
00:17:57,000 --> 00:18:01,000
તે અમારી વિદ્યાર્થી વર્ગ છે.

336
00:18:01,000 --> 00:18:03,000
તેનો અર્થ એ કે અમે બેમાંના એક માર્ગે અમારી વિદ્યાર્થીઓ પ્રારંભ કરી શકો છો.

337
00:18:03,000 --> 00:18:08,000
જો હું કહું છું વિદ્યાર્થી alloc init હું કે પદ્ધતિ નથી વાપરી કે હું હમણાં જ લખ્યું છું,

338
00:18:08,000 --> 00:18:11,000
અને તેના બદલે હું ફક્ત alice.name કહેવું કરી શકો છો,

339
00:18:11,000 --> 00:18:14,000
અને હવે હું મિલકત નામ સુયોજિત જાઉં છું.

340
00:18:14,000 --> 00:18:17,000
>> તેવી જ રીતે, જો હું initWithName પદ્ધતિ ઉપયોગ કરવા માંગો છો

341
00:18:17,000 --> 00:18:20,000
હું ફક્ત alloc કહેવું શકે છે, અને તે પછી બદલે આરંભ કહેતા

342
00:18:20,000 --> 00:18:24,000
હું પદ્ધતિ કે હું હમણાં જ બનાવેલ કૉલ જાઉં છું, અને હું બોબ પાસ જાઉં છું.

343
00:18:24,000 --> 00:18:30,000
આ બિંદુએ, આ ઑબ્જેક્ટ બોબ એક બોબ માટે સમાન નામ છે.

344
00:18:30,000 --> 00:18:35,000
ઠીક છે, નીચે અહીં હું કે NSMutableArray કે અમે અગાઉ જોયું હતું ઉપયોગ કરું છું.

345
00:18:35,000 --> 00:18:38,000
હું space.Then allocating છું હું એક નવા એરે પ્રારંભ છું.

346
00:18:38,000 --> 00:18:40,000
હું તેને માટે 2 વસ્તુઓ ઉમેરો જાઉં છું.

347
00:18:40,000 --> 00:18:43,000
આ એરે હવે વિદ્યાર્થી પદાર્થો ધરાવે છે.

348
00:18:43,000 --> 00:18:46,000
નોંધ કરો કે ક્યાંય હું કહેવા આ વિદ્યાર્થીઓ ઝાકઝમાળ છે નહોતી.

349
00:18:46,000 --> 00:18:48,000
હું જણાવ્યું હતું કે તે એક એરે સમયગાળો, છે.

350
00:18:48,000 --> 00:18:50,000
પછી હું મૂકી શકો છો તે અંદર ગમે કે હું માંગો છો.

351
00:18:50,000 --> 00:18:52,000
અહીં હું 2 પદાર્થો હોય છે.

352
00:18:52,000 --> 00:18:56,000
>> છેલ્લે, હું અન્ય પદાર્થ અહીં છે, આ ટીએફ.

353
00:18:56,000 --> 00:18:59,000
TF.h અહીં બોલ મૂળભૂત એ જ વસ્તુ.

354
00:18:59,000 --> 00:19:01,000
હું NSObject છે, અને જે રીતે દ્વારા વારસામાં છું,

355
00:19:01,000 --> 00:19:03,000
જ્યારે તમે વર્ગો બનાવવા આ બધા તમારા માટે કરવામાં આવે છે,

356
00:19:03,000 --> 00:19:06,000
ઈન્ટરફેસ boilerplate આ પ્રકારની.

357
00:19:06,000 --> 00:19:08,000
તે વિદ્યાર્થીઓ એક મિલકત ધરાવે છે.

358
00:19:08,000 --> 00:19:15,000
હું એક દંપતી પદ્ધતિઓ અહીં કે ખરેખર એક સંપૂર્ણ ઘણો નથી છે,

359
00:19:15,000 --> 00:19:18,000
અને તેથી તેનો અર્થ એ કે પછી હું આ ટીએફ પદાર્થ બનાવવા

360
00:19:18,000 --> 00:19:23,000
હું આ જેવા તેના પર આ પદ્ધતિ ગ્રેડ કૉલ કરી શકો છો.

361
00:19:23,000 --> 00:19:26,000
ઉદ્દેશ C-સિન્ટેક્સ પર કોઈપણ પ્રશ્નો પહેલાં અમે કેટલાક વધુ તરફ શરૂ

362
00:19:26,000 --> 00:19:30,000
રસપ્રદ એપ્લિકેશન્સ વિકાસ સામગ્રી?

363
00:19:30,000 --> 00:19:34,000
>> ઠીક છે, તેથી આપણે ખરેખર એક iPhone એપ્લિકેશન કરો.

364
00:19:34,000 --> 00:19:39,000
તમારા iPhone એપ્લિકેશન મુખ્ય વર્ગો કે તમે અંદર ઉપયોગ કરી શકશો દૃશ્ય નિયંત્રકો કહેવાય છે,

365
00:19:39,000 --> 00:19:42,000
અને એક દૃશ્ય નિયંત્રક મૂળભૂત એક સ્ક્રીન પ્રતિનિધિત્વ

366
00:19:42,000 --> 00:19:46,000
તમારી એપ્લિકેશન ની અંદર છે, તેથી જો હું સંગીત એપ્લિકેશન પર ઉદાહરણ તરીકે, છું,

367
00:19:46,000 --> 00:19:50,000
એક દૃશ્ય નિયંત્રક દેખાવ કે જેમાં હું મારા iPhone પર તમામ ગીતો જોવા પ્રતિનિધિત્વ કરી શકે છે.

368
00:19:50,000 --> 00:19:53,000
બીજો અભિપ્રાય નિયંત્રક જ્યારે હું એક ગીત પર ક્લિક કરો અને તેને રમવાની શરૂ થઈ શકે છે

369
00:19:53,000 --> 00:19:55,000
અથવા હું નીચે કલાકારો માં ડ્રિલિંગ છું.

370
00:19:55,000 --> 00:19:59,000
તે વિવિધ સ્ક્રીનો દરેક અલગ મત નિયંત્રક તરીકે રજૂ કરી શકે છે,

371
00:19:59,000 --> 00:20:04,000
અને એક દૃશ્ય નિયંત્રક ખરેખર માત્ર એક વર્ગ છે કે જે કહે છે કે કેવી રીતે આ સ્ક્રીન કામ કરે છે.

372
00:20:04,000 --> 00:20:07,000
એક દૃશ્ય નિયંત્રક ની અંદર વસ્તુઓ, અમે ગુણધર્મો નથી જઈ રહ્યાં છો,

373
00:20:07,000 --> 00:20:10,000
જેથી એક બટન જેવી વસ્તુઓ માટે અમારા દૃષ્ટિકોણ નિયંત્રક એક મિલકત હોઈ રહ્યું છે.

374
00:20:10,000 --> 00:20:13,000
>> અમે પણ પદ્ધતિઓ હોય છે જઈ રહ્યાં છો, અને આ મૂળભૂત છે ઘટના હેન્ડલર્સ.

375
00:20:13,000 --> 00:20:16,000
આ પદ્ધતિ કહે છે જ્યારે તમે આ બટન દબાવો

376
00:20:16,000 --> 00:20:19,000
હું કંઈક કરવા માંગો છો, અને છેલ્લે ફરીથી,

377
00:20:19,000 --> 00:20:24,000
અમે આ સ્વ કીવર્ડ ઉપયોગ કરવા માટે વર્તમાન હમણાં ઍક્સેસ રહ્યા છીએ.

378
00:20:24,000 --> 00:20:29,000
માટે iOS માં ઈન્ટરફેસો બીલ્ડ ખરેખર છે ખરેખર, ખરેખર સરળ છે.

379
00:20:29,000 --> 00:20:32,000
તેઓ આ સરસ ખેંચો અને છોડો ઈન્ટરફેસ બિલ્ડર કહેવાય ઈન્ટરફેસ છે,

380
00:20:32,000 --> 00:20:37,000
અને 2 કોર વિભાવનાઓ છે જે તમારા ઉદ્દેશ C-અપ ઈન્ટરફેસ બિલ્ડર માટે વાયર

381
00:20:37,000 --> 00:20:40,000
IBOutlet અને IBAction છે.

382
00:20:40,000 --> 00:20:44,000
એક IBOutlet ફક્ત કહે છે કે જો તમે મિલકત કે એક બટન છે ઘોષિત કર્યા,

383
00:20:44,000 --> 00:20:47,000
અને તમે તેને તમારા વાસ્તવિક UI માં કંઈક સુધી રોકી રાખવા માંગો,

384
00:20:47,000 --> 00:20:49,000
તમે કહો તે આઉટલેટ છે જઈ રહ્યાં છો.

385
00:20:49,000 --> 00:20:51,000
તેવી જ રીતે, જો તમે ઇવેન્ટ સંભાળનાર પ્રતિનિધિત્વ કરવા માંગો છો

386
00:20:51,000 --> 00:20:54,000
પછી તમે કહો તે ક્રિયા છે જઈ રહ્યાં છો.

387
00:20:54,000 --> 00:20:57,000
>> વાસ્તવમાં આ ગ્રાફિકલ રજૂઆત WIRE

388
00:20:57,000 --> 00:21:00,000
અને તમારો કોડ તે ખરેખર, ખરેખર સરળ છે.

389
00:21:00,000 --> 00:21:03,000
જો તમે IBOutlet જોડી કરવા માંગો છો, બધી તમારે કરવા છે કે તમે ક્લિક નિયંત્રિત,

390
00:21:03,000 --> 00:21:05,000
અને અમે આ ખરેખર ઝડપી ઉદાહરણ જોશો.

391
00:21:05,000 --> 00:21:07,000
તમે ક્લિક કરો નિયંત્રિત જ્યાં તે જુઓ કંટ્રોલર કહે છે.

392
00:21:07,000 --> 00:21:09,000
તમે ઈન્ટરફેસ માં ખેંચો જઈ રહ્યાં છો, ઊલટી, અથવા,

393
00:21:09,000 --> 00:21:13,000
જો તમે એક ઘટના સંભાળનાર રોકી રાખવા માંગો છો તો તમે ઈન્ટરફેસમાંથી ખેંચો જઈ રહ્યાં છો

394
00:21:13,000 --> 00:21:15,000
અન્ય દિશામાં હોય છે.

395
00:21:15,000 --> 00:21:20,000
ચાલો એક ખરેખર સરળ iOS ઉદાહરણ પર એક નજર.

396
00:21:20,000 --> 00:21:23,000
>> ચાલો એક નવો પ્રોજેક્ટ બનાવો.

397
00:21:23,000 --> 00:21:25,000
હું ઉપર અરજી કરવા માટે અહીં આવે જાઉં છું,

398
00:21:25,000 --> 00:21:28,000
અને હું એક દૃશ્ય અરજી ક્લિક કરો જાઉં છું.

399
00:21:28,000 --> 00:21:31,000
હું આગામી ક્લિક કરો જાઉં છું. હું મારા પ્રોજેક્ટ એક નામ આપો પડશે.

400
00:21:31,000 --> 00:21:33,000
હું તેને હેલો કહી શકશો.

401
00:21:33,000 --> 00:21:36,000
રસપ્રદ રીતે, એપલ ધારે છે કે તમે એક ઉત્પાદન બનાવી રહ્યાં છો

402
00:21:36,000 --> 00:21:38,000
જેથી તમે તેને વેચવા અને તેઓ પૈસા બનાવી શકો છો.

403
00:21:38,000 --> 00:21:41,000
નીચે અહીં હું કહે છે કે આ એક iPhone એપ્લિકેશન છે જાઉં છું.

404
00:21:41,000 --> 00:21:44,000
તમે એક આઇપેડ એપ્લિકેશન બનાવવા કરી શકો છો અથવા જો તમે એક તે એપ્લિકેશન્સ ઓફ બનાવવા માંગો છો

405
00:21:44,000 --> 00:21:47,000
કે બંને ઉપકરણો છે કે જે તમને પણ કરી શકો છો આધાર આપે છે.

406
00:21:47,000 --> 00:21:49,000
આ છે તમે શું તમારી checkmarks જેમ જોવા માંગો છો.

407
00:21:49,000 --> 00:21:51,000
>> તમે સ્ટોરીબોર્ડ્સ છે, જે પાછળથી જોશો વાપરવા માંગો,

408
00:21:51,000 --> 00:21:54,000
અને તમે ખરેખર આપોઆપ સંદર્ભ ગણતરીનો ઉપયોગ કરવા માંગો છો,

409
00:21:54,000 --> 00:21:58,000
જે સરસ લક્ષણ કે જે તમે malloc અને મફત કહેવું કર્યા અટકાવે છે.

410
00:21:58,000 --> 00:22:03,000
જ્યાં સુધી તમે malloc અને મફત કૉલ કરવા માંગો છો, હું આ ચકાસાયેલ છોડી દેશે.

411
00:22:03,000 --> 00:22:07,000
હું આગામી ક્લિક કરો, અને પડશે છેવટે, આ મને પૂછો રહ્યું છે જ્યાં હું તેને સેવ કરવા માંગો છો.

412
00:22:07,000 --> 00:22:14,000
હું બનાવવા દબાવો, અને પડશે અહીં અમે જાઓ.

413
00:22:14,000 --> 00:22:16,000
હું એક નવા પ્રોજેક્ટ બનાવી.

414
00:22:16,000 --> 00:22:19,000
ડાબી પર અહીં પર બધી ફાઈલો કે મારા પ્રોજેક્ટ ની અંદર છે,

415
00:22:19,000 --> 00:22:22,000
નોટિસ અને એ કે હું એક સમગ્ર જથ્થો મળી છે, અને તેણે પણ મેં કંઈપણ નથી.

416
00:22:22,000 --> 00:22:24,000
આઇઓએસ મહાન છે.

417
00:22:24,000 --> 00:22:27,000
>> ઉદાહરણ માટે, અહીં આ ViewController.h,

418
00:22:27,000 --> 00:22:30,000
આ મારી પ્રથમ દૃશ્ય નિયંત્રક પ્રતિનિધિત્વ રહ્યું છે,

419
00:22:30,000 --> 00:22:32,000
મારા એપ્લિકેશન ની અંદર પ્રથમ સ્ક્રીન રહે છે.

420
00:22:32,000 --> 00:22:34,000
હવે આપણે જાણીએ છીએ કે આ શું કહી છે.

421
00:22:34,000 --> 00:22:36,000
અમે કહી રહ્યાં છે હું આ વર્ગ ViewController કૉલ છું,

422
00:22:36,000 --> 00:22:40,000
અને એક ViewController બધું છે કે જે UIViewController કરે છે કરે છે,

423
00:22:40,000 --> 00:22:43,000
અને આ, ફરીથી, અમુક વર્ગ કે એપલે લખ્યું હતું કે અમારા માટે સરળ સામગ્રી ઘણો કરે છે

424
00:22:43,000 --> 00:22:46,000
સ્ક્રીન પ્રદર્શિત કરવા.

425
00:22:46,000 --> 00:22:50,000
અહીં છે જ્યાં હું ખરેખર વ્યાખ્યાયિત મારા મતે નિયંત્રક શું કરે શરૂ કરી શકો છો,

426
00:22:50,000 --> 00:22:52,000
અને તે તારણ કે હું ખરેખર આ કોઇ જરૂર નથી.

427
00:22:52,000 --> 00:22:55,000
આ બોઇલરપ્લેટના કે એપલે મને માટે મફત આપે છે.

428
00:22:55,000 --> 00:22:59,000
હું કે પ્રથમ વાક્ય જરૂર હતી, અથવા હું એક વર્ગ ન હોય તો,

429
00:22:59,000 --> 00:23:02,000
તેથી અમે તે છૂટકારો મેળવવા અને આ છૂટકારો મેળવી શકે છે.

430
00:23:02,000 --> 00:23:05,000
ઠીક છે, તેથી આ મારા ખાલી સ્ક્રીન છે.

431
00:23:05,000 --> 00:23:08,000
>> હવે આપણે આ MainStoryboard.storyboard પર ક્લિક કરો,

432
00:23:08,000 --> 00:23:11,000
અને આ છે જ્યાં તે રસપ્રદ વિચાર શરૂ થાય છે.

433
00:23:11,000 --> 00:23:14,000
આ મારા એપ્લિકેશન પર પ્રથમ સ્ક્રીન દર્શાવે છે.

434
00:23:14,000 --> 00:23:17,000
જો હું એક બટન ઉમેરવા માંગો છો, HTML માં હું એક બટન ટેગ બનાવો હતી.

435
00:23:17,000 --> 00:23:20,000
Android માં તમે બટન ટેગ બનાવો હોય છે,

436
00:23:20,000 --> 00:23:23,000
પરંતુ iOS માં જો હું માત્ર નીચે અહીં આવવા તળિયે જમણી

437
00:23:23,000 --> 00:23:27,000
અને જો હું આ 3 જી એક પર અહીં ક્લિક કરો જ્યાં તે ઓબ્જેક્ટો કહે છે,

438
00:23:27,000 --> 00:23:31,000
અને હું સરકાવો શકો છો, અથવા હું બટન માટે શોધ શરૂ કરી શકો છો.

439
00:23:31,000 --> 00:23:35,000
અને જુઓ, એક બટન છે, તેથી જો હું ખરેખર ખેંચો અને આ અધિકાર છોડો ત્યાં,

440
00:23:35,000 --> 00:23:38,000
હું માત્ર મારા એપ્લિકેશન પર આ સ્ક્રીન પર કર્યું છે એક બટન ઉમેર્યા છે.

441
00:23:38,000 --> 00:23:41,000
જો હું લખાણ બદલવા માંગો છો, તો હું ડબલ તેને ક્લિક કરી શકો છો,

442
00:23:41,000 --> 00:23:47,000
કંઈક પ્રલોભક જેમ કહે છે કે "મારા દબાવો."

443
00:23:47,000 --> 00:23:51,000
ઠીક છે, હવે જો હું આ એપ્લિકેશન ચલાવો, કે જેથી અમે તેને કમ્પાઇલ,

444
00:23:51,000 --> 00:23:54,000
જેથી તેને ચલાવવા માટે હું ટોચ ડાબી બાજુએ આવેલી પ્લે બટન પર ક્લિક કરો, અને ત્યાં મારી એપ્લિકેશન છે.

445
00:23:54,000 --> 00:23:58,000
મેં કંઈપણ નથી નહોતી, અને હું એક મીઠી શોધી iPhone એપ્લિકેશન મળ્યો હતો.

446
00:23:58,000 --> 00:24:01,000
જો હું તેને રોકવા માંગો છો, તો તમે સ્ટોપ બટન ક્લિક કરી શકો છો

447
00:24:01,000 --> 00:24:03,000
કારણ કે તેને વધુ મજા છે.

448
00:24:03,000 --> 00:24:07,000
>> હવે કહો કે હું ખરેખર થાય છે જ્યારે હું આ બટન દબાવો કંઈક કરવા માંગો છો.

449
00:24:07,000 --> 00:24:09,000
આમ કરવા માટે કે હું જરૂર શું છે મને બનાવવાની જરૂર છે

450
00:24:09,000 --> 00:24:13,000
એક નવી ઇવેન્ટ સંભાળનાર અથવા ક્રિયા.

451
00:24:13,000 --> 00:24:16,000
તેનો અર્થ એ છે કે હું અમુક પદ્ધતિ કે હું કહી શકાય માંગો છો બનાવવાની જરૂર છે

452
00:24:16,000 --> 00:24:18,000
જ્યારે હું બટન દબાવો, જેથી આપણે એક નવી પદ્ધતિ બનાવો.

453
00:24:18,000 --> 00:24:20,000
હું ViewController.h ની અંદર છું.

454
00:24:20,000 --> 00:24:22,000
હું કહે છે કે એક પદ્ધતિ અસ્તિત્વમાં જરૂર છે.

455
00:24:22,000 --> 00:24:26,000
હું પ્રથમ સંયોગચિહ્ન જરૂર છે કારણ કે હું દૃશ્ય નિયંત્રક પર આ ફોન કરી જાઉં છું.

456
00:24:26,000 --> 00:24:28,000
હું આ એક પ્રકાર આપવી પડે છે.

457
00:24:28,000 --> 00:24:31,000
આ પ્રકાર કે IBAction વસ્તુ કે અમે અગાઉ જોયું હશે છે.

458
00:24:31,000 --> 00:24:35,000
આ ઘટના સંભાળનાર છે, જેથી તે એક IBAction પરત ચાલી રહ્યું છે,

459
00:24:35,000 --> 00:24:38,000
અને આ XCode માટે હિંટ એમ કહે છે કે

460
00:24:38,000 --> 00:24:40,000
આ એવું કંઈક હું કંઈક WIRE માંગો છો.

461
00:24:40,000 --> 00:24:45,000
હું તેને buttonPressed અર્ધવિરામ, જેમ કે એક નામ આપી શકે છે.

462
00:24:45,000 --> 00:24:48,000
>> હવે હું મારા વર્ગ ની અંદર એક નવી પદ્ધતિ જાહેર કર્યું છે.

463
00:24:48,000 --> 00:24:50,000
મેં કહ્યું કર્યું છે અને આ પદ્ધતિ અસ્તિત્વ ધરાવે છે.

464
00:24:50,000 --> 00:24:53,000
હવે આપણે ViewController.m આવે છે,

465
00:24:53,000 --> 00:24:56,000
દો અને કહો કે આ પદ્ધતિ શું કરી શકે છે.

466
00:24:56,000 --> 00:25:03,000
જો હું લખીને શરૂ કરવા માટે, ઉદાહરણ તરીકે buttonPressed (રદબાતલ)

467
00:25:03,000 --> 00:25:06,000
સૂચના XCode ખરેખર સરસ છે અને મારા માટે autocompletes.

468
00:25:06,000 --> 00:25:09,000
કે ખરેખર અદ્ભુત છે.

469
00:25:09,000 --> 00:25:12,000
અહીં નોંધ કરો કે ફાઈલ મી. ની અંદર હું પણ રદબાતલ કહેવું કરી શકો છો,

470
00:25:12,000 --> 00:25:15,000
અને આ કારણ છે કે IBAction ખરેખર એક પ્રકાર નથી.

471
00:25:15,000 --> 00:25:19,000
તે ખરેખર ક્યાંક છે વ્યાખ્યાયિત hashtag માટે રદબાતલ હોઇ શકે છે,

472
00:25:19,000 --> 00:25:22,000
અને ફરી, આ માત્ર XCode માટે હિંટ કે કહે છે

473
00:25:22,000 --> 00:25:25,000
હું આ ઇવેન્ટ સંભાળનાર પ્રયત્ન કરવા માંગો છો, અને અમે માત્ર એક જ સેકન્ડમાં શા માટે જોઈ શકશો.

474
00:25:25,000 --> 00:25:28,000
જ્યારે આ બટન દબાવવામાં આવે હું નકામી કંઈક કરવા જાઉં છું

475
00:25:28,000 --> 00:25:30,000
પોપઅપ પ્રદર્શિત કરવા.

476
00:25:30,000 --> 00:25:35,000
>> આમ કરવા માટે કે હું આ વર્ગ એક નવી ઉદાહરણ UIAlertView કહેવાય બનાવી શકો છો,

477
00:25:35,000 --> 00:25:39,000
અને આ એક વર્ગ છે કે એપલ લખ્યું હતું કે નકામી પૉપઅપ્સ પ્રદર્શિત થઈ રહ્યું છે તે છે.

478
00:25:39,000 --> 00:25:43,000
અમે આ પોપઅપ ચેતવણી કહી, અને પડશે હું પગલાંઓ 2 છે, આ પદાર્થ બનાવવા માટે યાદ રાખો કે,.

479
00:25:43,000 --> 00:25:46,000
પ્રથમ વાત હું જરૂર જગ્યા ફાળવી છે.

480
00:25:46,000 --> 00:25:48,000
હું UIAlertView કરવા માંગો છો.

481
00:25:48,000 --> 00:25:51,000
હું જગ્યા ફાળવી કરવા માંગો છો. કે મારી પ્રથમ પદ્ધતિ છે.

482
00:25:51,000 --> 00:25:53,000
મારી આગલી પદ્ધતિ છે હું તેને પ્રારંભ કરવા માંગો છો,

483
00:25:53,000 --> 00:25:58,000
અને તેથી હું આ મોટા, લાંબા initWithTitle કહેવાય પદ્ધતિ હોય છે.

484
00:25:58,000 --> 00:26:01,000
જે સામાન્ય નિયંત્રિત કરવા માટે આ પોપઅપ શું કહે બનશે.

485
00:26:01,000 --> 00:26:04,000
મારા પોપઅપ ઓફ શીર્ષક હેલ્લો હોઈ શકે છે.

486
00:26:04,000 --> 00:26:08,000
આ પોપઅપ ઓફ સંદેશો પ્રયત્ન "આ iOS છે." કરી શકો છો

487
00:26:08,000 --> 00:26:10,000
પ્રતિનિધિ વસ્તુ, મને ખબર નથી કે શું છે.

488
00:26:10,000 --> 00:26:13,000
ચાલો તે કશું કહેવું.

489
00:26:13,000 --> 00:26:18,000
હવે બટન છે જે દેખાય રહ્યું છે જેમ કે "તે ખાતરી છે કે" કંઈક કહી શકો

490
00:26:18,000 --> 00:26:24,000
અને હું ખરેખર કોઇ અન્ય બટનો નથી માંગતા, તેથી આપણે કે કાઢી નાખવા અને કૌંસ બંધ કરો.

491
00:26:24,000 --> 00:26:27,000
>> ઠીક છે, હું એક વધારાનું એક બનાવ્યું છે. ત્યાં અમે જાઓ.

492
00:26:27,000 --> 00:26:30,000
આ રીતે મને એક નવા પોપઅપ બનાવી શકો છો.

493
00:26:30,000 --> 00:26:35,000
જો હું ખરેખર પોપઅપ બતાવવા માંગો છો હું શો પદ્ધતિ કૉલ કરવા માંગો છો.

494
00:26:35,000 --> 00:26:38,000
આમ કરવા માટે કે હું ચેતવણી અને શો કહેવું કરી શકો છો,

495
00:26:38,000 --> 00:26:40,000
અને ફરી, સ્વયંપૂર્ણ સુપર સરસ હતો.

496
00:26:40,000 --> 00:26:42,000
જો હું ભૂલી ગયા છો કે શું હતું, જો હું માત્ર s માં લખ્યું,

497
00:26:42,000 --> 00:26:45,000
હું મારફતે અહીં સરકાવવા માટે બહાર આકૃતિ તે શું હતું શકે છે,

498
00:26:45,000 --> 00:26:48,000
અને તે સરસ રીતે ફિલ્ટર.

499
00:26:48,000 --> 00:26:52,000
હવે હું આ નવી પોપઅપ બનાવી.

500
00:26:52,000 --> 00:26:55,000
અમે પાછા પ્રતિનિધિ શું અર્થ પછી આવો પડશે,

501
00:26:55,000 --> 00:26:58,000
અને હવે હું કહેવા હું આ પદ્ધતિ ઉત્તેજિત કરી કરવા માંગો છો માંગો છો

502
00:26:58,000 --> 00:27:01,000
જ્યારે હું બટન દબાવો, જેથી હું મારા સ્ટોરીબોર્ડ પર પાછા આવવાની જાઉં છું,

503
00:27:01,000 --> 00:27:04,000
અને હું હવે આ IBAction જોડી કરવા માંગો છો.

504
00:27:04,000 --> 00:27:06,000
પ્રથમ વસ્તુ તમે કરવા માંગો છો છે બટન ક્લિક કરો.

505
00:27:06,000 --> 00:27:08,000
જ્યારે હું આ બટન દબાવો હું શું કશુંક કરવા માંગો છો.

506
00:27:08,000 --> 00:27:10,000
હું નીચે નિયંત્રણ પકડી ન જાઉં છું.

507
00:27:10,000 --> 00:27:13,000
હું ક્લિક કરો અને બટન ખેંચો જાઉં છું

508
00:27:13,000 --> 00:27:15,000
અહીં ઉપર જ્યાં તેને જુઓ કંટ્રોલર કહે છે.

509
00:27:15,000 --> 00:27:17,000
અમે જોઈ શકો છો કે જે તેને સરસ રીતે અપ અજવાળે છે.

510
00:27:17,000 --> 00:27:22,000
>> જો હું દો મારા માઉસ સાથે જાઓ હવે હું અહીં પર આ પોપઅપ હોય છે, જ્યાં હું કેટલાક વિકલ્પો હોય છે.

511
00:27:22,000 --> 00:27:24,000
આમાંના ઘટનાઓ કે હું રજીસ્ટર કરી શકે છે.

512
00:27:24,000 --> 00:27:28,000
આ એ જ પદ્ધતિઓનો હું મારા IBActions તરીકે ક ફાઈલ જાહેર બધી હોય છે.

513
00:27:28,000 --> 00:27:31,000
આ રીતે XCode જાણે શું આ થોડું યાદીમાં દેખાશે જોઈએ,

514
00:27:31,000 --> 00:27:33,000
જેથી માત્ર એક સંકેત છે.

515
00:27:33,000 --> 00:27:37,000
જો હું દબાવવામાં બટન પર ક્લિક કરો, હું હવે ઘટના સંભાળનાર નોંધણી કરાવી છે.

516
00:27:37,000 --> 00:27:41,000
જાવાસ્ક્રિપ્ટ અમે કહી હું કેટલાક કોડ કે જે ઘટના સંભાળનાર રજીસ્ટર પડી.

517
00:27:41,000 --> 00:27:43,000
ઉદ્દેશ C-તે ખરેખર હતી કે સરળ.

518
00:27:43,000 --> 00:27:46,000
જો હું આ ફરીથી ચલાવો

519
00:27:46,000 --> 00:27:49,000
હવે જ્યારે હું બટન દબાવો મારા ઘટના સંભાળનાર માટે ગોળીબાર રહ્યું છે,

520
00:27:49,000 --> 00:27:51,000
અને હું આ પોપઅપ વિચાર જાઉં છું.

521
00:27:51,000 --> 00:27:54,000
સુપર, સુપર ત્યાં સરળ.

522
00:27:54,000 --> 00:27:57,000
>> જો તમે ક્યારેય ઘટનાઓ કે જે રજીસ્ટર થઈ થવું તમામ જોવા માંગો છો

523
00:27:57,000 --> 00:28:00,000
એક ઘટક પર જો હું આ બટન પર ક્લિક કરો

524
00:28:00,000 --> 00:28:02,000
અને હું અહીં આવવા પર જમણી બાજુ

525
00:28:02,000 --> 00:28:05,000
પ્રથમ તમે અહીં જોઈ હું બટન પ્રકાર જેવી વસ્તુઓ કરી શકે છે શકે છે,

526
00:28:05,000 --> 00:28:08,000
તેથી જો તમે એક તે હું કે ઉમેરો સંપર્ક બટન માંગો છો

527
00:28:08,000 --> 00:28:10,000
અથવા જે.

528
00:28:10,000 --> 00:28:13,000
જો હું ઘટનાઓ કે જે આ બટન પર હોય છે બધી જોવા માંગો છો

529
00:28:13,000 --> 00:28:16,000
જો હું અહીં ઉપર જમણી બાજુએ બધી રીતે આવવું

530
00:28:16,000 --> 00:28:19,000
અમે અહીં ઘટનાઓ હું આ અલગ અલગ ઘટનાઓ બધી અંતે જોઇ શકો છો.

531
00:28:19,000 --> 00:28:23,000
હું બટન દબાવો, જ્યારે હું દો બટન ઓફ જાઓ, જ્યારે હું નળ ડબલ અથવા જે કરી શકે છે,

532
00:28:23,000 --> 00:28:26,000
અને એક હું હમણાં જ રજીસ્ટર છે અને આ ઘટના ટચ કહેવાય ઉપર આધારિત છે,

533
00:28:26,000 --> 00:28:29,000
અને આ કહે છે કે જલદી મારી આંગળી બોલ બટન આવે છે

534
00:28:29,000 --> 00:28:32,000
ઇવેન્ટ કે જે આગ માટે જઈ રહ્યો છે, અને તે બરાબર શું માત્ર થયું છે.

535
00:28:32,000 --> 00:28:36,000
આ મૂળભૂત બટન દબાવવામાં ઘટના પ્રકારની છે.

536
00:28:36,000 --> 00:28:39,000
>> કોઈપણ પ્રશ્નો અત્યાર સુધી?

537
00:28:39,000 --> 00:28:43,000
ઠીક છે, કે અમે કેવી રીતે અમારી કોડ વસ્તુઓ WIRE શરૂ કરી શકો છો

538
00:28:43,000 --> 00:28:46,000
અમારા ઈન્ટરફેસ ની અંદર વસ્તુઓ માં.

539
00:28:46,000 --> 00:28:49,000
યાદ રાખો કે પ્રથમ વસ્તુ અમે આમ હતી કોડ શોધી હતી,

540
00:28:49,000 --> 00:28:54,000
અને પછી અમે વાયર્ડ કોડ માટે ઈન્ટરફેસ,

541
00:28:54,000 --> 00:28:57,000
અને ત્યાં અમારી પ્રથમ એપ્લિકેશન છે.

542
00:28:57,000 --> 00:29:00,000
ઠીક છે, કે જે ખરેખર ઠંડી હતી, અને અમે આ બટન બનાવી.

543
00:29:00,000 --> 00:29:03,000
તો શું આપણે કરવા માંગો છો નથી માટે ગુણધર્મો સમૂહ બનાવો

544
00:29:03,000 --> 00:29:05,000
આ બટનો રજૂ?

545
00:29:05,000 --> 00:29:08,000
ઉદાહરણ તરીકે, ચહેરાના ટેક ટો હું 9 બટનો છે,

546
00:29:08,000 --> 00:29:11,000
અને તે સુપર, સુપર માટે ખેંચો અને છોડો 9 વખત હોય નકામી હશો

547
00:29:11,000 --> 00:29:14,000
અથવા જો હું 81 સાથે ચહેરાના ટેક ટો બનાવવા બદલે 9 હતી

548
00:29:14,000 --> 00:29:17,000
અને હું ખેંચો અને છોડો 81 વખત હતો અને તે નબળું છે.

549
00:29:17,000 --> 00:29:20,000
અમે તેના બદલે શું કરી શકો છો એક HTML જેવી જ છે

550
00:29:20,000 --> 00:29:23,000
જ્યારે અમે ID અને નામો જેવી વસ્તુઓ હતી અને અમે વસ્તુઓ માટે શોધ કરી શકો છો

551
00:29:23,000 --> 00:29:27,000
તેમના ID દ્વારા, ત્યાં iOS માં સમાન ખ્યાલ ટૅગ્સ કહેવાય છે.

552
00:29:27,000 --> 00:29:31,000
>> ટૅગ માત્ર એક ઘટક માટે અનન્ય આંકડાકીય આઇડેન્ટીફાયર છે.

553
00:29:31,000 --> 00:29:34,000
જો હું કહું છું આ 0 એક ટૅગ છે, ઉદાહરણ તરીકે,

554
00:29:34,000 --> 00:29:38,000
જો હું બનાવો બટન ક્લિક કરો અને તેને 0 ની ટેગ આપે છે, અને અમે જોશો કેવી રીતે માત્ર એક બીજી કે કરવું,

555
00:29:38,000 --> 00:29:41,000
જો હું કે બટન મેળવવા માંગો છો કે હું ફક્ત કહે હું કહી શકો છો

556
00:29:41,000 --> 00:29:45,000
આ પદાર્થ અહીં ઉપર પદ્ધતિ viewWithTag,

557
00:29:45,000 --> 00:29:48,000
આ ઉદાહરણ તરીકે, self.view કે જે વર્તમાન સ્ક્રીન દર્શાવે છે,.

558
00:29:48,000 --> 00:29:53,000
જો હું કે viewWithTag પદ્ધતિ કહી, હું પાછા 0 ટેગ સાથે બટન ખેંચી જઇ રહ્યો છું.

559
00:29:53,000 --> 00:29:58,000
ચાલો ઇમારત ચહેરાના ટેક ટો દ્વારા આ પર એક નજર.

560
00:29:58,000 --> 00:30:01,000
પ્રથમ, આ મારા સ્ટોરીબોર્ડ છે.

561
00:30:01,000 --> 00:30:05,000
હું આ 10 UI બટનો બનાવી છે.

562
00:30:05,000 --> 00:30:07,000
નોટિસ તેઓ બધા જ માપ છો.

563
00:30:07,000 --> 00:30:11,000
જો હું એક આ બટન પર ક્લિક કરો અને હું અહીં ફરી આ જમણી બાજુ પર આવે છે

564
00:30:11,000 --> 00:30:15,000
તમે જોશો હું ફોન્ટ અહીં ગોઠવ્યો છે, તેથી હું ફોન્ટ થોડો મોટા કર્યા,

565
00:30:15,000 --> 00:30:19,000
પરંતુ હું પણ કર્યું હતું હું આ ટેગ સુયોજિત કરો.

566
00:30:19,000 --> 00:30:23,000
મેં કહ્યું હતું કે આ 1 નું ટેગ છે, અને તે ઉપર ડાબી બાજુએ છે.

567
00:30:23,000 --> 00:30:26,000
>> હવે, જો હું બીજું બટન ક્લિક કરો, અને આ બીજા અહીં એક જેવી,

568
00:30:26,000 --> 00:30:29,000
હવે તમે જોઈ શકશો કે મારી ટેગ 2 છે.

569
00:30:29,000 --> 00:30:32,000
આ બટનો દરેક માત્ર એક અનન્ય ટૅગ છે,

570
00:30:32,000 --> 00:30:35,000
અને તેથી આ પછી છે હું કેવી રીતે કરું છું માટે વાતચીત શરૂ થઈ રહ્યું છે

571
00:30:35,000 --> 00:30:38,000
મારા એપ્લિકેશન સાથે.

572
00:30:38,000 --> 00:30:40,000
આ એક દૃશ્ય નિયંત્રક તમામ અંદર છે,

573
00:30:40,000 --> 00:30:42,000
પરંતુ અહીં છે, આપણે શું હોય છે.

574
00:30:42,000 --> 00:30:44,000
અમે 3 ગુણધર્મો અહીં છે.

575
00:30:44,000 --> 00:30:49,000
પ્રથમ એક અને એક છેલ્લા મારા બોર્ડ રાજ્યના પ્રતિનિધિત્વ કરવાના છે.

576
00:30:49,000 --> 00:30:53,000
મૂળભૂત રીતે આ પ્રથમ એક રજૂ જ્યાં Xs અને ઓસ છે એરે છે.

577
00:30:53,000 --> 00:30:57,000
આ અન્ય એક અહીં અમને કહે વળાંક જેની છે.

578
00:30:57,000 --> 00:31:01,000
તમે ધ્યાન પડશે કે હું પણ આ બધી વસ્તુઓ અહીં છે.

579
00:31:01,000 --> 00:31:05,000
પહેલાં જ્યારે અમે ગુણધર્મો જાહેર અમે તેમને એક નામ અને પ્રકાર આપ્યો હતો.

580
00:31:05,000 --> 00:31:08,000
અમે પણ તેમને કેટલીક વધારાની માહિતી અહીં આપી શકે છે.

581
00:31:08,000 --> 00:31:11,000
આ પ્રથમ nonatomic કહે છે, અને આ શું કહે છે

582
00:31:11,000 --> 00:31:16,000
મૂળભૂત છે માત્ર એક વસ્તુ ક્યારેય એક સમયે આ ચલ ઍક્સેસ કરવાનો પ્રયાસ કરી હશે.

583
00:31:16,000 --> 00:31:19,000
તમે વધુ જટિલ કાર્યક્રમો કે જે બહુ થ્રેડેડ છે કરી શકે,

584
00:31:19,000 --> 00:31:22,000
અને તેથી સ્ક્રેચ માં અમે અલગ થ્રેડો હતી,

585
00:31:22,000 --> 00:31:25,000
અને વિવિધ sprites જ સમયે અલગ અલગ બાબતો કરી કરી શકે છે.

586
00:31:25,000 --> 00:31:29,000
>> જો કે આ કેસ છે, કે જે તે કશું કે અમે જોઈ આવશે નથી નથી,

587
00:31:29,000 --> 00:31:33,000
જો આપણે nonatomic કહેવું તે ખરેખર વસ્તુઓ થોડો ઝડપી બનાવી રહ્યું છે.

588
00:31:33,000 --> 00:31:37,000
અમે પણ આ સોંપો, મજબૂત, અથવા નબળું કહેવાય વસ્તુ છે.

589
00:31:37,000 --> 00:31:40,000
આ સોંપી માત્ર કહે છે કે આ એક પ્રમાણભૂત પ્રકાર છે.

590
00:31:40,000 --> 00:31:43,000
આ એક ઑબ્જેક્ટ અથવા નિર્દેશક કારણ કે આ માત્ર એક bool નથી,

591
00:31:43,000 --> 00:31:46,000
જેથી bool ઉદ્દેશ C-માં સમાયેલ છે.

592
00:31:46,000 --> 00:31:49,000
આ કહે નથી પ્રયાસ કરવા માટે અહીં પોઇન્ટર સાથે ફેન્સી કંઈપણ નથી.

593
00:31:49,000 --> 00:31:51,000
તે એક નિયમિત જૂના scaler છે.

594
00:31:51,000 --> 00:31:54,000
મજબૂત અને નબળા, આ નબળા કે વાસ્તવમાં કહે છે

595
00:31:54,000 --> 00:31:57,000
હું આ દેખાવ નિયંત્રક કંઈક થઈ પોઇન્ટ કરવા માંગો છો.

596
00:31:57,000 --> 00:32:00,000
હું ખરેખર ફાળવી નથી જવું અથવા છું મારી જાતને આ init.

597
00:32:00,000 --> 00:32:04,000
ઇન્ટરફેસ બિલ્ડર, જ્યારે હું એપ્લિકેશન ચલાવો, કે બધા આરંભ હેન્ડલ રહ્યું છે.

598
00:32:04,000 --> 00:32:07,000
જો હું નબળા કહે છે કે કહે છે કે કોઈએ આ બનાવવા કરી રહ્યું છે.

599
00:32:07,000 --> 00:32:09,000
જો હું મજબૂત કહે, આ કહે છે કે હું એક પ્રયત્ન જાઉં છું

600
00:32:09,000 --> 00:32:12,000
કે આ બોર્ડ પદાર્થ બનાવી છે,

601
00:32:12,000 --> 00:32:14,000
અને તેથી અહીં હું કેટલાક વધુ પદ્ધતિઓ અહીં હોય છે,

602
00:32:14,000 --> 00:32:18,000
ઉદાહરણ તરીકે, જ્યારે નવી રમત બટન દબાવવામાં આવે માટે એક ક્રિયા,

603
00:32:18,000 --> 00:32:20,000
જ્યારે અન્ય બટનો કોઈપણ દબાવવામાં આવે ક્રિયા,

604
00:32:20,000 --> 00:32:23,000
અને એટ વગેરે.

605
00:32:23,000 --> 00:32:26,000
>> અમે પણ ચહેરાના ટેક ટો ની તર્કશાસ્ત્રના ખૂબ માં મળશે,

606
00:32:26,000 --> 00:32:30,000
જોકે તે ખૂબ જ આકર્ષક છે, પરંતુ આપણે પર એક નજર

607
00:32:30,000 --> 00:32:33,000
વસ્તુઓ કે અમે iOS ની અંદર કરી શકો છે.

608
00:32:33,000 --> 00:32:35,000
આ નવી રમત પદ્ધતિ ઉત્તેજિત કરી રહ્યું છે

609
00:32:35,000 --> 00:32:37,000
જ્યારે પણ હું નવા રમત બટન દબાવો.

610
00:32:37,000 --> 00:32:41,000
માટે રોકી રાખવા કે હું ફક્ત મારા સ્ટોરીબોર્ડ પર આવે છે.

611
00:32:41,000 --> 00:32:43,000
હું નવી રમત પર ક્લિક કર્યું.

612
00:32:43,000 --> 00:32:47,000
જો હું ઉપર આવવા જમણી અહીં હું કે જોઈ શકો છો

613
00:32:47,000 --> 00:32:50,000
છે newGame પદ્ધતિ વાયર્ડ ઇનસાઇડ ઉપર ટચ કરો.

614
00:32:50,000 --> 00:32:53,000
તેથી જ આ પકવવામાં કરો રહ્યું છે.

615
00:32:53,000 --> 00:32:56,000
આ newGame પદ્ધતિ કેટલાક સેટ કરવા ઉપર રહ્યું છે.

616
00:32:56,000 --> 00:32:59,000
તે કહે છે કે હું તમને બોર્ડ રાજ્ય સાફ કરવા માંગો છો બનશે.

617
00:32:59,000 --> 00:33:01,000
આ ચંચળ એરે પર સરસ પદ્ધતિ છે.

618
00:33:01,000 --> 00:33:03,000
આ કહેવું તે હવે એક્સ વળાંક છે રહ્યું છે,

619
00:33:03,000 --> 00:33:07,000
અને હવે હું આ viewWithTag વસ્તુ લાભ લેવા જાઉં છું.

620
00:33:07,000 --> 00:33:11,000
>> હું જાણું છું કે મારા બટનનો ટૅગ્સ 1-9 હોય છે,

621
00:33:11,000 --> 00:33:13,000
અને તે હું આપખુદ લેવામાં છે.

622
00:33:13,000 --> 00:33:15,000
જો હું દરેક બટન લખાણ સુયોજિત કરવા માટે ખાલી થવું હોય

623
00:33:15,000 --> 00:33:17,000
કારણ કે મેં માત્ર એક નવી રમત શરૂ કર્યું અને હું કોઇ નથી માંગતા

624
00:33:17,000 --> 00:33:20,000
Xs અથવા ઓસ પર હું આ કરી શકો છો મૂકવામાં આવી હતી.

625
00:33:20,000 --> 00:33:24,000
હું કહી શકીએ હું ટેગ સાથે દૃશ્ય, 1, 2, 3, 4 એટ વગેરે કરવા માંગો છો.

626
00:33:24,000 --> 00:33:27,000
આ એક અલગ બટન દરેક સમય ખેંચી જશે.

627
00:33:27,000 --> 00:33:30,000
અહીં હું તેને ભૂમિકા માટે UIButton જાઉં છું.

628
00:33:30,000 --> 00:33:33,000
જેમ અમે ints ફ્લોટ્સ અને ઊલટું માટે ભૂમિકા કરી શકે છે

629
00:33:33,000 --> 00:33:37,000
આ કહે છે કે હું એક UIButton આ ભૂમિકા કરવા માંગો છો.

630
00:33:37,000 --> 00:33:40,000
તેનો અર્થ એ કે આ પ્રકારની UIButton * રહેશે

631
00:33:40,000 --> 00:33:43,000
પોઇન્ટર કારણે છે, પરંતુ ગભરાશો નહીં, તેઓ ડરામણી હવે નથી.

632
00:33:43,000 --> 00:33:47,000
>> એકવાર હું આ બટન હું તેની પર એક પદ્ધતિ કૉલ જાઉં છું હોય છે.

633
00:33:47,000 --> 00:33:50,000
આ પદ્ધતિ setTitle forState કહેવામાં આવે છે, અને તેથી આ કહે છે

634
00:33:50,000 --> 00:33:53,000
હું બટન લખાણ સુયોજિત કરવા માટે ખાલી શબ્દમાળા થવા માંગતા હો,

635
00:33:53,000 --> 00:33:57,000
અને મેં તે ખાલી શબ્દમાળા જ્યારે તે ન દબાવવામાં છે કરવા માંગો છો.

636
00:33:57,000 --> 00:34:01,000
જો હું આ પદ્ધતિ ઉપયોગ કરું છું, હું બટન લખાણ બદલી શકો છો

637
00:34:01,000 --> 00:34:04,000
જલદી કોઈ તેની બનાવ્યા, પરંતુ અમે કહી જ્યારે બટન માત્ર ત્યાં બેસવું છે કરવા માંગો છો

638
00:34:04,000 --> 00:34:07,000
હું લખાણ ખાલી કરવા માંગો છો.

639
00:34:07,000 --> 00:34:10,000
છેલ્લે, અમે મારા બોર્ડ પ્રારંભ જઈ રહ્યાં છો,

640
00:34:10,000 --> 00:34:12,000
અને હું કહે છે કે બધું 0 અંતે હાલમાં જાઉં છું,

641
00:34:12,000 --> 00:34:15,000
આ બોર્ડ જેથી સભ્યો નિર્વિકાર એક ચંચળ એરે છે,

642
00:34:15,000 --> 00:34:21,000
જેનો અર્થ છે કે હું addObject પદ્ધતિ અને માત્ર એક 0 અંદર કૉલ કરી શકો છો.

643
00:34:21,000 --> 00:34:23,000
કે શું થાય છે જ્યારે હું એક નવા રમત બનાવો.

644
00:34:23,000 --> 00:34:25,000
>> ચાલો એક બીજા પર એક નજર.

645
00:34:25,000 --> 00:34:28,000
આ અહીં પદ્ધતિ IBAction કે દબાવવામાં કરી રહ્યું છે તે છે

646
00:34:28,000 --> 00:34:31,000
દર વખતે એક તે વર્ગની દબાવવામાં આવે.

647
00:34:31,000 --> 00:34:33,000
હવે અમે કેટલીક ચહેરાના ટેક ટો તર્કશાસ્ત્ર અહીં છે.

648
00:34:33,000 --> 00:34:36,000
અમે આકૃતિ વળાંક જેની છે,

649
00:34:36,000 --> 00:34:39,000
આધારિત છે અને તે પર અમે ક્યાં તો એક્સ અથવા ઓ સુયોજિત કરો,

650
00:34:39,000 --> 00:34:43,000
પરંતુ અમે નોંધ્યું છે કે અમે આ જ ઘટના સંભાળનાર વારંવાર ઉપયોગ કરી રહ્યાં છો

651
00:34:43,000 --> 00:34:45,000
તે બટનોની દરેક એક એક છે.

652
00:34:45,000 --> 00:34:49,000
, એટલે કે હું ટોચે ડાબા બટન માટે એક પદ્ધતિ ન હોય

653
00:34:49,000 --> 00:34:52,000
તળિયે જમણી બાજુના બટન માટે એક અલગ પદ્ધતિ છે, તેમ છતાં હું હોય તે થઈ શકે છે.

654
00:34:52,000 --> 00:34:54,000
કે ખરેખર સારી ડિઝાઇન નહિં હોય.

655
00:34:54,000 --> 00:34:57,000
હું અહીં કરી રહ્યો છું શું છે હું ખરેખર તે નક્કી કરવા માટે જઈ રહ્યો છું

656
00:34:57,000 --> 00:35:00,000
આ બટન દબાવવામાં કે હતી ટેગ શું છે.

657
00:35:00,000 --> 00:35:04,000
તમે નોંધ્યું છે કે આ નાટક પદ્ધતિ એક દલીલ લે છે.

658
00:35:04,000 --> 00:35:07,000
તે મોકલનાર કહેવાય છે, અને મોકલનાર શું મોકલનાર છે છે જવાની

659
00:35:07,000 --> 00:35:10,000
બરાબર શું ક્રિયા પર લેવામાં આવ્યો છે.

660
00:35:10,000 --> 00:35:15,000
જો હું બટન દબાવો, આ મોકલનાર કે UIButton પ્રયત્ન રહ્યું છે

661
00:35:15,000 --> 00:35:18,000
કે હું ખરેખર દબાવવામાં, કે જેથી અર્થ એ થાય કે કે UIButton

662
00:35:18,000 --> 00:35:20,000
ટેગ ધરાવે છે કારણ કે હું એક ટેગ બનાવી.

663
00:35:20,000 --> 00:35:23,000
>> જો હું ટેગ અંતે મેળવવા માંગો છો કે હું ફક્ત કહે કરી શકો છો

664
00:35:23,000 --> 00:35:26,000
હું પ્રેષક ના ટેગ કરવા માંગો છો,

665
00:35:26,000 --> 00:35:28,000
અને ફરી, હું માત્ર એક UIButton માટે કર્યું છે કે તે casted.

666
00:35:28,000 --> 00:35:32,000
હું જાણું છું કે આ મોકલનાર એક UIButton હશે થાય છે.

667
00:35:32,000 --> 00:35:34,000
તે હંમેશા UIButton નથી.

668
00:35:34,000 --> 00:35:36,000
હું, ઉદાહરણ તરીકે, આ જ ઘટના સંભાળનાર રજીસ્ટર કરી શકે છે

669
00:35:36,000 --> 00:35:38,000
 એક બટન છે, એક એક સ્લાઇડર માટે છે.

670
00:35:38,000 --> 00:35:40,000
આ કિસ્સામાં, મને ખબર છે તેઓ બધા બટનો છો, જેથી હું કહેવા જાઉં છું

671
00:35:40,000 --> 00:35:43,000
હું આ બટન પ્રયત્ન કરવા માંગો છો, અને પછી હું ટેગ મેળવી શકો છો,

672
00:35:43,000 --> 00:35:48,000
અને ટેગ માંથી હવે મને ખબર જ્યાં હું બોર્ડ ની અંદર છું.

673
00:35:48,000 --> 00:35:51,000
પછી હું ફક્ત ક્યાંતો X અથવા ઓ, એ બાબતનો વિમાનની મુસાફરી કરી શકો છો સેટ કરી શકો છો,

674
00:35:51,000 --> 00:35:54,000
તપાસ જે વગેરે, એટ જીત્યો છે.

675
00:35:54,000 --> 00:35:59,000
>> આ અત્યાર સુધી પર કોઈપણ પ્રશ્ન છે?

676
00:35:59,000 --> 00:36:02,000
ઠીક છે, બધી કોડ અમે ઓનલાઇન અમે ખૂબ જ પ્રવેશ મેળવવા માંગતા નહિં હોય પોસ્ટ

677
00:36:02,000 --> 00:36:06,000
આ ચહેરાના ટેક ટો તર્કશાસ્ત્ર, પરંતુ હવે તમે તે ખરેખર જોઈ શકો છો

678
00:36:06,000 --> 00:36:09,000
તમામ અમે કરી રહ્યા છીએ છે અમે આ એરે પર રહ્યાં રહ્યાં છો,

679
00:36:09,000 --> 00:36:13,000
તેથી અમે અહીં આંટીઓ માટે એક દંપતિ છે, અને અમે હમણાં જ જોવા સરખામણી કરી રહ્યા છીએ

680
00:36:13,000 --> 00:36:18,000
અમે તમામ પંક્તિઓ, અથવા જેમ સ્તંભ કંઈપણ એક મેચમાં મેચ હોય છે.

681
00:36:18,000 --> 00:36:21,000
ખરેખર આ એપ્લિકેશન ચલાવો, તો હું એક આ બટનોની પર ટેપ કરો

682
00:36:21,000 --> 00:36:24,000
કે નાટક પદ્ધતિ છોડવામાં આવી હતી, જેથી તેનો અર્થ એ કે હું હમણાં જ સેટ

683
00:36:24,000 --> 00:36:31,000
આ બટન એક X હોઈ, તેથી હવે આ બટન એક ઓ પ્રયત્ન કરશે, અને એમ જ,

684
00:36:31,000 --> 00:36:35,000
અને જેથી તે કેવી રીતે અમે આ એક પાનું એપ્લિકેશન સાથે વાર્તાલાપ શરૂ કરી રહ્યાં છો.

685
00:36:35,000 --> 00:36:38,000
>> અમે કોડ પોસ્ટ કરશો, તેથી કે વાંચી જવું મફત લાગે,

686
00:36:38,000 --> 00:36:43,000
દો પરંતુ હવે કેટલાક એપ્લિકેશન્સ કે જે હમણાં જ એક પાનું કરતાં વધુ છે તે વિશે વાત કરો.

687
00:36:43,000 --> 00:36:47,000
તરીકે ચહેરાના ટેક ટો તરીકે ઉત્તેજક હતા, iOS ની અંદર એપ્લિકેશન્સ ઘણો

688
00:36:47,000 --> 00:36:50,000
બહુવિધ સ્ક્રીનો સાથે વસ્તુઓ નીચે આ કવાયત પ્રકારની હોય છે.

689
00:36:50,000 --> 00:36:54,000
પ્રથમ ખ્યાલ કે અમે વિશે વાત કરવાની જરૂર પડશે પ્રોટોકોલ છે,

690
00:36:54,000 --> 00:36:57,000
અને એ પ્રોટોકોલ ફક્ત પદ્ધતિઓનો સમૂહ છે

691
00:36:57,000 --> 00:36:59,000
કે જે તમે વ્યાખ્યાયિત વચન કરી શકો છો.

692
00:36:59,000 --> 00:37:02,000
જો હું 2 પદ્ધતિઓ સાથે આ નવી પ્રોટોકોલ, આ પ્રથમ એક બનાવવા માટે,

693
00:37:02,000 --> 00:37:05,000
જો પરત પ્રકાર રદબાતલ છે, હું તે foo કહેવાય છે.

694
00:37:05,000 --> 00:37:07,000
તે કોઈ દલીલો લે છે. હું અન્ય પદ્ધતિ છે.

695
00:37:07,000 --> 00:37:11,000
તે પૂર્ણાંક આપે છે. હું કહેવાય તે બાર, અને તે એક દલીલ લે છે.

696
00:37:11,000 --> 00:37:14,000
આ તમામ પ્રોટોકોલ છે કે SomeProtocol કહેવાય છે અહીં,

697
00:37:14,000 --> 00:37:19,000
આ વસ્તુઓ છે કે જે કોઇ વ્યક્તિ અમલીકરણ કરી શકો છો એક સમૂહ છે.

698
00:37:19,000 --> 00:37:22,000
હું આ પ્રોટોકોલ ની અંદર foo શું નથી જણાવ્યું છે.

699
00:37:22,000 --> 00:37:26,000
તેના બદલે, મેં હમણાં જ કહી રહ્યો છું તમે foo વ્યાખ્યાયિત જો તમે કરવા માંગો છો શકે છે.

700
00:37:26,000 --> 00:37:30,000
જો હું દૃશ્ય નિયંત્રક બનાવી રહ્યો છું કે એક વર્ગ બનાવવા

701
00:37:30,000 --> 00:37:33,000
હું અંદરથી કે વર્ગ વચન ઓફ અમલ કરી શકો છો

702
00:37:33,000 --> 00:37:40,000
આમાંની કેટલીક પદ્ધતિઓનો, તેથી ઉદાહરણ તરીકે, જો કહેવું <SomeProtocol>

703
00:37:40,000 --> 00:37:43,000
હવે કહે છે હું તમને એક વચન બનાવવા છું અંદર કે

704
00:37:43,000 --> 00:37:50,000
આ દૃશ્ય નિયંત્રક વર્ગ હું બંને foo અને બાર વ્યાખ્યાઓ હશે.

705
00:37:50,000 --> 00:37:52,000
>> કે શા માટે ઉપયોગી છે?

706
00:37:52,000 --> 00:37:55,000
IOS ની અંદર ઘટકો ઘણાં આ લાભ લેવા

707
00:37:55,000 --> 00:37:58,000
ડિઝાઇન પેટર્ન પ્રતિનિધિમંડળ કહેવાય છે, અને પ્રતિનિધિમંડળ શું કહે છે

708
00:37:58,000 --> 00:38:01,000
છે, ઉદાહરણ તરીકે, કે જો હું લખાણ બોક્સમાં હોય છે

709
00:38:01,000 --> 00:38:04,000
અને અમુક ઘટનાઓ કે મારા લખાણ બોક્સની અંદર રજીસ્ટર થઈ શકે છે,

710
00:38:04,000 --> 00:38:07,000
અલગ ઘટનાઓ હું શું કરી શકો બનાવવા બદલે છે, હું કહું છું કરી શકો છો

711
00:38:07,000 --> 00:38:10,000
આ લખાણ બોક્સની પ્રતિનિધિ કેટલાક હેતુ હશે.

712
00:38:10,000 --> 00:38:13,000
જ્યારે હું કહું છું કે આ એક પ્રતિનિધિ હવે એ છે કે અર્થ એ થાય કે

713
00:38:13,000 --> 00:38:16,000
જ્યારે પણ કેટલાક ઘટના લખાણ બોક્સમાં કરવામાં આવી છોડવામાં આવશે

714
00:38:16,000 --> 00:38:18,000
બદલે તેને અથવા કે કંઈપણ રજીસ્ટર કર્યા

715
00:38:18,000 --> 00:38:21,000
તે માત્ર પ્રતિનિધિ પર પદ્ધતિ કહી રહ્યું છે.

716
00:38:21,000 --> 00:38:24,000
ઉદાહરણ તરીકે, અંદર મારા લખાણ બોક્સની હું જ્યારે હું દબાવો માટે એક પદ્ધતિ છે

717
00:38:24,000 --> 00:38:27,000
કે તળિયે જમણી બાજુના બટન પૂર્ણ થાય,

718
00:38:27,000 --> 00:38:30,000
અને તેથી બદલે ઘટના સંભાળનાર હું શું કહી શકીએ રજીસ્ટર થયેલ છે

719
00:38:30,000 --> 00:38:34,000
લખાણ બોક્સમાં, અહીં એક પદાર્થ કે હું તમને એક પદ્ધતિ કૉલ કરવા માંગો છો છે

720
00:38:34,000 --> 00:38:37,000
દર વખતે કોઇ કરવામાં બટન દબાવીને,

721
00:38:37,000 --> 00:38:40,000
અને તેનો અર્થ એ કે જે તે પદાર્થ કેટલાક પ્રોટોકોલ અમલીકરણ છે

722
00:38:40,000 --> 00:38:45,000
કહે છે કે હું તે થઈ બટન ક્રિયા વ્યાખ્યાયિત વચન,

723
00:38:45,000 --> 00:38:47,000
કારણ કે જો તે પદ્ધતિ નક્કી કરે છે અને નથી કે તમે પૂરી પ્રેસ,

724
00:38:47,000 --> 00:38:49,000
પછી તે ગૂંચવણમાં જ હશે.

725
00:38:49,000 --> 00:38:55,000
>> ચાલો એક ઉદાહરણ પર એક નજર.

726
00:38:55,000 --> 00:38:58,000
અહીં હું ફક્ત એક લખાણ બોક્સમાં હોય છે,

727
00:38:58,000 --> 00:39:04,000
અને અહીં એક પર આ લખાણ બોક્સની આ જમણી બાજુએ ગુણધર્મો ના પ્રતિનિધિ છે.

728
00:39:04,000 --> 00:39:06,000
આ વર્ગ એક મિલકત છે.

729
00:39:06,000 --> 00:39:09,000
હું અહીં કર્યું શું છે હું ક્લિક કરી નિયંત્રિત, અને હું અહીં પર આ સ્પોટ પરથી ખેંચી

730
00:39:09,000 --> 00:39:13,000
આ દૃશ્ય નિયંત્રક, અને તે હવે આ લખાણ બોક્સની પ્રતિનિધિ કહે છે

731
00:39:13,000 --> 00:39:18,000
છે દૃશ્ય નિયંત્રક હશે.

732
00:39:18,000 --> 00:39:20,000
તેનો અર્થ એ છે કે જ્યારે કેટલાક ક્રિયાઓ થાય છે, રજીસ્ટર બદલે

733
00:39:20,000 --> 00:39:25,000
અલગ ઘટના હેન્ડલર્સ હું તો તમારે તેમને પ્રતિનિધિ મોકલવા માંગો છો.

734
00:39:25,000 --> 00:39:28,000
હવે આપણે મારા મતે નિયંત્રક પર એક નજર.

735
00:39:28,000 --> 00:39:32,000
આ ક. ફાઈલની અંદર હું વચન કર્યા છે.

736
00:39:32,000 --> 00:39:36,000
હું આ પ્રોટોકોલ ની અંદર કેટલાક પદ્ધતિઓ અમલમાં વચન કર્યા છે

737
00:39:36,000 --> 00:39:38,000
UITextFieldDelegate ફરી, અને કહે છે,

738
00:39:38,000 --> 00:39:42,000
આ માત્ર કેટલીક વસ્તુઓ કે હું અમલ પસંદ કરી શકો છો કેટલાક યાદી છે.

739
00:39:42,000 --> 00:39:46,000
>> જો હું મારો ફાઈલ એમ. અહીં આવે છે, હું એક જેવી પદ્ધતિ અમલમાં છે.

740
00:39:46,000 --> 00:39:49,000
હું તેને textFieldShouldReturn કહેવાય કર્યા છે

741
00:39:49,000 --> 00:39:52,000
કારણ કે તે શું છે તે પ્રોટોકોલ ની અંદર તરીકે ઓળખાતું હતું.

742
00:39:52,000 --> 00:39:57,000
અને હવે જ્યારે પણ હું કર્યું છે કે ટેક્સ્ટ ક્ષેત્ર બટન દબાવો અંદર

743
00:39:57,000 --> 00:40:00,000
આ છે શું કહેવાય કરો ચાલી રહ્યું છે, જેથી હું એક ઘટના સંભાળનાર ન રજીસ્ટર ન હતી.

744
00:40:00,000 --> 00:40:03,000
હું પ્રતિનિધિ સાથે જોડાયેલ છે, અને જ્યારે પણ આ ઘટના પકવવામાં આવે છે

745
00:40:03,000 --> 00:40:08,000
આ પદ્ધતિ કે જે કહેવાય આવશે છે, તેથી જો હું ઉપર અહીં આવો મારા સ્ટોરીબોર્ડ માટે અને ચલાવવા માટે તેને-

746
00:40:08,000 --> 00:40:11,000
જ્યારે લોડ છે અમે જોઈ શકો છો આ શું કરે છે.

747
00:40:11,000 --> 00:40:13,000
મારી સ્ક્રીન પર મેં 2 વસ્તુઓ હોય છે.

748
00:40:13,000 --> 00:40:16,000
હું આ લખાણ ક્ષેત્રમાં હોય છે, અને હું આ લેબલ હોય છે.

749
00:40:16,000 --> 00:40:19,000
હું માત્ર કહી રહ્યો છું હું આ લેબલની લખાણ કરવા માંગો છો

750
00:40:19,000 --> 00:40:23,000
ગમે તે વપરાશકર્તા લખાણ ક્ષેત્રમાં ની અંદર માં ટાઇપ કરવા માટે સમાન છે.

751
00:40:23,000 --> 00:40:26,000
આ આગામી અહીં વાક્ય ખાલી પદ્ધતિ કે હું ફોન કરું છું છે

752
00:40:26,000 --> 00:40:29,000
લખાણ ક્ષેત્ર કે જે કહે છે કે હું તમને કીબોર્ડ છુપાવવા માટે કરવા માંગો છો છે.

753
00:40:29,000 --> 00:40:33,000
આ ફક્ત મનસ્વી પદ્ધતિ કે એપલે પસંદ કર્યું છે.

754
00:40:33,000 --> 00:40:38,000
>> ફરીથી, પહેલાં મેં કંઈપણ હું બધું WIRE અપ હતી કર્યું છે, તેથી હું પ્રથમ ઉપર અહીં આવ્યા હતા.

755
00:40:38,000 --> 00:40:42,000
દેખાવ નિયંત્રક પ્રતિ હું લખાણ બોક્સમાં પર ખેંચો.

756
00:40:42,000 --> 00:40:46,000
હું જાઓ, અને હું અહીં જોઈ શકો છો કે હું આ લખાણ ક્ષેત્રમાં મિલકત કરી શકો છો

757
00:40:46,000 --> 00:40:49,000
ઉપર જુઓ નિયંત્રક અહીં થી હું મિલકત વ્યાખ્યાયિત કર્યું છે

758
00:40:49,000 --> 00:40:52,000
કે જે લખાણ ક્ષેત્રમાં એક IBOutlet છે.

759
00:40:52,000 --> 00:40:55,000
આ કહે છે કે હું આ મિલકત WIRE અપ કરી શકો છો

760
00:40:55,000 --> 00:40:59,000
મારા UI માં લખાણ ક્ષેત્ર છે.

761
00:40:59,000 --> 00:41:03,000
હવે જ્યારે હું આ બટન પર ક્લિક કરો હું લખીને શરૂ કરી શકો છો.

762
00:41:03,000 --> 00:41:06,000
હવે જો હું પૂર્ણ કરો બટન ક્લિક કરો આ ગોળીબાર રહ્યું છે

763
00:41:06,000 --> 00:41:08,000
એક ઇવેન્ટ કે હું હવે પ્રતિભાવ આપી શકો છો.

764
00:41:08,000 --> 00:41:10,000
કોઈ ઘટના હેન્ડલર્સ.

765
00:41:10,000 --> 00:41:13,000
કે કેવી રીતે હું હમણાં જ તે થઈ બટન પર પ્રતિક્રિયા.

766
00:41:13,000 --> 00:41:15,000
અર્થમાં બનાવીએ?

767
00:41:15,000 --> 00:41:20,000
>> આ એક ડિઝાઈન પેટર્ન જે તમે ક્યારેય જાતે શોધી શકે નથી

768
00:41:20,000 --> 00:41:23,000
તમારા પોતાના પ્રોટોકોલ બનાવી રહ્યા હોય, પરંતુ ફક્ત ખબર છે કે અમુક

769
00:41:23,000 --> 00:41:27,000
વિવિધ iOS ઘટકો અલગ અલગ રીતે ઘટનાઓ રજીસ્ટર કરો.

770
00:41:27,000 --> 00:41:29,000
બટનો, ઉદાહરણ તરીકે, તે IBActions વાપરો.

771
00:41:29,000 --> 00:41:32,000
લખાણ ક્ષેત્રો, બીજી બાજુ, માટે પ્રતિનિધિઓ ઉપયોગ થશે.

772
00:41:32,000 --> 00:41:36,000
અમે જુઓ અને તમે જે દસ્તાવેજીકરણ કે અંદર તમામ નજર કરી શકે છે.

773
00:41:36,000 --> 00:41:41,000
જો કે, ત્યાં ખરેખર UI સામગ્રી એક ટન તમે iOS માં સમાયેલ છે,

774
00:41:41,000 --> 00:41:46,000
તેથી, ઉદાહરણ તરીકે, જે રીતે હું કરી હતી કે નીચે જમણા ખૂણે થાય કહી

775
00:41:46,000 --> 00:41:48,000
છે મને આ લખાણ ક્ષેત્રમાં પસંદ કરેલ હોય.

776
00:41:48,000 --> 00:41:50,000
હું ઉપર અહીં આવ્યા હતા.

777
00:41:50,000 --> 00:41:53,000
હું નીચે એક બીટ ટીપણાની પેઠે વીંટેલું માટે કી પરત,

778
00:41:53,000 --> 00:41:56,000
અને હું ખરેખર વસ્તુઓ સંપૂર્ણ સમૂહ આ બનાવવા કરી શકો છો, જો કે હું માંગો છો કે કહેવા માટે

779
00:41:56,000 --> 00:42:00,000
કટોકટી બદલે હું કે શું છે, જે સંપૂર્ણપણે રેન્ડમ છે કહી,

780
00:42:00,000 --> 00:42:02,000
અને હું શા માટે ત્યાં કટોકટી આંતરિક કૉલ કરો બટન છે ખબર નહિં હોય,

781
00:42:02,000 --> 00:42:06,000
પરંતુ, તે ખરેખર નાના પત્રો ઇમરજન્સી કોલ કહે છે.

782
00:42:06,000 --> 00:42:08,000
ત્યાં તમે જાઓ.

783
00:42:08,000 --> 00:42:12,000
>> ચોક્કસપણે iOS આ વિવિધ વિકલ્પો બધા અન્વેષણ કરો.

784
00:42:12,000 --> 00:42:14,000
પ્રતિનિધિઓ પર કોઈપણ પ્રશ્ન છે?

785
00:42:14,000 --> 00:42:18,000
ફરીથી, ફક્ત એક રસપ્રદ ડિઝાઈન પેટર્ન કે તમે પરિચિત પ્રયત્ન કરીશું.

786
00:42:18,000 --> 00:42:22,000
ઠીક છે, ચાલો આગામી ટેબલ દૃશ્યો પર એક નજર.

787
00:42:22,000 --> 00:42:26,000
ટેબલ દૃશ્ય મૂળભૂત વસ્તુઓ છે કે જે યાદી છે કે જે iOS માં સ્થળ પર તમામ છે.

788
00:42:26,000 --> 00:42:29,000
જ્યારે તમે તમારા તમામ સંપર્કો દ્વારા ફ્લિપિંગ કરી રહ્યાં છો, તમે શોધી રહ્યા છો

789
00:42:29,000 --> 00:42:34,000
આ સુયોજિત પાનું, અને વસ્તુઓ યાદી તે પ્રકારના એક કોષ્ટક દૃશ્ય કહેવાય છે.

790
00:42:34,000 --> 00:42:37,000
IOS માં એક કોષ્ટક દૃશ્ય અમલ ખૂબ સરળ છે.

791
00:42:37,000 --> 00:42:41,000
તેના બદલે એક વર્ગ છે કે જે UIViewController ઉતરી બનાવવા

792
00:42:41,000 --> 00:42:44,000
જેમ અમે પહેલાં અમે ફક્ત બદલે કહેવું જરૂર કર્યું છે

793
00:42:44,000 --> 00:42:46,000
બધું એક UIViewController હું કરવા માંગો છો નથી,

794
00:42:46,000 --> 00:42:50,000
હું બધું UITableViewController હું કરવા માંગો છો નથી કહેવું,

795
00:42:50,000 --> 00:42:54,000
કે જેથી માત્ર કેટલીક વધારાની વસ્તુઓ છે કે જે સંપૂર્ણપણે આપણા માટે કરવામાં આવે છે ઉમેરે છે.

796
00:42:54,000 --> 00:42:58,000
અમે ખૂબ જ મારાથી ટેબલ ની અંદર જગ્યાએ ભરવા માટે કહો થોડું કરવાની જરૂર છે.

797
00:42:58,000 --> 00:43:02,000
>> ક્રમમાં ટેબલ હું કેટલાક પ્રશ્નોના જવાબ જરૂર પ્રદર્શિત કરવા માટે.

798
00:43:02,000 --> 00:43:06,000
પ્રથમ પ્રશ્ન મને જવાબ આપવાની જરૂર છે કેટલા વિભાગો કોષ્ટકમાં છે?

799
00:43:06,000 --> 00:43:08,000
જ્યારે તમે તમારા સંપર્કો એપ્લિકેશન મારફતે ફ્લિપિંગ રહ્યાં છો અને તમે નોટિસ પડશે કે તે પ્રકારની છે

800
00:43:08,000 --> 00:43:12,000
આ જેમ દ્વારા આયોજીત, પછી તમે bs હોય છે, અને તમે તે થોડી પેટા હેડર હોય છે.

801
00:43:12,000 --> 00:43:14,000
તે દરેક વિભાગને કહેવામાં આવે છે.

802
00:43:14,000 --> 00:43:16,000
તમે કરી શકો છો અથવા આ જરૂર ન હોઈ શકે.

803
00:43:16,000 --> 00:43:19,000
પ્રથમ વસ્તુ તમે કરવાની જરૂર છે એક પદ્ધતિ અમલમાં

804
00:43:19,000 --> 00:43:22,000
numberOfSectionsInTableView: tableView કહેવાય છે.

805
00:43:22,000 --> 00:43:25,000
કે ફક્ત આપે કેટલા વિભાગો તમે હોય છે,

806
00:43:25,000 --> 00:43:29,000
તેથી આ કહેવું શકે એક આપશે જો તમે એક મોટા ટેબલ દૃશ્ય છે.

807
00:43:29,000 --> 00:43:33,000
આગામી પ્રશ્ન છે કે iOS જાણવા જરૂર છે કેટલા પંક્તિઓ તમારી પાસે છે?

808
00:43:33,000 --> 00:43:36,000
ઉદાહરણ તરીકે, તમે એક કોષ્ટક દૃશ્ય દ્વારા ફ્લિપિંગ કરી રહ્યાં છો.

809
00:43:36,000 --> 00:43:39,000
તમે ગાયન એક નિશ્ચિત સંખ્યા અથવા તમે શોધી રહ્યાં છો તે સંપર્કો એક નિશ્ચિત સંખ્યા હોય છે.

810
00:43:39,000 --> 00:43:41,000
જો તમે મને કરશો, અલબત્ત, ઘણાં કે નથી,

811
00:43:41,000 --> 00:43:44,000
અને જેથી તે કેવી રીતે iOS જાણે કેટલા કોશિકાઓ પ્રદર્શિત કરવા માટે.

812
00:43:44,000 --> 00:43:46,000
>> ફરીથી, આ 3 વળતર કંઈક કહી શકે છે.

813
00:43:46,000 --> 00:43:49,000
મારા ટેબલ દૃશ્ય 3 પંક્તિઓ છે.

814
00:43:49,000 --> 00:43:52,000
છેલ્લે, iOS જાણવા દરેક સેલ શું લાગે જરૂર છે,

815
00:43:52,000 --> 00:43:54,000
તેથી તે ખરેખર કરવા ચાલી રહ્યું છે શું છે અને આ પદ્ધતિ નીચે અહીં કહી,

816
00:43:54,000 --> 00:43:57,000
આ tableView: cellForRowAtIndexPath.

817
00:43:57,000 --> 00:44:01,000
તે માટે તમારા ટેબલ ની અંદર દરેક એક કોષ પર આ પદ્ધતિ કહી રહ્યું છે.

818
00:44:01,000 --> 00:44:03,000
તે કેવી રીતે ખબર નથી કેટલી વખત તેને કૉલ કરવા માટે?

819
00:44:03,000 --> 00:44:06,000
સારું, તમે તે વિભાગમાં પંક્તિઓ સંખ્યા અંદર જણાવ્યું હતું.

820
00:44:06,000 --> 00:44:08,000
અમે અમારી કોશિકાઓ દરેક પર આ કૉલ જઈ રહ્યાં છો,

821
00:44:08,000 --> 00:44:11,000
અને આ અંદર છે જ્યાં તમે ખરેખર જેવી વસ્તુઓ કરી શકો છો

822
00:44:11,000 --> 00:44:16,000
લખાણ સુયોજિત અથવા તમે કહી જમણી બાજુ પર થોડો વાદળી બટન શું કરે છે.

823
00:44:16,000 --> 00:44:19,000
આ કોશિકાઓ મેળવવાને પેટર્ન, અમે આ પદ્ધતિ વાપરી રહ્યા છીએ

824
00:44:19,000 --> 00:44:22,000
dequeueReusableCellWithIdentifier કહેવાય છે.

825
00:44:22,000 --> 00:44:29,000
>> ઉદ્દેશ C-વાસ્તવમાં તેમની પદ્ધતિ નામોની હાસ્યાસ્પદ લંબાઈ માટે ખૂબ જાણીતા છે,

826
00:44:29,000 --> 00:44:32,000
અને આ ખરેખર બિંદુ ઉદાહરણ એક સરસ કિસ્સો છે.

827
00:44:32,000 --> 00:44:37,000
આ પદ્ધતિ કરે છે શું આ માત્ર કહે છે હું તમને મને સેલ આપવા માંગો છો.

828
00:44:37,000 --> 00:44:39,000
ફક્ત iOS વસ્તુ.

829
00:44:39,000 --> 00:44:41,000
જો તમે તમારા આઇપોડ પર 100,000 ગાયન કંઈક છે

830
00:44:41,000 --> 00:44:45,000
iOS કરવા નથી માંગતા નથી શું છે 100,000 કોશિકાઓ ફાળવો,

831
00:44:45,000 --> 00:44:48,000
કારણ કે જો તમે તમારા યાદીમાં ટોચ પર છો, તમે ખરેખર કરવા મેમરીને ફાળવવા જરૂર

832
00:44:48,000 --> 00:44:51,000
કોષ કે 99.000 નીચે પંક્તિઓ છે માટે?

833
00:44:51,000 --> 00:44:55,000
ના, કારણ કે જેમ તમે સરકાવવાથી રહ્યાં છો અને તમે આ કરી શકો છો ફાળવવા તરીકે તમે સાથે જાઓ પ્રકારની.

834
00:44:55,000 --> 00:44:57,000
આ તમારા માટે કરવામાં આવે છે.

835
00:44:57,000 --> 00:44:59,000
તમે તે બધા મૂર્ખ કામગીરી સામગ્રી વિશેની ચિંતા નથી.

836
00:44:59,000 --> 00:45:02,000
બધા તમે કહો કે તમે આ પદ્ધતિ dequeueReusableCellWithIdentifier કહી છે,

837
00:45:02,000 --> 00:45:06,000
અને આ કહે છે, ઠીક, જો તમે હું તમારા માટે એક નવો સેલ બનાવવા જઈ રહ્યો છું કરવાની જરૂર છે.

838
00:45:06,000 --> 00:45:09,000
>> પરંતુ જો તમે કોષ્ટક તળિયે છો અને તમે પહેલાથી જ કેટલાક કોષો ફાળવવામાં કર્યા છે

839
00:45:09,000 --> 00:45:12,000
કોષ્ટકની ઉપરની કે તમે ખરેખર જઈ રહ્યાં છો નજીકના સમયમાં જરૂર નથી અંતે

840
00:45:12,000 --> 00:45:15,000
હું તમને એક એક નવું allocating બદલે પાછા તે આપવા જઈ રહ્યો છું,

841
00:45:15,000 --> 00:45:17,000
અને તેથી આ એક સરસ પ્રદર્શન ચિંતાનો વિષય છે.

842
00:45:17,000 --> 00:45:21,000
તમે કોષો જાતે ફાળવી નથી.

843
00:45:21,000 --> 00:45:23,000
જે તમને આપવા પાછળ એક સેલ ચાલી રહ્યું છે.

844
00:45:23,000 --> 00:45:25,000
તે તમે જે કોષ પદાર્થ પરત ચાલી રહ્યું છે.

845
00:45:25,000 --> 00:45:28,000
એકવાર તમે સેલ પદાર્થ તમે સામગ્રી તે કરવા કરી શકો છો.

846
00:45:28,000 --> 00:45:32,000
તમે આ લખાણ લેબલ કહેવાય મિલકત સાથે કોશિકાના લખાણ સુયોજિત કરી શકો છો.

847
00:45:32,000 --> 00:45:36,000
તમે જમણી બાજુ અથવા અમુક અન્ય રેન્ડમ સામગ્રી પર તીર ઉમેરી શકો છો

848
00:45:36,000 --> 00:45:41,000
આ અન્ય મિલકત સાથે accessoryType કહેવાય છે, અને તેથી અને તેથી.

849
00:45:41,000 --> 00:45:46,000
>> ચાલો ખરેખર એક કોષ્ટક દૃશ્ય હવે અમલીકરણ પર એક નજર.

850
00:45:46,000 --> 00:45:49,000
જ્યારે હું આ પ્રોજેક્ટ બનાવનાર

851
00:45:49,000 --> 00:45:53,000
તેના બદલે એક દૃશ્ય અરજી કહેતા કરતાં હું ખરેખર પર અહીં આવ્યા

852
00:45:53,000 --> 00:45:57,000
મુખ્ય-વિગતવાર કાર્યક્રમ છે, અને તેથી મૂળભૂત આ મેલ એપ્લિકેશન અનુલક્ષે

853
00:45:57,000 --> 00:46:01,000
ડાબી પર ટેબલ જુઓ અને પછી જમણી બાજુ પર સમાવિષ્ટો સાથે iPad પર.

854
00:46:01,000 --> 00:46:07,000
આઇપોડ અથવા આઇફોન પર આ એક ટેબલ દૃશ્ય અનુલક્ષે રહ્યું છે.

855
00:46:07,000 --> 00:46:10,000
કે જ્યાં હું મારા સ્ટાર્ટર કોડ મળ્યો હતો.

856
00:46:10,000 --> 00:46:13,000
>> ચાલો પ્રથમ સ્ટોરીબોર્ડ પર એક નજર.

857
00:46:13,000 --> 00:46:15,000
આ બધા મારા માટે કરવામાં આવ્યું હતું, જે મૂળભૂત રીતે બનાવેલ છે.

858
00:46:15,000 --> 00:46:18,000
આ સંશોધક પટ્ટી મને બતાવ્યું ઉદાહરણ સેલ શું દેખાશે શકે છે,

859
00:46:18,000 --> 00:46:22,000
અને હું ડબલ આ ક્લિક કરો, કરી શકો છો શીર્ષક બદલો.

860
00:46:22,000 --> 00:46:25,000
કોઈપણ અન્ય UI ચિંતા હું ત્યાં સંભાળી શકે છે.

861
00:46:25,000 --> 00:46:27,000
હેડર ફાઈલ ખરેખર સરળ લાગે છે.

862
00:46:27,000 --> 00:46:30,000
કહેતા આ UIViewController છે બદલે આપણે હવે કહી રહ્યાં છે કે આ એક છે

863
00:46:30,000 --> 00:46:35,000
TableViewController, તેથી આપણે જાણીએ છીએ કે અમે તે તમામ ટેબલ પદ્ધતિઓ કૉલ કરવા માંગો છો.

864
00:46:35,000 --> 00:46:38,000
આગામી હું એક મિલકત કે પ્રતિનિધિત્વ કરવાના છે બનાવવા માંગો છો

865
00:46:38,000 --> 00:46:40,000
મારા ટેબલ ની અંદર જે વસ્તુઓ.

866
00:46:40,000 --> 00:46:43,000
આ ટેબલ આપખુદ પ્રદર્શિત રહ્યું છે

867
00:46:43,000 --> 00:46:46,000
ફળ યાદી છે, અને તેથી હું કેટલાક એરે બનાવવાની જરૂર છે

868
00:46:46,000 --> 00:46:49,000
જેમાં હું ફળ દાખલ કરી શકો છો.

869
00:46:49,000 --> 00:46:52,000
મારા અમલીકરણ ફાઈલ પ્રથમ વસ્તુ ની અંદર હું કરવા માંગો છો

870
00:46:52,000 --> 00:46:55,000
છે મને ખાતરી છે કે હું આ એરે પ્રારંભ બનાવવા માંગો છો.

871
00:46:55,000 --> 00:46:58,000
>> હું alloc આરંભ જણાવ્યું હતું કે, મારા ફળ એરે બનાવનાર,

872
00:46:58,000 --> 00:47:03,000
અને હું 4 વસ્તુઓ તેને ઉમેરીને છું, એક જે વધારે અન્ય 3 કરતાં વિવાદાસ્પદ છે.

873
00:47:03,000 --> 00:47:06,000
અને હવે હું 4 કદ ઝાકઝમાળ છે.

874
00:47:06,000 --> 00:47:08,000
અમે તેને ધ્રુજારી કરી રહ્યાં છો CS50 માં.

875
00:47:08,000 --> 00:47:11,000
હવે હું 4 કદ ઝાકઝમાળ છે.

876
00:47:11,000 --> 00:47:13,000
હવે હું આ પ્રશ્નોનો જવાબ આપવા શરૂ જાઉં છું, વાસ્તવમાં, અને

877
00:47:13,000 --> 00:47:16,000
જ્યારે હું આ એપ્લિકેશન બનાવનાર આ તમામ પહેલેથી જ મારા માટે કરવામાં આવ્યું હતું.

878
00:47:16,000 --> 00:47:19,000
હું બહાર ટેબલ દૃશ્યમાં વિભાગો સંખ્યા ટાઇપ નથી.

879
00:47:19,000 --> 00:47:22,000
તે પહેલાથી જ ત્યાં હતો, અને હું બ્લેન્ક્સનો ભરતા છું.

880
00:47:22,000 --> 00:47:24,000
કેટલા વિભાગો હું છે?

881
00:47:24,000 --> 00:47:26,000
એક. બધા થાય છે.

882
00:47:26,000 --> 00:47:28,000
કેટલી પંક્તિઓ હું છે?

883
00:47:28,000 --> 00:47:31,000
વેલ, હું દરેક ફળ માટે એક પંક્તિ હોય છે, જેથી આ ગણક

884
00:47:31,000 --> 00:47:34,000
કોઈપણ એરે કહે મોટું કેવી રીતે તે એક મિલકત છે?

885
00:47:34,000 --> 00:47:36,000
કે કેટલા પંક્તિઓ હું હોય છે.

886
00:47:36,000 --> 00:47:42,000
છેલ્લે, હું કહેવા દરેક સેલ શું લાગતું નથી જરૂર છે?

887
00:47:42,000 --> 00:47:46,000
હું dequeueReusableCellWithIdentifier કહેવું જાઉં છું.

888
00:47:46,000 --> 00:47:48,000
>> ફરીથી, આ પહેલેથી જ મારા માટે લખવામાં આવ્યું હતું.

889
00:47:48,000 --> 00:47:51,000
હું આ જાતે કરી ન હોય અને હું પાછી મેળવવા માંગો છો

890
00:47:51,000 --> 00:47:54,000
આ સ્થાન પર આ કોષ.

891
00:47:54,000 --> 00:47:57,000
યાદ રાખો કે અમે દરેક એક કોશિકા પર આ જ પદ્ધતિ કૉલ કરી રહ્યાં છો,

892
00:47:57,000 --> 00:48:01,000
અને આ અહીં દલીલ, આ indexPath દલીલ,

893
00:48:01,000 --> 00:48:03,000
કહે પંક્તિ શું હું સાઇન છું

894
00:48:03,000 --> 00:48:05,000
જો હું indexPath.row અહીં કહેવું નીચે

895
00:48:05,000 --> 00:48:09,000
આ 0 હોય, તો પછી તેને 1 હોય, તો પછી તેને 2 હશે, અને આ છે તેથી હું જાણું છું

896
00:48:09,000 --> 00:48:11,000
સેલ શું હું હાલમાં પ્રદર્શિત છું.

897
00:48:11,000 --> 00:48:15,000
હું કોશિકાના text આ textLabel મિલકત મદદથી સેટ કરવા માંગો છો

898
00:48:15,000 --> 00:48:19,000
મારા ફળ એરે અંદર જાઓ અને વિચાર

899
00:48:19,000 --> 00:48:21,000
દરેક પંક્તિ ને અનુરૂપ ઑબ્જેક્ટ.

900
00:48:21,000 --> 00:48:24,000
જો આ એક સ્ટ્રિંગ છે, હું હવે સુયોજિત છું

901
00:48:24,000 --> 00:48:28,000
લખાણ એ શબ્દમાળાને મિલકત.

902
00:48:28,000 --> 00:48:30,000
હું એક અન્ય વસ્તુ કરી શકો છો.

903
00:48:30,000 --> 00:48:32,000
હું પણ કોશિકાઓ દરેક પર એક ઘટના સંભાળનાર રજીસ્ટર કરી શકો છો,

904
00:48:32,000 --> 00:48:35,000
તેથી જ્યારે હું આ કોશિકાઓના દરેક ટૅપ

905
00:48:35,000 --> 00:48:39,000
આ didSelectRowAtIndexPath, આ મારા માટે કહેવાય રહ્યું છે,

906
00:48:39,000 --> 00:48:42,000
તેથી આ વ્યાખ્યાયિત કરીને ફક્ત હું હવે હેન્ડલ શું થાય છે કરી શકો છો

907
00:48:42,000 --> 00:48:46,000
જ્યારે તમે સેલ ટૅપ અને ફરી, અમે જેમાં સેલ ટેપ કરવામાં આવ્યું હતું પસાર કરી રહ્યાં છે

908
00:48:46,000 --> 00:48:50,000
જેથી અમે અમારા કોષો બધા માટે આ જ ઘટના સંભાળનાર ફરી ઉપયોગ કરી શકો છો.

909
00:48:50,000 --> 00:48:53,000
>> ફરીથી, આ કંઈક iOS મારા માટે કરી છે.

910
00:48:53,000 --> 00:48:55,000
ચાલો અન્ય નકામી પોપઅપ પ્રદર્શિત

911
00:48:55,000 --> 00:48:59,000
કે ફક્ત કહે તમે કંઈક જ્યાં કે કંઈક લેવામાં

912
00:48:59,000 --> 00:49:04,000
છે પંક્તિ પદાર્થ હશે.

913
00:49:04,000 --> 00:49:10,000
જ્યારે હું આ ચલાવો, હું આ સરસ ટેબલ દૃશ્ય હોય જાઉં છું

914
00:49:10,000 --> 00:49:14,000
આ ફળ દરેક માટે એક પંક્તિ સાથે, અને જો હું એક ટેપ

915
00:49:14,000 --> 00:49:16,000
તે મને કહે શું થયું.

916
00:49:16,000 --> 00:49:21,000
અર્થમાં બનાવીએ?

917
00:49:21,000 --> 00:49:24,000
ચાલો થોડો વધુ એક એપ્લિકેશન જટીલ બીલ્ડ કરવા,

918
00:49:24,000 --> 00:49:28,000
તરીકે ક્લિક કરવાનું તમને ટમેટા લેવામાં જેટલો છે.

919
00:49:28,000 --> 00:49:31,000
આ storyboarding વિશે સરસ ભાગ

920
00:49:31,000 --> 00:49:35,000
છે તે માત્ર અમને ડિઝાઈન સ્ક્રીનો વ્યક્તિગત રીતે મદદ નથી ચાલી રહ્યું છે,

921
00:49:35,000 --> 00:49:38,000
તે પણ અમને મદદ મળીને અમારા સમગ્ર એપ્લિકેશન ગૂંચ ચાલી રહ્યું છે,

922
00:49:38,000 --> 00:49:42,000
જેથી અંતિમ એપ્લિકેશન અમે મકાન હશો આ સરસ રમતો સમાચાર વાચક છે,

923
00:49:42,000 --> 00:49:45,000
અને તેથી તે માટે ઘણા સ્ક્રીનો છે ચાલી રહ્યું છે, અને તેથી હું ખરેખર પ્રતિનિધિત્વ કરી શકે છે

924
00:49:45,000 --> 00:49:48,000
સ્ટોરીબોર્ડ પર આ બહુવિધ સ્ક્રીનો દરેક,

925
00:49:48,000 --> 00:49:52,000
અને હું ઝૂમ અને ઊંચા સ્તર માંથી મારા એપ્લિકેશન જોઈ શકો છો.

926
00:49:52,000 --> 00:49:55,000
>> ક્રમમાં મારા સ્ટોરીબોર્ડ એક નવી તત્વ અંદર બનાવવા માટે

927
00:49:55,000 --> 00:49:59,000
તે ખરેખર ઈન્ટરફેસ બિલ્ડર ની અંદર સરળ છે.

928
00:49:59,000 --> 00:50:01,000
જો હું આ બીજા સ્ક્રીન ઍડ કરવા માંગો છો, ઉદાહરણ તરીકે,

929
00:50:01,000 --> 00:50:06,000
હું પ્રથમ ચૂંટવું ઝૂમ કે એપલે ખૂબ જ પ્રેમ કરે છે સાથે બહાર ઝૂમ કરી શકો છો,

930
00:50:06,000 --> 00:50:09,000
અને નીચે અહીં પહેલાં હું એક બટન શોધવા માટે

931
00:50:09,000 --> 00:50:12,000
અને હું ખેંચો અને એક બટન છોડો

932
00:50:12,000 --> 00:50:15,000
જો હું એક નવા સ્ક્રીન બનાવવા માંગો છો હું વાસ્તવમાં માત્ર ખેંચો અને છોડો કરી શકો છો

933
00:50:15,000 --> 00:50:19,000
સમગ્ર દૃશ્ય નિયંત્રક, તેથી જો હું આ ચુંટો, તે અહીં ખેંચો પર,

934
00:50:19,000 --> 00:50:23,000
હેય, ત્યાં બીજી સ્ક્રીન છે, અને તેથી હવે આ જ સ્ટોરીબોર્ડ ફાઈલ મદદથી

935
00:50:23,000 --> 00:50:26,000
હું મારા એપ્લિકેશન ની અંદર સ્ક્રીનો બધી શકો છો, અને હું ઝૂમ કરી શકો છો

936
00:50:26,000 --> 00:50:28,000
જુઓ અને તેઓ કેવી રીતે સંચાર કર્યો.

937
00:50:28,000 --> 00:50:32,000
આ હજુ સુધી વાર્તાલાપ કરશે.

938
00:50:32,000 --> 00:50:36,000
માર્ગ કે આ 2 સ્ક્રીનો વાર્તાલાપ છે તમે સંબંધો વ્યાખ્યાયિત કરે છે.

939
00:50:36,000 --> 00:50:39,000
તમે મૂળભૂત આ સ્ક્રીન કહેવું કરી શકો છો, જ્યારે તમે આ બટન દબાવો,

940
00:50:39,000 --> 00:50:42,000
હું તમે આ નવા સ્ક્રીન પર સ્લાઇડ કરવા માંગો છો.

941
00:50:42,000 --> 00:50:44,000
તેનો અર્થ એ કે ત્યાં વચ્ચે સંબંધ આ પ્રકારની છે

942
00:50:44,000 --> 00:50:46,000
 પ્રથમ સ્ક્રીનમાં અને બીજા સ્ક્રીન.

943
00:50:46,000 --> 00:50:49,000
તમે મૂળભૂત કે બટન બીજા સ્ક્રીન પર એક તીર પડશે

944
00:50:49,000 --> 00:50:53,000
કહે છે કે જ્યારે તમે આ બટન દબાવો કે જ્યાં હું જવા માંગો છો.

945
00:50:53,000 --> 00:50:57,000
જેમ આપણે ક્લિક કર્યું અને નિયંત્રણ કરવા માટે તે આઉટલેટ્સ વ્યાખ્યાયિત ખેંચ્યાં

946
00:50:57,000 --> 00:51:01,000
અમે એ જ વસ્તુ કરવા માટે આ segues વ્યાખ્યાયિત રહ્યા છીએ.

947
00:51:01,000 --> 00:51:05,000
>> અમે તે માટે એક ઉદાહરણ જુઓ, અને પડશે આપણે ખરેખર સંક્રમણ પહેલા

948
00:51:05,000 --> 00:51:08,000
એક સ્ક્રીન બીજા iOS પર્યાપ્ત સરસ આ પદ્ધતિ કહી છે

949
00:51:08,000 --> 00:51:11,000
prepareForSegue કહેવાય છે, અને આ છે જ્યાં અમે શરૂ કરી શકો છો

950
00:51:11,000 --> 00:51:14,000
એક એપ્લિકેશન બીજી માહિતી મોકલી.

951
00:51:14,000 --> 00:51:17,000
ઉદાહરણ અમે કરી રહ્યાં છો તે જોવા માટે મૂળભૂત રીતે અમને પરવાનગી આપશે

952
00:51:17,000 --> 00:51:20,000
માટે લીગ અને વિભાગો દ્વારા બેઝબોલ ટીમો ફિલ્ટર કરે છે.

953
00:51:20,000 --> 00:51:23,000
હું જ્યારે લીગ પસંદ કરો, ઉદાહરણ તરીકે, હું સંક્રમણ માટે કરવા માંગો છો

954
00:51:23,000 --> 00:51:25,000
મારી આગળની સ્ક્રીન જ્યાં હું વિભાગો તમામ પ્રદર્શિત કરી શકો છો

955
00:51:25,000 --> 00:51:27,000
કે લીગ અથવા બધા અલગ અલગ ટીમો છે.

956
00:51:27,000 --> 00:51:31,000
હું એ સ્ક્રીન ટીમો શું તમે પ્રદર્શિત કરીશું મોકલવાની જરૂર છે.

957
00:51:31,000 --> 00:51:35,000
આમ કરવા માટે કે હું આ પદ્ધતિ લાભ લેવા જાઉં છું અહીં.

958
00:51:35,000 --> 00:51:39,000
>> છેલ્લે, માત્ર iOS પર રેન્ડમ બિંદુ.

959
00:51:39,000 --> 00:51:41,000
જો તમે માહિતી સંગ્રહવા માંગો છો ત્યાં આ કોર માહિતી તરીકે ઓળખાય વાત છે,

960
00:51:41,000 --> 00:51:44,000
જે ખરેખર સાથે કામ જટીલ પ્રકારની છે.

961
00:51:44,000 --> 00:51:47,000
તમે પણ એસક્યુએલ વાપરવા માટે માહિતી સ્ટોર કરી શકો છો,

962
00:51:47,000 --> 00:51:51,000
, જે ફરીથી વધુ જટિલ બાજુ પર સરસ પરંતુ પ્રકારની છે સાથે કામ કરે છે,

963
00:51:51,000 --> 00:51:55,000
પરંતુ iOS પણ આ ખરેખર ઠંડી મિલકત યાદીઓ વસ્તુઓ તરીકે ઓળખાય છે આધાર આપે છે,

964
00:51:55,000 --> 00:52:00,000
અને એક મિલકત સૂચિ ખાલી ફાઈલ કે જે કી કિંમત જોડીઓને પ્રતિનિધિત્વ કરે છે.

965
00:52:00,000 --> 00:52:03,000
તમે કીઓની યાદી વ્યાખ્યાયિત કરવા માટે, અને તમે કહી આ કી માટે કોઈ અરે હોવો રહ્યું છે.

966
00:52:03,000 --> 00:52:06,000
આ કી શબ્દમાળા હોવી રહ્યું છે, અને મૂળભૂત કંઈપણ તમે શું કરી શકો છો

967
00:52:06,000 --> 00:52:10,000
JSON માં તમે અંદર મિલકત યાદી કરી શકો છો,

968
00:52:10,000 --> 00:52:14,000
અને તેથી આ ખરેખર સરસ રીતે અમને અમુક માહિતી સાથે કામ કરવા માટે પરવાનગી આપે છે.

969
00:52:14,000 --> 00:52:18,000
ઉદાહરણ તરીકે, હું આ Teams.plist કે હું બનાવનાર હોય છે.

970
00:52:18,000 --> 00:52:22,000
હું એક નવા plist ફાઈલ છે, અને હું નીચે વ્યાયામ કરી શકો છો.

971
00:52:22,000 --> 00:52:26,000
આ એક શબ્દકોશ છે, આ એક શબ્દકોશ, આ શબ્દમાળાઓ છે,

972
00:52:26,000 --> 00:52:30,000
અને તેથી આ એક JSON દસ્તાવેજ એક સરસ ગ્રાફિકલ રજૂઆત છે

973
00:52:30,000 --> 00:52:33,000
અથવા માત્ર કી કિંમત જોડીઓને સમૂહ,

974
00:52:33,000 --> 00:52:37,000
અને તેથી આ માહિતી એ છે કે હું મારી એપ્લિકેશન ની અંદર સાથે કામ કરવામાં આવશે.

975
00:52:37,000 --> 00:52:40,000
>> ચાલો પ્રથમ ઉપર અહીં આવે છે. અમે પુષ્કળ વધુ ફાઇલો હવે હોય છે.

976
00:52:40,000 --> 00:52:44,000
દો પરંતુ પ્રથમ પર સ્ટોરીબોર્ડ અહીં આવે છે.

977
00:52:44,000 --> 00:52:48,000
સ્ટોરીબોર્ડ અહીં જો હું ઝૂમ કરી શકો છો આઉટ

978
00:52:48,000 --> 00:52:51,000
આપણે હવે જુઓ કે આ મારા એપ્લિકેશનના ફ્લો છે.

979
00:52:51,000 --> 00:52:53,000
હું પ્રથમ આ સ્ક્રીન પર શરૂ જાઉં છું.

980
00:52:53,000 --> 00:52:55,000
હું આ સ્ક્રીન પર નીચે શારડી જાઉં છું,

981
00:52:55,000 --> 00:52:58,000
અને હું આ સ્ક્રીન પર નીચે શારડી જાઉં છું, અને અમે અહીં જોઈ શકો છો કે હું પ્રકારની જો

982
00:52:58,000 --> 00:53:04,000
આ આસપાસ અમે આ તીર અહીં અહીં જવા છે એક ખસેડવા માટે,

983
00:53:04,000 --> 00:53:08,000
અને જે રીતે હું કે તીર વ્યાખ્યાયિત હતો જો હું થોડો ઝૂમ,

984
00:53:08,000 --> 00:53:12,000
અને જો હું આ દૃશ્ય નિયંત્રક પર આવે છે,

985
00:53:12,000 --> 00:53:16,000
અને અહીં સેલ, અને હું એમ કહે માંગો છો જ્યારે તમે સેલ ટૅપ

986
00:53:16,000 --> 00:53:18,000
હું તમે અન્ય સ્ક્રીન સ્લાઇડ કરવા માંગો છો.

987
00:53:18,000 --> 00:53:21,000
હું ફક્ત નીચે નિયંત્રણ પકડી શકે છે,

988
00:53:21,000 --> 00:53:26,000
થોડો ઉપર સ્ક્રોલ, નીચે નિયંત્રણ ધરાવે છે, આ કોષ ખેંચો પર અને નહીં.

989
00:53:26,000 --> 00:53:30,000
>> અને અમે અહીં ઉપર કહેવું શું સંક્રમણ કે જે તમે ઉપયોગ કરવા માંગો છો છે?

990
00:53:30,000 --> 00:53:32,000
શું તમે તે સ્લાઇડ વસ્તુ કે દબાણ કહેવાય છે ઉપયોગ કરવા માંગો છો?

991
00:53:32,000 --> 00:53:34,000
શું તમે નીચે માંથી સ્લાઇડ ઉપર માંગો છો?

992
00:53:34,000 --> 00:53:36,000
કે વાહનોમાં કહેવાય છે.

993
00:53:36,000 --> 00:53:40,000
અને એક વખત જ્યારે હું એક આ બટન પર ક્લિક કરો, તો તે મારા માટે આ તીર દોરવા ચાલી રહ્યું છે,

994
00:53:40,000 --> 00:53:44,000
અને તે અર્થ એ થાય કે હું ખરેખર નિયંત્રિત કર્યું છે શું થાય છે જ્યારે હું આ બટન ગ્રાફિકલી દબાવો.

995
00:53:44,000 --> 00:53:48,000
હું કોઈપણ ખરેખર એક સ્ક્રીન ના આગામી એક સ્લાઇડ કોડ નથી લખી ન હતી.

996
00:53:48,000 --> 00:53:51,000
હું આ દૃષ્ટિની ઈન્ટરફેસ બિલ્ડર ની અંદર વ્યાખ્યાયિત થયેલ છે.

997
00:53:51,000 --> 00:53:55,000
જો હું આ તીર પર ક્લિક કરો, અમે જોઈ શકો છો કે હું આ વાત એ નામ આપ્યું હતું.

998
00:53:55,000 --> 00:53:59,000
હું તેને showDivisions, અને આ છે કે જેથી મને ખબર કરી શકો છો

999
00:53:59,000 --> 00:54:03,000
સંક્રમણ શું થાય છે તે વિશે છે, અને અમે માત્ર એક સેકન્ડમાં શા માટે જોઈ શકશો.

1000
00:54:03,000 --> 00:54:06,000
કે કેવી રીતે હું મારા એપ્લિકેશનમાં વિવિધ સ્ક્રીનો વાયર્ડ કર્યું છે.

1001
00:54:06,000 --> 00:54:09,000
જો આ એક છે, ઉદાહરણ તરીકે બટન બદલે એક કોષ્ટક દૃશ્ય હતા

1002
00:54:09,000 --> 00:54:11,000
હું બટન પર ક્લિક કરો નિયંત્રિત, આગળની સ્ક્રીન પર ખેંચો શકે છે,

1003
00:54:11,000 --> 00:54:16,000
અને તે કેવી રીતે હું સંશોધક રીતે કરી શકે છે.

1004
00:54:16,000 --> 00:54:19,000
>> ખરેખર ઝડપથી, જો અમે MasterViewController આવે છે,

1005
00:54:19,000 --> 00:54:22,000
ફરીથી, અમે ફક્ત વસ્તુઓ યાદી વ્યાખ્યાયિત જઈ રહ્યાં છો

1006
00:54:22,000 --> 00:54:26,000
કે ટેબલ દૃશ્ય પ્રદર્શિત કરવામાં આવશે.

1007
00:54:26,000 --> 00:54:29,000
અહીં હું કહી રહ્યો છું હું કે જે તમને plist ફાઈલ લેવા માટે કરવા માંગો છો,

1008
00:54:29,000 --> 00:54:32,000
અને હું તો તમે તેને લાવવા માટે એક શબ્દકોશ માં કરવા માંગો છો,

1009
00:54:32,000 --> 00:54:35,000
અને એકવાર તમે તે શબ્દકોશ છે, હું તે જ પ્રશ્નો ફરી જવાબ જાઉં છું.

1010
00:54:35,000 --> 00:54:37,000
અહીં વિભાગોની સંખ્યા છે.

1011
00:54:37,000 --> 00:54:41,000
એક, ત્યાં દરેક લીગ માટે એક પંક્તિ છે, અને દરેક કોષની લખાણ છે

1012
00:54:41,000 --> 00:54:46,000
ક્યાં તો પ્રથમ, પ્રથમ લીગ, બીજા લીગ, અને તેથી પ્રયત્ન કરીશું.

1013
00:54:46,000 --> 00:54:51,000
છેલ્લે, હું આ પદ્ધતિ છે કે અમે માત્ર prepareForSegue કહેવાય હતો ઉપયોગ જાઉં છું,

1014
00:54:51,000 --> 00:54:54,000
અને આ પદ્ધતિ છે કે જે ઉત્તેજિત કરી રહ્યું છે જ્યારે હું ક્લિક કરો

1015
00:54:54,000 --> 00:54:57,000
એક તે પંક્તિઓ પર અને તેથી કે સંક્રમણ સક્રિય

1016
00:54:57,000 --> 00:54:59,000
કે હું તીર સાથે સુયોજિત કરો.

1017
00:54:59,000 --> 00:55:02,000
આ કહેતા છે કે હું બહુવિધ કરી શકો છો

1018
00:55:02,000 --> 00:55:05,000
એક સ્ક્રીન બીજા સંબંધો.

1019
00:55:05,000 --> 00:55:08,000
જો હું 2 બટન ધરાવે છે અને દરેક બટન તમે એક અલગ સ્ક્રીન પર લઈ જશે

1020
00:55:08,000 --> 00:55:10,000
હું દરેક બટન માટે 2 segues, 1 હોય જાઉં છું.

1021
00:55:10,000 --> 00:55:14,000
પરંતુ આ prepareForSegue છે, ફરીથી, ફરીથી વપરાશમાં હશે

1022
00:55:14,000 --> 00:55:17,000
વિવિધ સંબંધો દરેક માટે છે, કે જેથી અર્થ એ છે કે હું એક રસ્તો જરૂર

1023
00:55:17,000 --> 00:55:21,000
ઓળખવા જો તમે પ્રથમ બટન દબાવો અથવા તો તમે બીજી બટન દબાવો છે.

1024
00:55:21,000 --> 00:55:25,000
>> યાદ રાખો કે જ્યારે હું segue એક નામ, આ showDivisions આપ્યું,

1025
00:55:25,000 --> 00:55:29,000
કે કેવી રીતે હવે મને ખબર છે કે આ segue કે સક્રિય કરવામાં આવ્યું હતું.

1026
00:55:29,000 --> 00:55:32,000
બધા મને કરવા માંગો છો છે હું કહેવા માંગો છો

1027
00:55:32,000 --> 00:55:35,000
હું બહાર આકૃતિ હું શું માત્ર હિટ કરવા માંગો છો,

1028
00:55:35,000 --> 00:55:38,000
અને તેથી કે જે, હું કહી શકીએ હું પસંદ પંક્તિ માટે indexPath માંગો છો,

1029
00:55:38,000 --> 00:55:42,000
આ indexPath યાદ માત્ર કહે છે જ્યાં હું ફક્ત ક્લિક થાય,

1030
00:55:42,000 --> 00:55:47,000
અને પછી હું કહેવા હું બહાર આકૃતિ જ્યાં હું જાઉં છું કરવા માંગો છો માંગો છો.

1031
00:55:47,000 --> 00:55:50,000
આ destinationViewController કે, segue એક મિલકત છે.

1032
00:55:50,000 --> 00:55:53,000
કે સ્ક્રીન હું જાઉં છું છે,

1033
00:55:53,000 --> 00:55:56,000
તેથી હું જાણું છું કે સ્ક્રીન હું જાઉં છું DivisionsViewController કહેવાય છે

1034
00:55:56,000 --> 00:55:59,000
કારણ કે હું કે વર્ગ બનાવનાર,

1035
00:55:59,000 --> 00:56:02,000
અને તેથી હવે જો હું d.divisions કહેવું

1036
00:56:02,000 --> 00:56:06,000
હું હવે દૃશ્ય નિયંત્રક હું તેમની પાસે જવા વિશે છું એક મિલકત સુયોજિત છું.

1037
00:56:06,000 --> 00:56:10,000
આ રીતે હું એક સ્ક્રીન પરથી માહિતી અન્ય સ્ક્રીન પર મોકલવા છું.

1038
00:56:10,000 --> 00:56:13,000
>> માત્ર આ DivisionsViewController જોઈ

1039
00:56:13,000 --> 00:56:16,000
તમે અહીં જોઈ શકો છો કે જે ક. ફાઈલમાં

1040
00:56:16,000 --> 00:56:20,000
ત્યાં કે મિલકત વિભાગો છે, અને કે હું શું મૂળભૂત રચવાનું છું,

1041
00:56:20,000 --> 00:56:25,000
જેથી તે કેવી રીતે હું જાણું છું કે હું અનુરૂપ વિભાગો દર્શાવી રહ્યો છું

1042
00:56:25,000 --> 00:56:28,000
લીગ કે હું ક્લિક થાય, અને ફરી,

1043
00:56:28,000 --> 00:56:31,000
વાસ્તવિક ટેબલ દૃશ્ય ખૂબ જ ખૂબ લાગે છે, માત્ર તે જવાબ

1044
00:56:31,000 --> 00:56:34,000
3 સરળ તેમજ પ્રશ્નો ઓળખવા

1045
00:56:34,000 --> 00:56:37,000
શું થાય છે જ્યારે તમે આગળની સ્ક્રીન પર ખસેડો.

1046
00:56:37,000 --> 00:56:40,000
જસ્ટ અહીં અન્ય વસ્તુઓ એક દંપતિ.

1047
00:56:40,000 --> 00:56:43,000
તમે ટોચ પર અહીં નોંધ્યું છે કે બદલે કહેતા # સમાવેશ થાય છે

1048
00:56:43,000 --> 00:56:45,000
હવે હું કહી રહ્યો છું # આયાત કરો.

1049
00:56:45,000 --> 00:56:47,000
આ માત્ર એક વસ્તુ ઉદ્દેશ C-છે.

1050
00:56:47,000 --> 00:56:52,000
આયાત મૂળભૂત સમાવેશ થાય છે એક NICER આવૃત્તિ છે,

1051
00:56:52,000 --> 00:56:57,000
અને, ઉદાહરણ તરીકે, અમે જાણવા માગીએ વર્ગ શું છે જરૂર છે,

1052
00:56:57,000 --> 00:57:00,000
તેથી હું ફક્ત DivisionsViewController કહી શકો છો.

1053
00:57:00,000 --> 00:57:05,000
જો અમે અમારી સી. ફાઈલની standardio.c અંદર ન hashtag નહોતી

1054
00:57:05,000 --> 00:57:07,000
આ કમ્પાઈલર કોઈ વિચાર શું printf હતી.

1055
00:57:07,000 --> 00:57:12,000
તેવી જ રીતે, જો હું DivisionsViewController આયાત નથી

1056
00:57:12,000 --> 00:57:16,000
આ કમ્પાઈલર ખરેખર કોઈ વિચાર એક DivisionsViewController શું છે.

1057
00:57:16,000 --> 00:57:19,000
જસ્ટ ખાતરી કરો કે તમારી અલગ છે. મીટર ફાઈલોની અંદર તમે આયાત કરવા માટે ખાતરી કરો કે બનાવવા

1058
00:57:19,000 --> 00:57:25,000
લાગતાવળગતા. ક ફાઈલો કે જેથી કમ્પાઇલર જાણે શું થઈ રહ્યું છે.

1059
00:57:25,000 --> 00:57:31,000
>> છેલ્લે, એપલ શું આખરે કેટલાક વેબ દૃશ્ય મદદથી માહિતી થયેલ છે દર્શાવે નહિં,

1060
00:57:31,000 --> 00:57:35,000
અને તેથી એક વેબ દૃશ્ય એક પદાર્થ કે જેમાં તમે એમ્બેડ કરી શકે છે

1061
00:57:35,000 --> 00:57:37,000
તમારી એપ્લિકેશન ની અંદર થોડો વેબ બ્રાઉઝર.

1062
00:57:37,000 --> 00:57:40,000
બધા તમારે તમારું વેબ બ્રાઉઝર પર URL સપ્લાય કરવામાં આવે છે,

1063
00:57:40,000 --> 00:57:43,000
તેથી હું mlb.mlb.com પર જાઓ કરવા માંગો છો,

1064
00:57:43,000 --> 00:57:46,000
અને આ રીતે હું દરેક ટીમ માટે ઘર પાનું ઍક્સેસ કરી શકો છો,

1065
00:57:46,000 --> 00:57:49,000
અને તેથી આ URL માં પસાર કરીને

1066
00:57:49,000 --> 00:57:52,000
વેબ દૃશ્ય મારા માટે આ પ્રદર્શિત કરી શકો છો અને હું આસપાસ બ્રાઉઝ કરી શકો છો,

1067
00:57:52,000 --> 00:58:01,000
અને સિમ્યુલેટર એક કે દ્વારા વપરાશમાં છે.

1068
00:58:01,000 --> 00:58:03,000
હવે આ મારું plist હતી.

1069
00:58:03,000 --> 00:58:07,000
જો હું આ બટન પર ક્લિક કરો અને આ પણ મારું plist આવ્યા છે, અને આ સ્લાઇડિંગ નિયંત્રિત કરવામાં આવી હતી

1070
00:58:07,000 --> 00:58:09,000
તે segues વ્યાખ્યાયિત કરીને.

1071
00:58:09,000 --> 00:58:12,000
હું આ બટન પર ક્લિક કરો અને એક વધુ,

1072
00:58:12,000 --> 00:58:15,000
અને હવે અહીં મારા UIWebView કે જેથી માત્ર છે,

1073
00:58:15,000 --> 00:58:19,000
અહીં URL માટે વેબસાઇટ કે હું માત્ર જડિત છે,

1074
00:58:19,000 --> 00:58:21,000
અને હું ઉન્મત્ત કંઈપણ હેન્ડલ ન હતી.

1075
00:58:21,000 --> 00:58:24,000
આ રીતે વેબ પૃષ્ઠ પ્રદર્શિત કરવા માટે.

1076
00:58:24,000 --> 00:58:27,000
આ અહીં બટન જેવી વસ્તુઓ પણ મને આપવામાં આવે છે

1077
00:58:27,000 --> 00:58:33,000
તદ્દન મફત કારણ કે હું આ segues મદદથી સંબંધો વ્યાખ્યાયિત કર્યું છે.

1078
00:58:33,000 --> 00:58:37,000
>> કોઈપણ પ્રશ્ન છે? યાહ.

1079
00:58:37,000 --> 00:58:40,000
[વિદ્યાર્થી] તેથી જ્યારે તમે alloc વાપરવા માટે, મફત કંઈપણ તમને ક્યારેય છે?

1080
00:58:40,000 --> 00:58:43,000
બરાબર, જ્યારે તમે alloc અને init કૉલ તમે તેને મુક્ત નથી.

1081
00:58:43,000 --> 00:58:46,000
આઇઓએસ માટે તમે કે તમામ હેન્ડલ રહ્યું છે.

1082
00:58:46,000 --> 00:58:51,000
તે અદભૂત છે, અને તમે કોઈપણ નિયમો ન તોડી રહ્યા છો. યાહ.

1083
00:58:51,000 --> 00:58:54,000
[વિદ્યાર્થી] જો તમે વધુ ટીમો છે કે જે સ્ક્રીન પર ફિટ કરી શકે સમાવેશ થાય હતા,

1084
00:58:54,000 --> 00:58:58,000
તે આપોઆપ સ્ક્રોલ વિકલ્પ રહેશે, અથવા એ છે કે કંઈક તમે ઉમેરવાની જરૂર?

1085
00:58:58,000 --> 00:59:01,000
બરાબર, જો હું વધુ ટીમો હતી, ઉદાહરણ તરીકે, તે આપમેળે હેન્ડલ કરશે

1086
00:59:01,000 --> 00:59:04,000
મારા માટે સરકાવનાર, અને તમામ કામગીરી ચિંતા

1087
00:59:04,000 --> 00:59:08,000
વિશાળ ટેબલ સાથે પણ મને માટે સંપૂર્ણપણે નિયંત્રિત.

1088
00:59:08,000 --> 00:59:11,000
>> અન્ય પ્રશ્નો છે?

1089
00:59:11,000 --> 00:59:13,000
આ કોડ બધી પોસ્ટ કરવામાં રહ્યું છે.

1090
00:59:13,000 --> 00:59:16,000
અમે આ પ્રકારના વધુ નાના વિગતો થોડો ઉપર glossed,

1091
00:59:16,000 --> 00:59:19,000
પરંતુ જેવી વસ્તુઓ વેબ દેખાવ માટે કેટલાક ગુણધર્મો સુયોજિત

1092
00:59:19,000 --> 00:59:22,000
ફક્ત વસ્તુઓ છે કે જે તમે એપલની દસ્તાવેજીકરણ બ્રાઉઝ કરીને મેળવી શકો છો,

1093
00:59:22,000 --> 00:59:24,000
જે ખરેખર છે, ખરેખર સરસ રીતે બહાર નાખ્યો.

1094
00:59:24,000 --> 00:59:27,000
તેઓ નમૂનો એપ્લિકેશન્સ ઘણો અને ઉપયોગો ઉદાહરણ છે

1095
00:59:27,000 --> 00:59:34,000
વિવિધ API નો સમાવેશ થાય છે, તેથી ચોક્કસપણે તમે કરી શકો છો જો તે વાંચી જવું.

1096
00:59:34,000 --> 00:59:36,000
જસ્ટ કેટલીક મદદરૂપ કડીઓ તમે પર એક નજર શકો છો.

1097
00:59:36,000 --> 00:59:38,000
આ અમુક હાથમાં દસ્તાવેજીકરણ માર્ગદર્શનો છે.

1098
00:59:38,000 --> 00:59:41,000
URL ને ભારે છે, તેથી તેઓ ટૂંકા કરી રહ્યાં છો.

1099
00:59:41,000 --> 00:59:44,000
આ પ્રથમ એક દસ્તાવેજીકરણ સમગ્ર પુસ્તકાલય છે.

1100
00:59:44,000 --> 00:59:46,000
ત્યાં થોડી શોધ બાર છે, તેથી જો તમે લખેલું બટન શરૂ

1101
00:59:46,000 --> 00:59:50,000
તે તમને બધી વસ્તુઓ તમને એક બટન સાથે કરી શકો વિશે તમામ માહિતી આપવી શરૂ થશે.

1102
00:59:50,000 --> 00:59:53,000
હું પણ કોષ્ટક જુઓ પ્રોગ્રામિંગ માર્ગદર્શન નો સમાવેશ કર્યો છે.

1103
00:59:53,000 --> 00:59:56,000
તે ખૂબ વધુ વિગતવાર ટેબલ દૃશ્યો સંભાળે છે,

1104
00:59:56,000 --> 01:00:00,000
કેવી રીતે વસ્તુઓ કરવું જેવી ગતિશીલ કોષો અથવા ફેરફાર કોશિકાઓ ઉમેરવા અથવા તેને દૂર કરો.

1105
01:00:00,000 --> 01:00:02,000
>> ત્યાં નમૂના એપ્લિકેશન્સ ઓફ એપલ લોટ કે તમે બતાવવા માટે કે શું કેવી રીતે કરશે છે,

1106
01:00:02,000 --> 01:00:05,000
અને છેલ્લે, આ છેલ્લા એક હ્યુમન ઈન્ટરફેસ માર્ગદર્શિકા છે,

1107
01:00:05,000 --> 01:00:09,000
અને આ મૂળભૂત યુઆઇ ઘટકો કેટલાક ચર્ચા છે,

1108
01:00:09,000 --> 01:00:12,000
જેવી બાબતો એક બટન છે જે 4 પિક્સેલ 4 પિક્સેલ્સ નથી કરતી.

1109
01:00:12,000 --> 01:00:15,000
કે ખરાબ વિચાર છે, અને અન્ય વસ્તુઓ છે કે જે એપલ તમે ઇચ્છે છે

1110
01:00:15,000 --> 01:00:18,000
સારી ડિઝાઇન પ્રોત્સાહિત કરીએ છીએ.

1111
01:00:18,000 --> 01:00:23,000
>> કોઈપણ છેલ્લા પહેલાં અમે સમાપ્ત પ્રશ્નો છે?

1112
01:00:23,000 --> 01:00:27,000
તમામ હક, ચોક્કસપણે ચર્ચા કરવા પર ખાસ લેબલો હશે જઈને-we're માટે મફત લાગે.

1113
01:00:27,000 --> 01:00:30,000
અમે એક iOS પડશે, તેથી ચોક્કસપણે કે ઉપયોગ કરે છે મફત લાગે.

1114
01:00:30,000 --> 01:00:34,000
જો તમે પ્રોજેક્ટ પર તમારા સહપાઠીઓને સાથે કામ કરવા માંગો છો

1115
01:00:34,000 --> 01:00:37,000
મદદ અથવા કેટલાક રેન્ડમ iOS સામગ્રી આકૃતિ

1116
01:00:37,000 --> 01:00:40,000
મને ઇમેઇલ મફત લાગે, અને ચોક્કસપણે તમામ કોડ ઑનલાઇન કારણ કે વાંચી જવું

1117
01:00:40,000 --> 01:00:43,000
માત્ર સમય રસ અમે પ્રકારની વધુ ઉપર glossed

1118
01:00:43,000 --> 01:00:45,000
વસ્તુઓ ફાઇનર દાણાદાર વિગતો.

1119
01:00:45,000 --> 01:00:47,000
પરંતુ ન હોય તો, પછી તમારા iOS પ્રોજેક્ટ પર સારું નસીબ, હું અને આશા છે કે અમે હોય

1120
01:00:47,000 --> 01:00:53,000
એપ સ્ટોરમાં એક એપ્લિકેશન્સ મોટા ધસારો.

1121
01:00:53,000 --> 01:00:56,000
[CS50.TV]