1
00:00:00,000 --> 00:00:00,500

2
00:00:00,500 --> 00:00:10,960
[સંગીત વગાડવાનો]

3
00:00:10,960 --> 00:00:12,960
ROGER ZURAWICKI: હાય, મારું
નામ, રોજર Zurawicki છે

4
00:00:12,960 --> 00:00:16,410
અને હું આવરી આવશે
આ CS50 ઉલ્કા પરિસંવાદ.

5
00:00:16,410 --> 00:00:21,520
ઉલ્કા નવી ફ્રેમવર્ક છે
વેબ ઓફ નવી પ્રકારનો માટે સમર્પિત,

6
00:00:21,520 --> 00:00:25,220
જો PHP અરજીઓ ન બનાવવા
પાછળ આગળ પ્રકારની

7
00:00:25,220 --> 00:00:29,070
વેબ ઓફ અમે PHPP સેટમાં જોવા મળી હતી
પરંતુ વધુ ગતિશીલ જાવાસ્ક્રિપ્ટ

8
00:00:29,070 --> 00:00:31,370
વેબ ઓફ ભાગો.

9
00:00:31,370 --> 00:00:36,260
વસ્તુઓ ઉલ્કા કરી શકો
લાઈવ સુધારી સમાવેશ

10
00:00:36,260 --> 00:00:42,380
અને તરત જ વાતચીત
એ જ વેબસાઈટની વપરાશકર્તાઓ વચ્ચે.

11
00:00:42,380 --> 00:00:46,420
>> આ પરિસંવાદ માટે, અમે હોય
કોડ મારા GitHub પર આયોજન કર્યું હતું.

12
00:00:46,420 --> 00:00:49,690
જો તમે આ URL પર જાઓ અને તે ડાઉનલોડ કરી શકો છો.

13
00:00:49,690 --> 00:00:53,085
તમે ગિટ ઉપયોગ કેવી રીતે ખબર હોય,
તમે રીપોઝીટરી ક્લોન કરી શકો છો.

14
00:00:53,085 --> 00:00:55,460
તમે ઉપયોગ કરવા માટે કેવી રીતે ખબર નથી જો
Git અથવા GitHub ઉપયોગ કર્યો નથી,

15
00:00:55,460 --> 00:00:57,030
કે સંપૂર્ણપણે દંડ છે.

16
00:00:57,030 --> 00:01:00,480
હું ઝડપથી ખરેખર તમને બતાવશે
અમે GitHub જઈ શકો છો કેવી રીતે,

17
00:01:00,480 --> 00:01:03,604
અને કરવા માટે એક વિકલ્પ છે
અહિ એક ઝિપ ડાઉનલોડ કરો.

18
00:01:03,604 --> 00:01:06,770
જો તમે આ ડિરેક્ટરી ડાઉનલોડ એકવાર તમે
અમારી કોડ સાથે રમવાની શરૂ કરી શકો છો.

19
00:01:06,770 --> 00:01:10,200

20
00:01:10,200 --> 00:01:13,190
>> ઉલ્કા વિશે વધુ માહિતી
meteor.com પર મળી શકે છે.

21
00:01:13,190 --> 00:01:16,580
આ સેમિનાર ફોલ્ડરમાં, હું ખરેખર
અમે ઉપયોગ કરી શકો છો કેટલાક ઉલ્કા પ્રોજેક્ટ છે.

22
00:01:16,580 --> 00:01:20,380

23
00:01:20,380 --> 00:01:26,400
અમે હોય ફોલ્ડર્સ પૈકી એક અમારી
સેમિનાર પ્રોજેક્ટ todos એપ્લિકેશન છે.

24
00:01:26,400 --> 00:01:28,780
તેથી મને લાગ્યું કે હું તેને જાય તો,
ઉલ્કા સ્થાપિત હોય.

25
00:01:28,780 --> 00:01:35,690
જેથી ચલાવવા માટે, હું હમણાં જ ટાઇપ કરવાની જરૂર
ઉલ્કા અને ઉલ્કા સ્થાપિત કરશે.

26
00:01:35,690 --> 00:01:38,310
જેમ તમે જોઈ શકો, અમે હોય છે
અમે ઉલ્કા સ્થાપિત ખાતરી કરો.

27
00:01:38,310 --> 00:01:40,562
તેથી હું માત્ર જાઉં છું
તે એક વધુ સમય ચલાવો

28
00:01:40,562 --> 00:01:42,520
બનાવવા માટે ખાતરી છે કે ઉલ્કા
યોગ્ય રીતે સ્થાપિત થયેલ છે.

29
00:01:42,520 --> 00:01:46,370

30
00:01:46,370 --> 00:01:48,450
>> હું ઉલ્કા હોય છે, જ્યારે
સ્થાપિત, હું તમને બતાવી શકે

31
00:01:48,450 --> 00:01:53,760
ઉલ્કા સાઇટ્સ કેટલાક જીવંત જનતા
ઇન્ટરનેટ પર હમણાં લાઇવ જતા.

32
00:01:53,760 --> 00:01:57,990
હું અમારા એપ્લિકેશન એક ડેમો છે.

33
00:01:57,990 --> 00:02:00,740
તમે નીચેની URL આગળ ઍક્સેસ કરી શકો છો.

34
00:02:00,740 --> 00:02:06,350
આ શું કરવાની એપ્લિકેશન છે કે અમે
અમારા પરિસંવાદ ડિરેક્ટરીમાં હોય છે.

35
00:02:06,350 --> 00:02:09,940
આ માટેનું URL છે
rozu-rabbit.meteor.com.

36
00:02:09,940 --> 00:02:14,782
તમે જોશો કે ઉલ્કા ખરેખર ચાલશે
મફત તમારી ઉલ્કા પ્રોજેક્ટ હોસ્ટ.

37
00:02:14,782 --> 00:02:17,490
અને પરિસંવાદ ના અંતે,
તમે પણ આ કરવું કરવાનો પ્રયત્ન કરીશું.

38
00:02:17,490 --> 00:02:20,550

39
00:02:20,550 --> 00:02:22,160
>> આ યાદી કરવું એપ્લિકેશન છે.

40
00:02:22,160 --> 00:02:27,740
અને તમે સાઇન ઇન કરી શકો છો, બનાવી
એકાઉન્ટ્સ, અને કાર્યો ઉમેરો.

41
00:02:27,740 --> 00:02:30,020
તમને આની જેમ એક એકાઉન્ટ બનાવી શકો છો.

42
00:02:30,020 --> 00:02:33,050

43
00:02:33,050 --> 00:02:35,850
અને હવે, એક વખત તમે એક હોય
ખાતા, તમે ક્રિયાઓ ઉમેરી શકો છો.

44
00:02:35,850 --> 00:02:42,780
ઉદાહરણ તરીકે, કાર્યો પૈકીનું એક મેં
મારી લોન્ડ્રી પસંદ પણ જરૂર પડી શકે છે.

45
00:02:42,780 --> 00:02:45,160
અને તમે આ પર છો તો
સાઇટ ઓનલાઇન માટે, તમે પડશે

46
00:02:45,160 --> 00:02:49,790
વાસ્તવમાં પર આ ક્રિયા જોવા
વાસ્તવિક સમય માં તમારા કમ્પ્યુટર.

47
00:02:49,790 --> 00:02:53,760
>> હું તમારા ઝડપી ડેમો બતાવી શકે
ખોલીને rozu-સસલા કરીને આ ના

48
00:02:53,760 --> 00:02:56,700
એ જ URL સાથે અન્ય ટેબમાં.

49
00:02:56,700 --> 00:03:00,360
અને અમે તે જ માહિતી આવે કે જુઓ.

50
00:03:00,360 --> 00:03:02,240
અમે પણ તે ચાલી શકે
અલગ બ્રાઉઝર.

51
00:03:02,240 --> 00:03:03,420
હું સફારી માં ચલાવવા કહે છે.

52
00:03:03,420 --> 00:03:04,720
અમે લોગઇન નથી કરી રહ્યાં છે કે જે રીતે.

53
00:03:04,720 --> 00:03:07,750

54
00:03:07,750 --> 00:03:11,060
તેથી અમે તે જ ઉલ્કા હોય
એપ્લિકેશન, અને તે લાવે એક વાર,

55
00:03:11,060 --> 00:03:13,910
અમે એ જ માહિતી જોશો
અમે પ્રથમ એક માં હતી.

56
00:03:13,910 --> 00:03:16,710
જેમ તમે જોઈ શકો, હું અહીં લોગઇન નથી છું.

57
00:03:16,710 --> 00:03:20,000
અને જ્યારે પ્રેક્ષકો તપાસમાં માહિતી,
તે બધા બ્રાઉઝર્સ પર સુધારશે

58
00:03:20,000 --> 00:03:20,910
એક સાથે.

59
00:03:20,910 --> 00:03:23,740
આ ખરેખર એક છે
ઉલ્કા વિશે ઠંડી લક્ષણો.

60
00:03:23,740 --> 00:03:27,700
લગભગ કોઈ કામ સાથે, તમે
જીવંત અપડેટ એપ્લિકેશન છે

61
00:03:27,700 --> 00:03:31,240
કે બધા પર ફેરફારો
એક જ સમયે તમારા ઉપકરણો.

62
00:03:31,240 --> 00:03:36,690
>> હું અહીં ચેક બૉક્સ શકો તો
મારા કરવું યાદીમાં, અમે હોય છે,

63
00:03:36,690 --> 00:03:41,230
મારા અન્ય Chrome બ્રાઉઝર માં,
આઇટમ બંધ ચકાસાયેલ.

64
00:03:41,230 --> 00:03:42,605
અને આ તત્કાલ થાય.

65
00:03:42,605 --> 00:03:46,340

66
00:03:46,340 --> 00:03:47,280
અધિકાર છે.

67
00:03:47,280 --> 00:03:52,730
તેથી તે ઉલ્કા જેવો દેખાય
સ્થાપન હવે તૈયાર છે.

68
00:03:52,730 --> 00:03:57,000
તેથી હવે આપણે આ પર પાછા જાઓ દો
todos એપ્લિકેશન સ્થાનિક રીતે આ સ્કોર અને.

69
00:03:57,000 --> 00:04:01,599
>> જો તમે ઉલ્કા પ્રોજેક્ટ હોય, તો તમે કરી શકો છો
માત્ર આદેશ ઉલ્કા સાથે ચલાવવા.

70
00:04:01,599 --> 00:04:03,640
જો તમે આ, ઉલ્કા કરી એકવાર
અમુક તૈયારી કરશે

71
00:04:03,640 --> 00:04:06,120
તમામ ખાતરી કરવા માટે
તમારો કોડ ચેક માં છે.

72
00:04:06,120 --> 00:04:12,440
અને પછી તે કે જે તમને કહી શકશો આ
પ્રોજેક્ટ સેવા આપવા માટે તૈયાર છે.

73
00:04:12,440 --> 00:04:17,750
તમને પરવાનગી આપવા માટે જરૂર પડી શકે છે તમારા
ફાયરવોલ તમારા કમ્પ્યુટર બ્લોકો તમે જો.

74
00:04:17,750 --> 00:04:22,440
>> જેથી ઉલ્કા મને કહેવાની છે શું
હમણાં કે આ વેબસાઇટ પર છે

75
00:04:22,440 --> 00:04:26,100
મારું કમ્પ્યુટર માટે સ્થાનિક, હું જોઈ શકો છો
આ ઉલ્કા પ્રોજેક્ટ છે શું.

76
00:04:26,100 --> 00:04:29,290
હમણાં, મારા એપ્લિકેશન છે કે નોંધ
ઇન્ટરનેટ માટે સુલભ નથી.

77
00:04:29,290 --> 00:04:35,170
અમે તમારી ઉલ્કા લાવવા માટે કેવી આવરી પડશે
થોડી પાછળથી જીવંત સાઇટ પર એપ્લિકેશન.

78
00:04:35,170 --> 00:04:40,510
તેથી હું ફક્ત આ નકલ કરવા જઇ રહ્યો છું
URL હવે અને Google Chrome માં જાઓ.

79
00:04:40,510 --> 00:04:42,600
>> અને આ કરવા માટે છે
આ ઉદાહરણ પરથી યાદી.

80
00:04:42,600 --> 00:04:46,080
તમે તેઓ અમલમાં જોઈ શકે
અહીં થોડા વધુ સુવિધાઓ.

81
00:04:46,080 --> 00:04:49,210
અમે અમે, વિવિધ ટેબો હોય
એ જ એકાઉન્ટ લક્ષણો હોય છે,

82
00:04:49,210 --> 00:04:52,141
અને અમે નવા યાદીઓ ઉમેરી શકો છો.

83
00:04:52,141 --> 00:04:54,140
હવે, આ એક ખરેખર
ઉલ્કા વિશે ઠંડી લક્ષણ

84
00:04:54,140 --> 00:04:57,450
કે માત્ર આ કરી શકો આ છે
તમારા વેબ બ્રાઉઝર પર કામ,

85
00:04:57,450 --> 00:05:00,030
પરંતુ તમે પણ બનાવી શકો છો
મૂળ આઇફોન અને, Android

86
00:05:00,030 --> 00:05:02,990
PhoneGap કહેવાય સાધન મારફતે એપ્લિકેશન્સ.

87
00:05:02,990 --> 00:05:06,740
>> જેથી કેટલાક પ્રોજેક્ટો આવશે
ચલાવવા માટે પુનઃરૂપરેખાંકિત

88
00:05:06,740 --> 00:05:08,700
આ todos એપ્લિકેશન જેવી iOS, પર.

89
00:05:08,700 --> 00:05:14,780
તેથી હું શું કરવાની જરૂર બધા iOS માં ચલાવવા માટે
પછી ઉલ્કા, ચલાવો, અને iOS લખો આવેલ છે.

90
00:05:14,780 --> 00:05:17,540
અને હું ઉલ્કા, તે કરવા જ્યારે
ફરી પેકેજ તૈયાર કરશે.

91
00:05:17,540 --> 00:05:21,670
તે તૈયાર છે એક વાર અને પછી,, તે પડશે
મારા આદેશ પર આઇઓએસ સિમ્યુલેટર ભાર.

92
00:05:21,670 --> 00:05:24,745
તમે માત્ર iOS એપ્લિકેશન્સ ચાલી શકે છે નોંધ
તમે જો એક મેક કોમ્પ્યુટર હોય.

93
00:05:24,745 --> 00:05:27,650

94
00:05:27,650 --> 00:05:30,730
તમે પર તમારી એપ્લિકેશન્સ ચાલી શકે છે
તમામ પ્લેટફોર્મ પર Android.

95
00:05:30,730 --> 00:05:34,070

96
00:05:34,070 --> 00:05:38,290
>> તેથી હવે તમે જોઈ શકો કે મારા iPhone
સિમ્યુલેટર મારા સ્ક્રીન પર આવ્યા.

97
00:05:38,290 --> 00:05:40,370
અને માત્ર એક ક્ષણ,
તે એપ્લિકેશન સાથે લોડ કરશો.

98
00:05:40,370 --> 00:05:46,070

99
00:05:46,070 --> 00:05:48,490
અમે તેને માત્ર એક બીટ કરી તો
નાની સ્ક્રીન પર ફિટ

100
00:05:48,490 --> 00:05:50,780
અમે અમે અમારી આઇફોન એપ્લિકેશન છે જુઓ.

101
00:05:50,780 --> 00:05:53,220
અને માત્ર જેથી અમે નથી
ગેરસમજ મળી, ચાલો કરી દો

102
00:05:53,220 --> 00:05:59,790
અમે એ જ પર હોય ખાતરી
વેબસાઇટ, સ્થાનિક યજમાન 3000.

103
00:05:59,790 --> 00:06:03,490
>> તેથી અહીં એક ઉદાહરણ છે
મારી પાસે આ ઉલ્કા એપ્લિકેશનના,

104
00:06:03,490 --> 00:06:08,770
બંને પર ચાલી todos એપ્લિકેશન,
એક ફોન અને વેબ બ્રાઉઝર પર.

105
00:06:08,770 --> 00:06:10,770
અને હું સામગ્રી બદલી જ્યારે
વેબ બ્રાઉઝરમાં,

106
00:06:10,770 --> 00:06:12,675
તે તરત જ ફોન પર જાય છે.

107
00:06:12,675 --> 00:06:16,500
અને હું ફોન પર કંઈક કાઢી શકો છો,
અને તે વેબ બ્રાઉઝરમાં બદલે છે.

108
00:06:16,500 --> 00:06:21,050
>> હવે, સામાન્ય રીતે મૂળ બનાવવાની
iOS અથવા Android માટે ફોન એપ્લિકેશન,

109
00:06:21,050 --> 00:06:26,090
તમે જાવા અથવા ક્યાં ખબર જરૂર
ઉદ્દેશ સી આ ટેકનોલોજીને ઉલ્કા ઉપયોગો

110
00:06:26,090 --> 00:06:29,240
જાવાસ્ક્રિપ્ટ તરીકે ચલાવવા માટે પરવાનગી આપવા માટે
તમારી એપ્લિકેશન PhoneGap કહેવામાં આવે છે.

111
00:06:29,240 --> 00:06:31,320
શું તમારી એપ્લિકેશન અનિવાર્યપણે
છે એક વેબ બ્રાઉઝર છે.

112
00:06:31,320 --> 00:06:34,500
અને ઉલ્કા બધા સંભાળે
સંકળાયેલા મુશ્કેલ ભાગો

113
00:06:34,500 --> 00:06:39,820
માટે કે વેબ બ્રાઉઝર લાવવા માટે
તમારા iPhone અથવા તમારા Android ઉપકરણ.

114
00:06:39,820 --> 00:06:42,210
તમે તે જોઈ શકો છો આ
વપરાશકર્તા ઈન્ટરફેસ, સરળ છે

115
00:06:42,210 --> 00:06:45,290
અને તે જુએ છે અને ખૂબ લાગે
ખૂબ એક મૂળ એપ્લિકેશન જેવી.

116
00:06:45,290 --> 00:06:48,620
હું ઘરમાં કે જાઓ નોટિસ તો
સ્ક્રીન હવે, હું પણ એક ચિહ્ન મેળવવા.

117
00:06:48,620 --> 00:06:50,880
આ જેમ એક વેબસાઇટ નથી
તમે સફારી માં શોધી લેતો.

118
00:06:50,880 --> 00:06:51,860
આ તેની પોતાની એપ્લિકેશન છે.

119
00:06:51,860 --> 00:06:54,130
તમે સ્થાપિત કરી શકો છો અને
તમે ઇચ્છો તો તેને કાઢી.

120
00:06:54,130 --> 00:06:59,500

121
00:06:59,500 --> 00:07:04,436
>> અમે શું આ કોડ તમને બતાવવા થોડા સમય શકો
todos આ પ્રકારની માટે એપ્લિકેશન જેવો દેખાય છે.

122
00:07:04,436 --> 00:07:08,260
તમે todos ફોલ્ડરમાં જોવા,
તમે ઘણા ફોલ્ડર્સ છે જોશો.

123
00:07:08,260 --> 00:07:11,440
પરંતુ કોર્સ પર
આ પરિસંવાદ ના, અમે પડશે

124
00:07:11,440 --> 00:07:14,780
દરેક ફોલ્ડર માટે વપરાય છે તે સમજવા.

125
00:07:14,780 --> 00:07:17,830
માતાનો ટર્મિનલ જાય તેથી અમે
થોડી વધુ સારી ફાઇલોને જોઈ શકો છો.

126
00:07:17,830 --> 00:07:20,410
>> હું નિયંત્રણ દબાવો જાઉં છું
સી, સર્વર બંધ કરવા

127
00:07:20,410 --> 00:07:22,770
અને હવે હું પાછી todos એપ્લિકેશનમાં છું.

128
00:07:22,770 --> 00:07:26,660
હું જેમ, અહીં અલગ ફોલ્ડર્સ હોય
ક્લાઈન્ટ ફોલ્ડર, સર્વર ફોલ્ડર.

129
00:07:26,660 --> 00:07:30,500
અને આ ફોલ્ડર્સ ખાલી કે અર્થ
ક્લાઈન્ટ ફોલ્ડરમાં બધું

130
00:07:30,500 --> 00:07:32,630
તમારા વેબ બ્રાઉઝર પર ચલાવવામાં નહીં.

131
00:07:32,630 --> 00:07:35,530
સર્વર ફોલ્ડરમાં બધું
એક સર્વર પર ચલાવવામાં નહીં.

132
00:07:35,530 --> 00:07:38,100
>> શું હું નિર્દેશ કરવા માંગો છો
આઉટ અમે હતી શું કે છે

133
00:07:38,100 --> 00:07:42,140
અમે અમારી ફોન ચાલી હતી જ્યારે અને
અમારા વેબ બ્રાઉઝર, આ ક્લાઈન્ટો હતા.

134
00:07:42,140 --> 00:07:45,730
પરંતુ શું એક ચાલી રહ્યું
ટર્મિનલ, કે જે સર્વર છે.

135
00:07:45,730 --> 00:07:48,710
અમે જેમ, અન્ય ફોલ્ડર્સ હોય
લાઇબ્રેરી કોડ છે, જે lib,

136
00:07:48,710 --> 00:07:51,050
તમારા મદદગાર જેવી
કાર્યો, જે તમે કરી શકો છો

137
00:07:51,050 --> 00:07:53,710
ક્લાઈન્ટ અને સર્વર બંને પર વાપરો.

138
00:07:53,710 --> 00:07:55,820
અને પછી તમે એક જાહેર હોય
ફોલ્ડર અને સાધનો

139
00:07:55,820 --> 00:07:59,310
મેળવવામાં માટે જરૂરી ફોલ્ડર
તમારી છબીઓ અને અન્ય સીએસએસ લોડ.

140
00:07:59,310 --> 00:08:02,630

141
00:08:02,630 --> 00:08:09,360
>> તમે ઉલ્કા સ્થાપિત કરેલ હોય, અમે કરશે
ઉલ્કા માટે ટ્યુટોરીયલ સાથે ચાલુ રાખો.

142
00:08:09,360 --> 00:08:12,790
જો તમે આ URL પર જાઓ શકે છે
meteor.com/install,

143
00:08:12,790 --> 00:08:17,990
આદેશ વાક્ય વિચાર કે હું
ઉલ્કા સ્થાપિત કરે છે કે જે તમે જોવા મળ્યો છે.

144
00:08:17,990 --> 00:08:20,240
અમે પ્રથમ પસાર થશે
થોડા પગલાંઓ વધુ સારી વિચાર

145
00:08:20,240 --> 00:08:22,760
ઉલ્કા સ્થાપિત કરવા વિશે લાગે છે.

146
00:08:22,760 --> 00:08:28,000
>> પરંતુ પ્રથમ, હું તેને એ મહત્વનું છે લાગે છે
અમે જાવાસ્ક્રિપ્ટ એક થોડો સમીક્ષા કરો.

147
00:08:28,000 --> 00:08:32,360
તમે કેવી અમુક ઉદાહરણો બતાવવા માટે
અમારા સી જ્ઞાન ભાષાંતર કરી શકો છો

148
00:08:32,360 --> 00:08:34,950
જાવાસ્ક્રિપ્ટ કરો, હું કર્યું
થોડા ઉદાહરણો બનાવી છે.

149
00:08:34,950 --> 00:08:36,940
તેઓ જેએસ ડિરેક્ટરીમાં હોય છે.

150
00:08:36,940 --> 00:08:41,750
આ પરિસંવાદો તમે ફોલ્ડર તો એટલી
જેએસ કહેવાય ફોલ્ડર છે, જુઓ.

151
00:08:41,750 --> 00:08:44,540
અને અહીં, અમે થોડા ઉદાહરણો છે.

152
00:08:44,540 --> 00:08:50,120
>> માતાનો પ્રથમ ખોલો
ઉદાહરણ અને ખૂબ જ ઝડપથી જુઓ.

153
00:08:50,120 --> 00:08:53,980
શું આપણે જોઈ તમારા પ્રમાણભૂત છે
વિશ્વમાં આદેશ હેલો.

154
00:08:53,980 --> 00:08:56,520
તમે સી નોટિસ કે જે તમે
ખૂબ થોડા લીટીઓ છે.

155
00:08:56,520 --> 00:09:00,490
અને CS50 વિદ્યાર્થીઓ જાણીએ છીએ,
અમે એક મુખ્ય કાર્ય જરૂર છે,

156
00:09:00,490 --> 00:09:05,730
અને અમે પ્રમાણભૂત સમાવેશ થાય છે
I / O printf કૉલ કરવા માટે પુસ્તકાલય.

157
00:09:05,730 --> 00:09:09,320
>> માતાનો જાવાસ્ક્રિપ્ટ સરખાવે કેવી જુઓ.

158
00:09:09,320 --> 00:09:11,560
હું ex1.js. ખોલવા જઈ રહ્યો છું

159
00:09:11,560 --> 00:09:14,650
આઉટ ટિપ્પણી કરી છે તે આ છે
કોડ જેવો દેખાશે સી,

160
00:09:14,650 --> 00:09:17,550
અને નીચે લીટી બધા છે
તમે નોડ માં રન કરવા પડે છે.

161
00:09:17,550 --> 00:09:20,452
તમે, તમે એક મુખ્ય કાર્ય જરૂર ના હોય
કોઈપણ ફાઈલો સમાવેશ કરવાની જરૂર નથી,

162
00:09:20,452 --> 00:09:21,660
અને તમે પાછા આવવા જરૂર નથી.

163
00:09:21,660 --> 00:09:23,810
તમે માત્ર console.log ફોન કરો.

164
00:09:23,810 --> 00:09:26,370
આ તમારા printf ની સમકક્ષ છે.

165
00:09:26,370 --> 00:09:29,310
>> અને તે જ લે
દલીલો કરશે printf.

166
00:09:29,310 --> 00:09:33,870
અને તેને ચલાવવા માટે ક્રમમાં,
તેના બદલે ex1 કરો ચલાવવાનો,

167
00:09:33,870 --> 00:09:38,930
તમે માત્ર નોડ ex1.js. ફોન કરશે

168
00:09:38,930 --> 00:09:41,830
તમે પછી નોડ લખી અને
ફાઇલ અને ચલાવવા નહીં.

169
00:09:41,830 --> 00:09:43,580
તે સંકલિત ન મળી નથી.

170
00:09:43,580 --> 00:09:45,970
જાવાસ્ક્રિપ્ટ એક અર્થઘટન ભાષા છે.

171
00:09:45,970 --> 00:09:49,150
તેથી તે છે જરૂરી નથી
ચલાવવા રહ્યું પહેલા સંકલિત.

172
00:09:49,150 --> 00:09:53,450
હું ex1.c ચલાવવા માગતા હતા,
હું તેને પ્રથમ વખત કરી છે

173
00:09:53,450 --> 00:09:59,160
અને પછી હું એક્ઝેક્યુટેબલ ચાલી શકે છે
એ જ આઉટપુટ મળે છે.

174
00:09:59,160 --> 00:10:02,460
>> માતાનો ઝડપથી કેટલાક આવરી દો
અન્ય જાવાસ્ક્રિપ્ટ ખ્યાલો.

175
00:10:02,460 --> 00:10:04,490
ઉદાહરણ બે જુઓ.

176
00:10:04,490 --> 00:10:14,690
Ex2.js માં, ex2.c માં, અમે કરી શકો છો
અમે કેટલાક કોડ છે કે જુઓ.

177
00:10:14,690 --> 00:10:16,550
મને ઝડપથી કરવા જઈએ
એક સારી લખાણ સંપાદક

178
00:10:16,550 --> 00:10:18,400
કે આ બતાવશે
નવી પંક્તિઓ થોડી વધુ સારી.

179
00:10:18,400 --> 00:10:21,760

180
00:10:21,760 --> 00:10:22,380
અધિકાર છે.

181
00:10:22,380 --> 00:10:24,190
અહીં અમે ઉદાહરણ 2.c. હોય

182
00:10:24,190 --> 00:10:27,360
અહીં અમે વિવિધ પ્રકારની હોય
કે અમે બહાર છાપવા કરી રહ્યાં છો.

183
00:10:27,360 --> 00:10:30,880
આપણે જાણીએ છીએ અને, printf લે
વિવિધ ટકા દલીલો

184
00:10:30,880 --> 00:10:34,050
માહિતી વિવિધ ટુકડાઓ ઍક્સેસ કરવા.

185
00:10:34,050 --> 00:10:36,840
અમે પ્રિન્ટ માંગો છો તો
શબ્દમાળા, અમે% s ફોન કરો.

186
00:10:36,840 --> 00:10:40,390
અમે એક ફ્લોટિંગ ફોન કરવા માંગો છો,
બિંદુ નંબર, અમે% એફ કહેવાય.

187
00:10:40,390 --> 00:10:45,810
અને એક ફોન કરવા કોઈ સરળ માર્ગ છે
તેની સાચી કે ખોટી કિંમત દ્વારા બુલિયન.

188
00:10:45,810 --> 00:10:50,760
તમે% d નો ઉપયોગ, તો તમે મેળવી શકો છો
એક 0 કે ખોટું અને સાચું માટે 1.

189
00:10:50,760 --> 00:10:53,270
>> જાવાસ્ક્રિપ્ટ અમારા માટે થોડી NICER છે.

190
00:10:53,270 --> 00:10:57,740
જાવાસ્ક્રિપ્ટ, ચાલો થોડા જોવા દો
તફાવતો આપણે આ ફાઈલમાં હોય છે.

191
00:10:57,740 --> 00:11:05,790
પ્રથમ, તમે સી અમે હોય કે નોટિસ
એક પ્રકાર સાથે દરેક ચલ પ્રારંભ.

192
00:11:05,790 --> 00:11:06,940
એસ ચાર રચે સ્ટાર છે.

193
00:11:06,940 --> 00:11:08,930
તે સ્ટ્રિંગ છે, અને તે
બીજા કોઈપણ પ્રકારની હોઈ શકે.

194
00:11:08,930 --> 00:11:10,450
એન ફ્લોટ છે.

195
00:11:10,450 --> 00:11:11,780
બી એક bool છે.

196
00:11:11,780 --> 00:11:14,220
>> પરંતુ જાવાસ્ક્રિપ્ટ,
ગતિશીલ પ્રકારના હોય છે.

197
00:11:14,220 --> 00:11:16,400
એટલે કે, તમે ન કરતા કે જે થાય
જાવાસ્ક્રિપ્ટ કહેવું જરૂર

198
00:11:16,400 --> 00:11:17,860
તમારા ચલો શું હશે પ્રકારો.

199
00:11:17,860 --> 00:11:22,730
તમે માત્ર કહે ચલ માટે var, નામ
ચલ છે, અને પછી તેની કિંમત.

200
00:11:22,730 --> 00:11:24,690
તેથી એક વાર ખરેખર કંઈપણ હોઈ શકે છે.

201
00:11:24,690 --> 00:11:25,640
તે સ્ટ્રિંગ બની શકે છે.

202
00:11:25,640 --> 00:11:27,300
તે એક અપૂર્ણાંક બિંદુ નંબર બની શકે છે.

203
00:11:27,300 --> 00:11:28,560
તે એક અક્ષર હોઈ શકે છે.

204
00:11:28,560 --> 00:11:31,250
તે બુલિયન બની શકે છે.

205
00:11:31,250 --> 00:11:34,380
અને કન્સોલ લોગ અલગ થોડી કામ કરે છે.

206
00:11:34,380 --> 00:11:37,340
તમે છાપવાનો કરવા માંગો છો,
સંખ્યાબંધ, તમે% ડી ફોન કરો.

207
00:11:37,340 --> 00:11:41,740
પરંતુ મોટા ભાગના કિંમતો બની શકે
માત્ર દંડ શબ્દમાળાઓ તરીકે મુદ્રિત.

208
00:11:41,740 --> 00:11:46,220
>> માતાનો નોડ માં આ સ્કોર દો
શું થશે તે જોવા માટે.

209
00:11:46,220 --> 00:11:51,880
હું નોડ ex2.js ફોન કરી શકો છો
અને અમે printf વિચાર

210
00:11:51,880 --> 00:11:56,870
કિંમતો CS50, એન તરીકે સાથે
આ અપૂર્ણાંક બિંદુ નંબર,

211
00:11:56,870 --> 00:12:00,620
અને પછી બુલિયન તરીકે બી
સાચી શબ્દમાળા રૂપાંતરિત.

212
00:12:00,620 --> 00:12:03,830
શું આપણે ઉદાહરણ 2.c કરવામાં તો શું?

213
00:12:03,830 --> 00:12:09,630
વેલ, અમે હજુ પણ કેટલાક હોય
printf સાથે વધુ annoyances.

214
00:12:09,630 --> 00:12:13,110
નોટિસ આ અપૂર્ણાંક બિંદુ કે
સંખ્યા યોગ્ય રીતે ફોર્મેટ કરી શકાય છે,

215
00:12:13,110 --> 00:12:18,120
અને તે બુલિયન ખાલી ન કરી શકે
સાચું કે ખોટું તરીકે પ્રદર્શિત કરી.

216
00:12:18,120 --> 00:12:18,620
અધિકાર છે.

217
00:12:18,620 --> 00:12:22,680
હવે આપણે ઉદાહરણ ત્રણ જુઓ.

218
00:12:22,680 --> 00:12:26,470
ઉદાહરણ ત્રણ, અમે દર્શાવે છે
તમે લૂપ માટે ઉપયોગ કરશે કેવી રીતે.

219
00:12:26,470 --> 00:12:27,630
હકીકતમાં, તે ખૂબ જ સરળ છે.

220
00:12:27,630 --> 00:12:31,430
વિશે સરસ વસ્તુઓ છે કે
જાવાસ્ક્રિપ્ટ તે સી આધારિત છે કે છે.

221
00:12:31,430 --> 00:12:33,920
તે અર્થ એ થાય કે ઘણો તમારા
કોડ ખૂબ સમાન દેખાશે

222
00:12:33,920 --> 00:12:36,490
અને ખૂબ જ લાગે છે.

223
00:12:36,490 --> 00:12:39,220
લૂપ માટે, આ જ વસ્તુ માં
કે ખરેખર અહીં બદલી નાંખી છે

224
00:12:39,220 --> 00:12:41,840
તેને બદલે પૂર્ણાંક હું ના હોય, અમે હું var હોય છે.

225
00:12:41,840 --> 00:12:45,470
અમે હજુ કદર માટે સોંપી શકો
શૂન્ય, તે પાંચ કરતા ઓછી છે કે તપાસો

226
00:12:45,470 --> 00:12:49,390
અને એક પછી તેને વધારતી
આ ++ ઓપરેટર સાથે.

227
00:12:49,390 --> 00:12:56,286
અમે હું પર console.log કૉલ, અને તે
અમને દરેક લીટી સાથે સંખ્યાબંધ છાપશે.

228
00:12:56,286 --> 00:12:58,410
માતાનો ઝડપથી ખરેખર ચલાવવા દો
તે આઉટપુટો તે જોવા માટે.

229
00:12:58,410 --> 00:13:02,320

230
00:13:02,320 --> 00:13:03,880
અમે દરેક લાઇન એક નવા નંબર મેળવવા.

231
00:13:03,880 --> 00:13:06,920
અન્ય વસ્તુ હું તમને જોઈતા
console.log સાથે નોટિસ

232
00:13:06,920 --> 00:13:09,960
તમે લખવા માટે ન હતી છે
નવી લાઇન માટે બેકસ્લેશ એ.

233
00:13:09,960 --> 00:13:12,480
Console.log છાપશે
તેની પોતાની લીટી પર બધું.

234
00:13:12,480 --> 00:13:14,585
કે સરસ લક્ષણ છે
જાવાસ્ક્રિપ્ટ અમને આપે છે.

235
00:13:14,585 --> 00:13:18,440

236
00:13:18,440 --> 00:13:22,600
>> હવે આપણે ઉદાહરણ ચાર ખોલો.

237
00:13:22,600 --> 00:13:28,710
ઉદાહરણ ચાર માં, પ્રથમ સી,
અમે થોડા કાર્યો ફોન આવે.

238
00:13:28,710 --> 00:13:33,290
આપણે જાહેર હોય છે કે નોટિસ
કાર્યો અમે મુખ્ય તેમને ઉપયોગ પહેલાં.

239
00:13:33,290 --> 00:13:37,250
અમે હોય તો મુખ્ય પ્રથમ અને
પછી ઉમેરો અને પછી ઊંચા, બનાવવા,

240
00:13:37,250 --> 00:13:39,540
રણકાર, અથવા GCC કરશે
અમને કહેતા ભૂલ આપી

241
00:13:39,540 --> 00:13:41,060
તે ઉચ્ચ શું છે ખબર નથી કે.

242
00:13:41,060 --> 00:13:42,780
તે શું એડ ખબર નથી.

243
00:13:42,780 --> 00:13:46,480
સી તેથી, તમે વિશે picky હોય છે
તમે તમારા કાર્યો કૉલ જેમાં ક્રમમાં.

244
00:13:46,480 --> 00:13:49,220

245
00:13:49,220 --> 00:13:51,310
>> માતાનો તમે કેવી રીતે કરી શકો જુઓ
જાવાસ્ક્રિપ્ટ આવું.

246
00:13:51,310 --> 00:13:56,060
અમે વિવિધ ફાઈલો હોય ત્યાં કારણ
આ કરવા માટે થોડા અલગ માર્ગો છે.

247
00:13:56,060 --> 00:13:58,950
એક રીતે ખૂબ ખૂબ છે
સીધો અનુવાદ.

248
00:13:58,950 --> 00:14:02,180
સી કાર્યો કારણ
પ્રકારો પરત, અને જાવાસ્ક્રિપ્ટ

249
00:14:02,180 --> 00:14:05,210
ખરેખર ખબર કે કાળજી કરતું નથી
તમે પાછા આવી ટાઇપ તે વિષે,

250
00:14:05,210 --> 00:14:06,300
તમે એક પ્રકાર લખો નહિં.

251
00:14:06,300 --> 00:14:08,100
તેની જગ્યાએ, તમે માત્ર જરૂર
કાર્ય લખવા માટે,

252
00:14:08,100 --> 00:14:11,180
અને બધું સુંદર છે
પહેલાં જેવા જ ખૂબ.

253
00:14:11,180 --> 00:14:14,630
>> તમે સાઇન જેમ એક ચલ હોય ત્યારે
અમે ફક્ત એક્સ અને વાય લખવા માટે જરૂર, ઉમેરો.

254
00:14:14,630 --> 00:14:16,060
અમે એક્સ પૂર્ણાંક છે કહેવું જરૂર નથી.

255
00:14:16,060 --> 00:14:18,940
અમે વાય પૂર્ણાંક કહેવું જરૂરી નથી.

256
00:14:18,940 --> 00:14:21,030
અમે એ જ વાક્યરચના સાથે આવો.

257
00:14:21,030 --> 00:14:24,230
ઉચ્ચ માટે, અમે સાથે જાહેર
તેના બદલે રદબાતલ કાર્ય.

258
00:14:24,230 --> 00:14:26,110
નોટિસ કે નહીં તે
તે રદબાતલ અથવા બિન રદબાતલ છે

259
00:14:26,110 --> 00:14:28,380
તે હજુ બધા જ કાર્ય છે.

260
00:14:28,380 --> 00:14:32,440
અને અમે ખાલી મૂકી નથી
કૌંસ માં કંઈપણ,

261
00:14:32,440 --> 00:14:34,690
અને તે સી કોડ જેવા ખૂબ ખૂબ લાગે છે.

262
00:14:34,690 --> 00:14:37,460
અને નીચે, અમે નીચે તેને કહી શકો છો.

263
00:14:37,460 --> 00:14:42,730
>> અમે ઉદાહરણ 4 બી જોવા, અમે નોટિસ
કે હું અમુક વસ્તુઓ બદલ્યું.

264
00:14:42,730 --> 00:14:45,340
હું બદલ્યું આ જ વસ્તુ
ખરેખર છતાં ક્રમ છે.

265
00:14:45,340 --> 00:14:47,340
અમે એ જ હોય
કાર્યો, પરંતુ હવે તેઓ છો

266
00:14:47,340 --> 00:14:52,200
તેઓ વપરાતા રહ્યા છો પછી જાહેર કર્યું
console.log અને લીટીઓ 18, 19 પર ઉચ્ચ.

267
00:14:52,200 --> 00:14:54,740
તમે સી આ હતી છો,
ભૂલ ફેંકવું કરશે બનાવે છે.

268
00:14:54,740 --> 00:14:56,070
અહીં, આ માત્ર દંડ કામ કરે છે.

269
00:14:56,070 --> 00:15:01,935
અને હું દ્વારા તમે આ બતાવી શકે
4 બી ઉદાહરણ પર નોડ કહે છે.

270
00:15:01,935 --> 00:15:05,350

271
00:15:05,350 --> 00:15:10,130
>> અમે વિધેયો કૉલ કરી શકો બીજી રીતે
ચલો તરીકે કાર્ય કરે સાચવીને છે.

272
00:15:10,130 --> 00:15:13,790
જેમ હું એક ચલ, જણાવ્યું હતું
કોઈપણ પ્રકારની હોઈ શકે છે.

273
00:15:13,790 --> 00:15:16,720
એક ચલ આ પ્રકારના એક
હોઈ શકે છે એક કાર્ય છે.

274
00:15:16,720 --> 00:15:19,800
તમે ઉદાહરણ જોવા તેથી જો
હું બદલ્યું છે તે 4C,

275
00:15:19,800 --> 00:15:24,320
અહીં var બદલે કાર્ય ઉમેરો ની ઉમેરવા છે.

276
00:15:24,320 --> 00:15:26,807
અને હવે એક કાર્ય બરાબર ઉમેરો.

277
00:15:26,807 --> 00:15:28,140
અહીં આ કાર્ય અનામિક છે.

278
00:15:28,140 --> 00:15:33,346
તે કોઇ નામ ધરાવે છે, તેથી તે માત્ર છે
કાર્ય અને પછી કૌંસ.

279
00:15:33,346 --> 00:15:35,220
તે પછી વાક્યરચના
બદલી, પણ તમે એ નથી

280
00:15:35,220 --> 00:15:38,300
ધ્યાનમાં રાખવા છે કે
શું તમે ખરેખર છો કે ચલ હોય

281
00:15:38,300 --> 00:15:42,940
એડ માં કાર્ય સ્ટોર, અને એક
તમે ઊંચી માં સ્ટોર કરી રહ્યાં છે કે ચલ.

282
00:15:42,940 --> 00:15:47,620
>> ઉમેરો અને ઊંચા હવે ચલો છે કારણ
અને ન કાર્યો, કંઈક બદલે છે.

283
00:15:47,620 --> 00:15:50,190
આ હું જોઈ એક સામાન્ય ભૂલ છે
લોકોના જાવા ઘણો,

284
00:15:50,190 --> 00:15:52,410
અને કંઈક ધ્યાનમાં રાખવા.

285
00:15:52,410 --> 00:15:54,365
હું આ ચલાવો ત્યારે, ચાલો જુઓ શું થાય દો.

286
00:15:54,365 --> 00:15:57,410

287
00:15:57,410 --> 00:15:58,230
હું એક ભૂલ મળી.

288
00:15:58,230 --> 00:16:01,000
તે આ બિંદુએ અવ્યાખ્યાયિત કહેતા છે.

289
00:16:01,000 --> 00:16:03,520
તેથી તે તેને કહેતા છે
છે ઉમેરવા શું ખબર નથી.

290
00:16:03,520 --> 00:16:06,010
>> હવે નથી એક આવે ઉમેરી કારણ
કાર્ય, ઉમેરો એક ચલ છે.

291
00:16:06,010 --> 00:16:10,100
અને તમે ખરેખર નથી આપવામાં આવ્યા છે
તમે તેને ઉપયોગ કરવામાં આવે ત્યારે હજી નીચેની ઉમેરો.

292
00:16:10,100 --> 00:16:14,460
કે જ્યાં જો, ઉદાહરણ 4d, માટે લાવે
તમે વિધેયો તરીકે ચલો વાપરવા માંગતા,

293
00:16:14,460 --> 00:16:17,210
તમે માત્ર તેની ખાતરી કરવા માટે જરૂર છે કે તેઓ
તેઓ ઉપયોગ કરી રહ્યા છો તે પહેલાં કિંમત મળે છે.

294
00:16:17,210 --> 00:16:20,200

295
00:16:20,200 --> 00:16:23,420
>> માતાનો પછી દાખલા થી પાંચ પર ખસેડો.

296
00:16:23,420 --> 00:16:27,390
અહીં, અમે વિશે વાત
સી સી માં સ્ટ્ર્ક્ટ્સ, સ્ટ્ર્ક્ટ્સ

297
00:16:27,390 --> 00:16:30,320
તેમને આ સુધારેલ માળખું હોય
જો તમારે તેમની જાહેર હોય છે, કારણ કે

298
00:16:30,320 --> 00:16:33,050
તમે તેનો ઉપયોગ કરતાં પહેલાં, અને
તમે મને એક વિદ્યાર્થી હોય છે,

299
00:16:33,050 --> 00:16:36,645
અને દરેક વિદ્યાર્થી બરાબર છે
એક નામ, એક વર્ષ, એક લિંગ.

300
00:16:36,645 --> 00:16:37,770
તે તેમને બધા હોય છે.

301
00:16:37,770 --> 00:16:42,280
તે અન્ય કોઇ કિંમતો હોઈ શકે નહિં,
અને તેઓ ચોક્કસ પ્રકારના હોય છે.

302
00:16:42,280 --> 00:16:47,540
>> પછી અમે પ્રારંભ શકો
આ સરસ વાક્યરચના માં સ્ટ્રક્ટ

303
00:16:47,540 --> 00:16:49,470
તે ક્રમ જાણે છે.

304
00:16:49,470 --> 00:16:51,460
તેથી તે રોજર એક નામ છે કે જાણે છે.

305
00:16:51,460 --> 00:16:54,060
તે 2016 એક છે કે જાણે
વર્ષ અને એમ એક લિંગ છે

306
00:16:54,060 --> 00:16:58,200
અમે તેને આ જણાવ્યું કારણ
યાદી સ્ટ્રક્ટ વિદ્યાર્થી છે.

307
00:16:58,200 --> 00:17:01,607
અને પછી તમે છાપી શકો છો
તે s.name ઍક્સેસ.

308
00:17:01,607 --> 00:17:03,690
અમે કેવી રીતે છો માતાનો જોવા દો
જાવાસ્ક્રિપ્ટ કરો કે રૂપાંતરિત કરો.

309
00:17:03,690 --> 00:17:06,400

310
00:17:06,400 --> 00:17:09,790
હવે એક છે કે ઓ નોટિસ
ચલ, અને કોઈ પ્રકાર છે.

311
00:17:09,790 --> 00:17:10,920
તે ફરીથી માત્ર એક વાર છે.

312
00:17:10,920 --> 00:17:14,480
તે તો કોઈ વાંધો નથી, કારણ કે
આ ચલ પ્રકાર, નિર્દેશક છે

313
00:17:14,480 --> 00:17:17,440
તે સ્ટ્રક્ટ, અથવા અન્ય કંઈપણ છે.

314
00:17:17,440 --> 00:17:19,650
અમે થોડા અલગ વાક્યરચના છે.

315
00:17:19,650 --> 00:17:21,890
આ વાક્યરચના પદાર્થ વાક્યરચના છે.

316
00:17:21,890 --> 00:17:24,400
>> તમને JSON માં તે જોઈ હોય શકે.

317
00:17:24,400 --> 00:17:27,780
JSON ખરેખર માટે વપરાય
જાવાસ્ક્રિપ્ટ ઑબ્જેક્ટ નોટેશન.

318
00:17:27,780 --> 00:17:31,240
આ તમને વ્યાખ્યાયિત કેવી રીતે છે
જાવાસ્ક્રિપ્ટ પદાર્થો.

319
00:17:31,240 --> 00:17:34,500
અમે, કે જે એક કી હોય
નામ જેવું મૂલ્ય,.

320
00:17:34,500 --> 00:17:37,680
અને અમે તેના પર કિંમતો આપી
કોલોન ની બીજી બાજુ.

321
00:17:37,680 --> 00:17:41,850
અને ધ્યાનમાં રાખવા એક વસ્તુ તમને છે
એક નામ અને એક વર્ષ હોય તે જરૂરી નથી

322
00:17:41,850 --> 00:17:42,980
અને એક પદાર્થ માટે એક લિંગ.

323
00:17:42,980 --> 00:17:44,570
એક પદાર્થ કોઈ કિંમતો હોઈ શકે છે.

324
00:17:44,570 --> 00:17:46,920
તે તમે ઇચ્છો તરીકે ઘણા હોઈ શકે છે.

325
00:17:46,920 --> 00:17:50,375
>> અમે ફક્ત આ વસ્તુઓ વાપરી શકો છો
તે જ રીતે આપણે, s.name સ્ટ્રક્ટ ઉપયોગ કરશે.

326
00:17:50,375 --> 00:17:53,810

327
00:17:53,810 --> 00:17:57,080
અમે ઝડપથી ખરેખર તે ચાલી શકે
નોડ ઉદાહરણ 5.c. કરવાથી

328
00:17:57,080 --> 00:18:00,320

329
00:18:00,320 --> 00:18:02,520
અમે ખરેખર નોડ એક સી ફાઈલ ચાલી શકતું નથી.

330
00:18:02,520 --> 00:18:03,654
તે સી શું છે ખબર નથી.

331
00:18:03,654 --> 00:18:04,695
તે માત્ર ત્યારે જ જાવાસ્ક્રિપ્ટ જાણે છે.

332
00:18:04,695 --> 00:18:09,865
આપણે ex5.js ચલાવો ત્યારે અમે વિચાર
અમે અપેક્ષા કે જે કિંમત છે,.

333
00:18:09,865 --> 00:18:13,490

334
00:18:13,490 --> 00:18:15,980
>> ઉદાહરણ છ પર ખસેડો.

335
00:18:15,980 --> 00:18:18,930
અહીં હું માત્ર થોડી વાત કરવા માંગો છો
જાવાસ્ક્રિપ્ટ એરે વિશે થોડી વધુ

336
00:18:18,930 --> 00:18:20,930
તેઓ થોડી છો કારણ કે
તમે છો તેના કરતાં અલગ

337
00:18:20,930 --> 00:18:26,940
સી એરે notated રહ્યા માં ઉપયોગ થાય છે,
ન સી જેવા કૌંસ સાથે,

338
00:18:26,940 --> 00:18:28,640
આ સર્પાકાર કૌંસ, પરંતુ કૌંસ સાથે.

339
00:18:28,640 --> 00:18:32,150
તમને ખાલી એરે હોય શકે છે,
વાક્ય ચાર આગમન જેવું.

340
00:18:32,150 --> 00:18:34,680
તમને એરે હોઇ શકે
બહુવિધ કિંમતો સાથે.

341
00:18:34,680 --> 00:18:39,790
અને તમે તેમને ઍક્સેસ
સી માં ફક્ત એક જ રસ્તો

342
00:18:39,790 --> 00:18:42,990
>> સાત વાક્ય, બધું
ખૂબ સરળ લાગે છે.

343
00:18:42,990 --> 00:18:45,390
એક નાની તફાવત વાક્ય 10 ખાતે અહીં છે.

344
00:18:45,390 --> 00:18:48,620
જે રીતે તમે એક ની લંબાઈ વિચાર
અરે માત્ર લંબાઈ ફોન કરીને છે.

345
00:18:48,620 --> 00:18:50,620
ઝાકઝમાળ ખરેખર બની શકે
એક પદાર્થ જેવી સારવાર,

346
00:18:50,620 --> 00:18:54,960
અને આ પદાર્થ લંબાઇ મિલકત ધરાવે
તમે તેને લંબાઈ વિચાર કૉલ છે.

347
00:18:54,960 --> 00:18:57,350
આ અલગ છે કે નોટિસ
સી, કારણ સી તમને

348
00:18:57,350 --> 00:19:01,600
લંબાઈ ખબર હોય છે
સમય આગળ તમારા પદાર્થ.

349
00:19:01,600 --> 00:19:04,700
>> એરે વિશે ખૂબ બીજા સરસ વસ્તુ
તમે વિવિધ પ્રકારો હોય શકે છે.

350
00:19:04,700 --> 00:19:07,470
તમે સી એક એરે હોય છે, ત્યાં
ચોક્કસ મૂલ્ય એરે હોય છે,

351
00:19:07,470 --> 00:19:11,900
એક સ્ટ્રક્ટ નિર્દેશક ક્યાં
અથવા [અશ્રાવ્ય] તરે અથવા.

352
00:19:11,900 --> 00:19:13,700
અહીં, તમે અલગ અલગ કિંમતો હોઈ શકે છે.

353
00:19:13,700 --> 00:19:17,560
હું પ્રથમ એક અપૂર્ણાંક બિંદુ નંબર હતો,
પછી બુલિયન, પછી બીજા પૂર્ણાંક.

354
00:19:17,560 --> 00:19:19,670
અને ખરેખર, તેઓ ખૂબ પ્રકારના બદલી શકો છો.

355
00:19:19,670 --> 00:19:21,220
16 લીટી જુઓ.

356
00:19:21,220 --> 00:19:26,760
અરે બે હોવા બદલાતી રહે છે
શબ્દમાળા માટે એક નંબર, પૂર્ણાંક,.

357
00:19:26,760 --> 00:19:30,920
>> એરે વિશે અન્ય સરસ વસ્તુ અહીં છે
19 લીટી પર, તેઓ અનંત કદ ધરાવે છે.

358
00:19:30,920 --> 00:19:35,900
તમે માત્ર હું સો માંગતા કહી શકો
તત્વ વંચાય શબ્દમાળા હોઈ.

359
00:19:35,900 --> 00:19:38,510
અને આ બનાવવા માટે લાગતું નથી
અર્થમાં કારણ એરે જ

360
00:19:38,510 --> 00:19:41,080
ત્રણ ઘટકો માટે જગ્યા છે,
જેથી અંતે બે પ્રયત્ન કરીશું.

361
00:19:41,080 --> 00:19:44,800
તમે આ કરવા ત્યારે, ચાલો
ત્રણ બને છે તે એરે જુઓ.

362
00:19:44,800 --> 00:19:47,460
અમે ઝડપથી આ રન કરશે
નોડ ઉદાહરણ six.js. સાથે

363
00:19:47,460 --> 00:19:49,990

364
00:19:49,990 --> 00:19:52,180
અમે આ ખરેખર લાંબા મળી
અરે, અને શું થાય છે

365
00:19:52,180 --> 00:19:55,100
અમે પ્રથમ થોડા તત્વો હોય રહ્યું છે
બ્લેન્ક્સનો અને પછી સમૂહ

366
00:19:55,100 --> 00:19:56,580
ત્યાં સુધી અમે અમારા શબ્દમાળા મળે છે.

367
00:19:56,580 --> 00:19:58,580
જાવાસ્ક્રિપ્ટ એ ભરે
અરે તે જરૂરી છે, કારણ કે.

368
00:19:58,580 --> 00:20:01,790

369
00:20:01,790 --> 00:20:05,420
>> માતાનો છેલ્લે અમારી છેલ્લા ઉદાહરણ પર જઈએ.

370
00:20:05,420 --> 00:20:08,180
અહીં અમે યાદી છે
વિવિધ વિદ્યાર્થીઓ.

371
00:20:08,180 --> 00:20:11,350
હું થોડો વાત કરવા માંગો છો
કેટલાક સરસ પાસાં વિશે બીટ

372
00:20:11,350 --> 00:20:14,240
ના જાવાસ્ક્રિપ્ટ આંટીઓ માટે.

373
00:20:14,240 --> 00:20:17,500
સી, આંટીઓ માટે પ્રકારની મર્યાદિત છે.

374
00:20:17,500 --> 00:20:21,490
તેઓ જ્યાં તમે ચોક્કસ માળખું હોય
એક ચલ હોય, તો તમે એક શરત હોય,

375
00:20:21,490 --> 00:20:23,850
અને પછી તમે કંઈક કરી
લૂપની ઓવરને અંતે.

376
00:20:23,850 --> 00:20:27,560
અને અલબત્ત આ, જાવાસ્ક્રિપ્ટ કામ કરે
આપણે અગાઉના ઉદાહરણોમાં જોયું.

377
00:20:27,560 --> 00:20:31,030
પરંતુ અમે પણ માટે NICER રીતો છે
ના જાવાસ્ક્રિપ્ટ આમ.

378
00:20:31,030 --> 00:20:33,870
આ એક foreach લૂપ કહેવાય છે.

379
00:20:33,870 --> 00:20:36,580
>> માફ કરશો, ચાલો પાછા જાઓ
અહીં ઉદાહરણ સાત.

380
00:20:36,580 --> 00:20:39,320
અમે પણ વિભાગ યાદી છે કહી શકો છો.

381
00:20:39,320 --> 00:20:43,250
તેથી મને દર આઇ આપવા અથવા
કે યાદીમાં દરેક ઇન્ડેક્સ.

382
00:20:43,250 --> 00:20:46,255
પછી અમે વિદ્યાર્થી મળી શકે
માત્ર હું કલમ ફોન કરીને.

383
00:20:46,255 --> 00:20:50,690
જેથી સુયોજિત i ની કોડ તમામ
શૂન્ય સમાન છે અને ખાતરી આઇ બનાવે

384
00:20:50,690 --> 00:20:54,420
છે લંબાઈ કરતાં ઓછી છે અને
હું એક દર વખતે ઉમેરી રહ્યા છે, તે છે

385
00:20:54,420 --> 00:21:00,220
તેના બદલે તમે કાળજી લેતી
સરસ રીતે આ foreach લૂપ સાથે.

386
00:21:00,220 --> 00:21:02,830
>> માત્ર foreach આંટીઓ કરી
યાદીઓ અથવા એરેને કામ,

387
00:21:02,830 --> 00:21:06,130
તેઓ પણ વસ્તુઓ કામ,
જે પણ સરસ છે.

388
00:21:06,130 --> 00:21:10,240
તમને નામે મળી શકે
ફક્ત લઈને દરેક મિલકત

389
00:21:10,240 --> 00:21:15,030
એક શબ્દકોશ અથવા એક પદાર્થ, વિદ્યાર્થી જેવી,
અને પછી માત્ર મને દર કી આપી કહેતા.

390
00:21:15,030 --> 00:21:18,920
કી આ હશે
ગુણધર્મો, નામ અથવા ઘર.

391
00:21:18,920 --> 00:21:22,870
અહીં આમ થવાનું છે તે એ છે કે
અમે પ્રથમ નામ અને પછી છાપે

392
00:21:22,870 --> 00:21:24,920
દરેક વિદ્યાર્થી ના ઘર.

393
00:21:24,920 --> 00:21:29,170
>> હું નોડ માં આ ચલાવી શકો છો
ખરેખર ઝડપથી તમે બતાવવા માટે.

394
00:21:29,170 --> 00:21:35,510
અમે પ્રથમ લૂપ, જ્યાં સુધી સી શૈલી વિચાર
અમે દરેક પદાર્થ છપાયેલ આવી રહી મળે છે.

395
00:21:35,510 --> 00:21:38,910
અને પછી અમે જાવાસ્ક્રિપ્ટ હોય
શૈલી, જ્યાં તમે માત્ર આ કરી શકો

396
00:21:38,910 --> 00:21:41,510
દરેક કી છાપે
અને વ્યક્તિગત રીતે કદર છે.

397
00:21:41,510 --> 00:21:45,560

398
00:21:45,560 --> 00:21:47,050
>> અધિકાર છે.

399
00:21:47,050 --> 00:21:52,850
હવે અમે Node.js આવરી લીધી છે, મને લાગે છે
અમે ઉલ્કા સાથે પ્રારંભ કરવા માટે તૈયાર છો.

400
00:21:52,850 --> 00:21:56,070
હું જણાવ્યું હતું કે, ઉલ્કા એક મહાન કામ કર્યું
કેટલાક તૈયાર ઉદાહરણો લખી

401
00:21:56,070 --> 00:22:00,600
તમારા માટે તમે મારફતે શોધખોળ કરી શકો છો કે
આ ટ્યુટોરીયલ અથવા પરિસંવાદ ફોલ્ડરમાં.

402
00:22:00,600 --> 00:22:03,750
પરંતુ અહીં હું કરવા માંગો
શરૂઆતથી વધુ શરૂ કરો.

403
00:22:03,750 --> 00:22:06,810
>> માતાનો એપ્લિકેશન કરવું સરળ બનાવીએ.

404
00:22:06,810 --> 00:22:14,140
આ શું કરવા આધાર પ્રકારની છે
હું છે અગાઉ તમને દર્શાવ્યું એપ્લિકેશન નથી.

405
00:22:14,140 --> 00:22:16,990
આ ટ્યુટોરીયલ માં, તમે
છે તે જોશે

406
00:22:16,990 --> 00:22:20,180
આદેશ ઉલ્કા માટે બનાવવા
નવી ઉલ્કા પ્રોજેક્ટ બનાવો.

407
00:22:20,180 --> 00:22:24,510
તમે ક્રમમાં આ કૉલ કરવાની જરૂર
ઉલ્કા પ્રોજેક્ટ તે કારણ સ્કોર

408
00:22:24,510 --> 00:22:27,470
આ આદેશો ચલાવવા કરશે
આ ઉલ્કા બનાવવા માટે

409
00:22:27,470 --> 00:22:31,100
તમારા પ્રોજેક્ટ માટે જરૂરી ફાઈલો.

410
00:22:31,100 --> 00:22:35,920
>> તમે ટર્મિનલ જાય તો, અમે કરી શકો છો
પગલું એક કહેવાય ફોલ્ડર માં જાઓ.

411
00:22:35,920 --> 00:22:41,240
અને એક સાથે પત્રવ્યવહાર કરશે પગલું
આ ટ્યુટોરીયલ માં પ્રથમ પગલું.

412
00:22:41,240 --> 00:22:44,020
સૂચના ફોલ્ડર્સ, પગલું છે
એક, પગલું બે, પાંચ માટે બધી રીતે.

413
00:22:44,020 --> 00:22:47,835
અને દરેક એક લાગતાવળગતા થયેલ
આ ટ્યુટોરીયલ માં એક પગલું છે.

414
00:22:47,835 --> 00:22:50,960

415
00:22:50,960 --> 00:22:52,780
હું તેને ખોલવા જઈ રહ્યો છું
અહીં મારા લખાણ સંપાદકમાં

416
00:22:52,780 --> 00:22:56,280
તેથી અમે બનાવવામાં આવી છે તે એક બીટ જોઈ શકો છો.

417
00:22:56,280 --> 00:22:58,530
અમે નોટિસ કે ત્યાં
ચાર મુખ્ય ભાગો છે.

418
00:22:58,530 --> 00:23:01,170
એક ઉલ્કા ડિરેક્ટરી .meteor, ત્યાં છે.

419
00:23:01,170 --> 00:23:03,180
અને તમે તે સામાન્ય રીતે
સ્પર્શ કરવાની જરૂર નથી.

420
00:23:03,180 --> 00:23:05,070
ઉલ્કા કાળજી લે
તે ફોલ્ડર છે, અને તે માત્ર

421
00:23:05,070 --> 00:23:08,640
ખાતરી કરો કે બનાવે તમારા
પ્રોજેક્ટ યોગ્ય રીતે કામ કરશે.

422
00:23:08,640 --> 00:23:14,580
>> અમે પણ ત્રણ ફાઈલો, એક HTML ફાઇલ હોય
એક જાવાસ્ક્રિપ્ટ ફાઈલ છે, અને એક સીએસએસ ફાઇલ.

423
00:23:14,580 --> 00:23:18,670
પ્રથમ HTML ફાઇલ સાથે શરૂ કરો.

424
00:23:18,670 --> 00:23:21,310
પ્રથમ નજરમાં, આ દેખાય છે
એક સામાન્ય HTML દસ્તાવેજનું જેવી.

425
00:23:21,310 --> 00:23:23,490
પરંતુ ત્યાં નોટિસ
થોડા તફાવતો છે.

426
00:23:23,490 --> 00:23:26,520
એક, આ ખરેખર નથી
સંપૂર્ણ HTML દસ્તાવેજનું.

427
00:23:26,520 --> 00:23:28,640
આપણે એચટીએમએલ ટૅગ્સ ગુમ કરી રહ્યાં છો.

428
00:23:28,640 --> 00:23:29,700
આ સામાન્ય છે.

429
00:23:29,700 --> 00:23:33,560
ઉલ્કા, તમે અપેક્ષા કરી રહ્યાં
આ એચટીએમએલ ટૅગ્સ બનાવવા માટે.

430
00:23:33,560 --> 00:23:35,260
કે તમારા માટે કરવામાં છે.

431
00:23:35,260 --> 00:23:38,380
શું તમે ખરેખર તો begin-- માંગતા
એક વેબસાઇટ બનાવવા માંગો છો,

432
00:23:38,380 --> 00:23:40,430
તમે માત્ર શરૂ કરવાની જરૂર
વડા ટેગ સાથે,

433
00:23:40,430 --> 00:23:43,510
પછી તે વ્યાખ્યાયિત, અને
શરીર ટૅગ વ્યાખ્યાયિત કરે છે.

434
00:23:43,510 --> 00:23:48,940
>> પરંતુ જો તમે આ નોટિસ તો
HTML ફાઇલ, અમે નવા ટૅગ છે.

435
00:23:48,940 --> 00:23:50,350
અમે નમૂનો ટૅગ છે.

436
00:23:50,350 --> 00:23:52,050
આ સામાન્ય એચટીએમએલ નથી.

437
00:23:52,050 --> 00:23:55,300
આ HTML એક ખાસ આવૃત્તિ છે
ઉલ્કા તમારા માટે ઉપલબ્ધ બનાવે છે.

438
00:23:55,300 --> 00:23:57,660
તે જગ્યા બાર કહેવાય છે.

439
00:23:57,660 --> 00:24:00,980
તમે થોડી તરીકે નમૂનાઓ વ્યાખ્યાયિત કરી શકો છો
પ્રકારની મદદગાર કાર્યો જેવા મોડ્યુલો,

440
00:24:00,980 --> 00:24:03,660
તમારા C અથવા JavaScript કોડ માં.

441
00:24:03,660 --> 00:24:06,020
આ નમૂના કરશે
કાર્ય કહેવાય નામ છે.

442
00:24:06,020 --> 00:24:10,520
અને તમે વાક્ય પર અહીં જોઈ શકો છો
13 તમે આ નમૂનાઓ કૉલ કરી શકો છો.

443
00:24:10,520 --> 00:24:14,380
અને શું ઉલ્કા કરશે માત્ર છે
તમારા માટે આ ક્રિયાઓ ભરો.

444
00:24:14,380 --> 00:24:17,540

445
00:24:17,540 --> 00:24:22,580
>> તમે જણાશે અન્ય વસ્તુ છે એક
થોડી અલગ આ દરેક કાર્ય છે.

446
00:24:22,580 --> 00:24:26,130
દરેક ચલ લેશે
કાર્યો અને પ્રકારની તે મારફતે જાઓ

447
00:24:26,130 --> 00:24:28,810
કે foreach લૂપ અમે માં
ઉદાહરણ સાત માં જોવા મળી હતી.

448
00:24:28,810 --> 00:24:34,200
આ દરેક એક શબ્દકોશ લઈ શકે
અથવા યાદી, એક પદાર્થ કે યાદી,

449
00:24:34,200 --> 00:24:38,820
અને તે માત્ર આ તમામ મારફતે જાઓ પડશે
એક foreach લૂપ જેવા કિંમતો છો.

450
00:24:38,820 --> 00:24:44,110
તેથી અમે ક્રિયાઓ એક ટોળું હોય તો, આ
દરેક કાર્ય પર નમૂનો ફોન કરશે.

451
00:24:44,110 --> 00:24:49,590
>> ચાલો આ ઉલ્કા પ્રોજેક્ટ ચલાવો
માત્ર આ બને કે નહીં તે જોવા.

452
00:24:49,590 --> 00:24:53,260
હું ઉલ્કા પ્રોજેક્ટ સાથે ચલાવો
ફક્ત ઉલ્કા અથવા ઉલ્કા ચલાવો.

453
00:24:53,260 --> 00:24:56,690
અને હવે ઉલ્કા માત્ર જરૂર પડશે
ઝડપથી આ પ્રોજેક્ટ તૈયાર કરવા,

454
00:24:56,690 --> 00:25:03,320
જરૂરી તરીકે ડેટાબેઝ શરૂ,
અને પછી સ્થાનિક રીતે એપ્લિકેશન પોસ્ટ કરો.

455
00:25:03,320 --> 00:25:07,200
આપણે હવે અમારી વેબ બ્રાઉઝર પર જઈ શકે છે.

456
00:25:07,200 --> 00:25:10,215
અને અમે તે અમે જોશો
ખૂબ જ સરળ એપ્લિકેશન છે.

457
00:25:10,215 --> 00:25:22,190

458
00:25:22,190 --> 00:25:29,130
તેથી અમે દર્શાવ્યું જોયું શું ખરેખર હતી
આ પગલું એક, આ પગલું એક ફાઈલ.

459
00:25:29,130 --> 00:25:33,260
>> માતાનો બે જ કારણ પગલું પર ખસેડો
હું તેને એ જ હેતુ સિદ્ધ જશે.

460
00:25:33,260 --> 00:25:36,500
હું માત્ર બદલી જાઉં છું
આ પગલું બે ડિરેક્ટરી કરો

461
00:25:36,500 --> 00:25:39,550
અમે જોઈ શકો છો જેથી અને ફરીથી ઉલ્કા ચલાવો
નમૂના આપણે માત્ર સાથે કામ કર્યું હતું.

462
00:25:39,550 --> 00:25:43,560

463
00:25:43,560 --> 00:25:45,730
હા, એક પ્રશ્ન?

464
00:25:45,730 --> 00:25:49,724
>> પ્રેક્ષક: અમે મળી રહ્યાં છો પરવાનગી
નકારી છે, તે શું થાય કે છે

465
00:25:49,724 --> 00:25:50,390
તે માટે કહેવાય?

466
00:25:50,390 --> 00:25:52,154

467
00:25:52,154 --> 00:25:54,070
ROGER ZURAWICKI: તો
તમે ઉલ્કા રન ચલાવી રહ્યા છો

468
00:25:54,070 --> 00:25:57,280
અને તમે પરવાનગી
નકારી, તમારી ફાઇલોને કેટલાક

469
00:25:57,280 --> 00:25:59,070
જમણી પરવાનગી સમૂહ છે શકે છે.

470
00:25:59,070 --> 00:26:03,970
તેથી તમે જ્યાં તપાસ કરવા માટે હોય
પરવાનગીઓ બંધ છે.

471
00:26:03,970 --> 00:26:06,030
તેઓ બોલ હોઈ શકે
તમારા ઉલ્કા પ્રોજેક્ટ,

472
00:26:06,030 --> 00:26:08,550
અથવા તેઓ બોલ હોઈ શકે
ઉલ્કા પોતાને ફાઇલો.

473
00:26:08,550 --> 00:26:13,742
>> પ્રેક્ષક: હું માત્ર હવે તે ડાઉનલોડ તો
તમારા GitHub થી, પછી હું શું કરવું જોઈએ

474
00:26:13,742 --> 00:26:16,110
[અશ્રાવ્ય]?

475
00:26:16,110 --> 00:26:20,110
>> ROGER ZURAWICKI: જો તમે ઇચ્છો તો
તમે તેને ઍક્સેસ કરી શકો છો તેની ખાતરી કરવા માટે,

476
00:26:20,110 --> 00:26:21,450
તમે ચલાવી શકો છો આદેશ છે.

477
00:26:21,450 --> 00:26:26,590
ઝડપથી મને દો તે બહાર લખો
જેથી અન્ય લોકો તેને જોઈ શકે છે.

478
00:26:26,590 --> 00:26:30,670
હું અહીં નવી ટેબ ખોલવા જઈ રહ્યો છું
અને મારા પરિસંવાદ ફોલ્ડર માં જાઓ.

479
00:26:30,670 --> 00:26:33,500

480
00:26:33,500 --> 00:26:36,490
Chmod આદેશ છે
પરવાનગીઓ બદલવાની,

481
00:26:36,490 --> 00:26:40,060
તે શું માટે અને તમે આર કહી શકો
પુનરાવર્તિત દરેક ફાઈલ માટે.

482
00:26:40,060 --> 00:26:46,040
અને પરવાનગીઓ, તમે 0755 પ્રયત્ન કરી શકો છો
તમે સંપૂર્ણ વપરાશ હોય તેની ખાતરી કરવા માટે,

483
00:26:46,040 --> 00:26:47,820
અને બીજું દરેકને વાંચી શકે છે.

484
00:26:47,820 --> 00:26:50,100
અને તમે માત્ર ચલાવી રહ્યા હોય તો
આ આદેશ, જો તે બનાવવા પડશે

485
00:26:50,100 --> 00:26:55,800
ખાતરી પરવાનગીઓ છે
સમગ્ર ડિરેક્ટરી માટે ચકાસો.

486
00:26:55,800 --> 00:26:59,160
-L ls ચાલી તમને બતાવી શકે એ
વધુ વિગતવાર પરવાનગીઓ.

487
00:26:59,160 --> 00:27:01,290
આ બરાબર દેખાય છે.

488
00:27:01,290 --> 00:27:03,900
>> શું સૌથી મહત્વનું છે છે
તમે બધા ત્રણ છે કે

489
00:27:03,900 --> 00:27:06,610
બધા ફાઈલોમાં માટે rwx
આ પરિસંવાદ ડિરેક્ટરી.

490
00:27:06,610 --> 00:27:09,415

491
00:27:09,415 --> 00:27:11,330
કે સમસ્યા હલ કરી?

492
00:27:11,330 --> 00:27:13,735
>> પ્રેક્ષક: તે ગુમ કહે
operant [અશ્રાવ્ય].

493
00:27:13,735 --> 00:27:17,980

494
00:27:17,980 --> 00:27:18,740
[અશ્રાવ્ય]

495
00:27:18,740 --> 00:27:20,490
ROGER ZURAWICKI: તમે
તમે તેની ખાતરી કરવા માટે હોય છે

496
00:27:20,490 --> 00:27:23,022
તમારો આદેશ ઓવરને અંતે કોઈ હોય છે.

497
00:27:23,022 --> 00:27:23,938
AUDIENCE: [અશ્રાવ્ય].

498
00:27:23,938 --> 00:27:36,395

499
00:27:36,395 --> 00:27:37,520
ROGER ZURAWICKI: બધા અધિકાર.

500
00:27:37,520 --> 00:27:42,220
અમને ઝડપથી પાછા જવા દો
સ્થાનિક યજમાન, અમે હોય એપ્લિકેશન.

501
00:27:42,220 --> 00:27:46,640
અને તમે અમે એક છે કે જોશો
ઈચ્છિત તરીકે અહીં થોડા ક્રિયાઓ,.

502
00:27:46,640 --> 00:27:49,330

503
00:27:49,330 --> 00:27:51,990
અમે સીએસએસ એક ટોળું, હોય છે જે
તમારા વિશે ચિંતા કરવાની જરૂર નથી.

504
00:27:51,990 --> 00:27:53,740
આ ઉલ્કા ટ્યુટોરીયલ
માત્ર તમારા માટે આ આપે

505
00:27:53,740 --> 00:27:58,010
યાદી દેખાવ એક કરવું તમારા બનાવવા માટે
આ સાદી HTML કરતાં NICER બીટ.

506
00:27:58,010 --> 00:28:02,290
અને અમે જાવાસ્ક્રિપ્ટ ફાઇલ, હોય છે જે
હું થોડીવાર પછી વધુ વિગતવાર જાય પડશે

507
00:28:02,290 --> 00:28:04,272
પરંતુ તે માત્ર આ ક્રિયાઓ પૂરી પાડે છે.

508
00:28:04,272 --> 00:28:04,980
આ કાર્ય એક છે.

509
00:28:04,980 --> 00:28:05,740
આ કાર્ય બે છે.

510
00:28:05,740 --> 00:28:06,590
આ કાર્ય ત્રણ છે.

511
00:28:06,590 --> 00:28:09,720
તેથી આ ઉલ્કા માતાનો મેળવવામાં ડેટા છે.

512
00:28:09,720 --> 00:28:15,590
>> આ ઠંડી વસ્તુઓ એક ઉલ્કા છે વિશે
ફેરફારો આપમેળે થઇ શકે છે.

513
00:28:15,590 --> 00:28:18,990
હું બદલવા માગતા હતા તો
પ્રથમ કાર્ય નામ,

514
00:28:18,990 --> 00:28:22,490
તેથી તે આ નથી કહે છે
કાર્ય એક, અને હું તેને સંગ્રહો,

515
00:28:22,490 --> 00:28:26,370
હું વેબ પર જાઓ પછી જ્યારે
બ્રાઉઝર, તો તમે તેને તાજું કરી શકો છો,

516
00:28:26,370 --> 00:28:30,861
અને તે આપોઆપ કહે
આ એક કાર્ય નથી.

517
00:28:30,861 --> 00:28:32,860
તમે એક જ વસ્તુ કરી શકો છો
આ ફાઈલો કોઈપણ.

518
00:28:32,860 --> 00:28:37,940
ફેરફાર કરી શકો, બદલે કરવું
યાદી, હું તેને મારા યાદી કરવી પડશે.

519
00:28:37,940 --> 00:28:40,980
>> અને એક વાત તમે હમણાં, નોંધ્યું
કે હું પણ તાજું ન હતી.

520
00:28:40,980 --> 00:28:43,960
તાજું ના વિચાર પ્રકાર છે
ના ઉલ્કા સાથે તમારા માટે હલ.

521
00:28:43,960 --> 00:28:48,970
તે ફાઈલ ફેરફારો શોધે ત્યારે,
તે તમારા માટે ફેરફારો લોડ કરશે.

522
00:28:48,970 --> 00:28:53,110
આ શું, બધી ફાઈલો પર કામ કરે છે
તે એચટીએમએલ, સીએસએસ, અથવા JavaScript છે.

523
00:28:53,110 --> 00:28:57,990
આ એપ્લિકેશન દેખાશે તે તમને બતાવવા માટે
જેવા સીએસએસ વગર, હું તે બધા દૂર કરી શકો છો.

524
00:28:57,990 --> 00:29:04,720
તે લોડ રહ્યું ત્યારે, તમે હવે હોય
એક ન તરીકે સરસ દેખાવ યાદી કરવું.

525
00:29:04,720 --> 00:29:06,370
માતાનો પાછા કે સામગ્રી મૂકી દો.

526
00:29:06,370 --> 00:29:11,343
અને ચોક્કસ પૂરતી, તે
રીફ્રેશ, અને અમારા સીએસએસ પાછા છે.

527
00:29:11,343 --> 00:29:11,843
સરસ.

528
00:29:11,843 --> 00:29:15,700

529
00:29:15,700 --> 00:29:20,010
>> અમે હવે ટ્યુટોરીયલ સાથે ખસેડી શકો છો.

530
00:29:20,010 --> 00:29:23,360
માતાનો પગલું બે, નમૂનાઓ વિશે વાત કરો.

531
00:29:23,360 --> 00:29:27,140
આ અમે માત્ર જોયું છે તે છે
વિવિધ કાર્યો સાથે.

532
00:29:27,140 --> 00:29:31,550
ઉલ્કા તમને સમજાવશે શું
નમૂનાઓ અને કેવી આ તર્ક કામ કરે છે.

533
00:29:31,550 --> 00:29:34,760
પરંતુ આપણે માત્ર માટે કોડ જોવા દો
અમે તેને બહાર અર્થમાં બનાવવા શકે છે તે જોવા.

534
00:29:34,760 --> 00:29:38,030

535
00:29:38,030 --> 00:29:41,460
>> ખૂબ જ સરળ કાર્યક્રમો માં,
આપણે સરળ હોય શું ગમે

536
00:29:41,460 --> 00:29:44,550
પગલું એક, પગલું બે, પગલું, શું કરવું
ત્રણ, પગલું ચાર, પગલું પાંચ,

537
00:29:44,550 --> 00:29:45,700
અમે કોઈ ફોલ્ડર્સ નથી.

538
00:29:45,700 --> 00:29:47,533
અમે સર્વર ન હોય
ફોલ્ડર હું ઉલ્લેખ કર્યો છે.

539
00:29:47,533 --> 00:29:50,510
અમે ક્લાઈન્ટ ન હોય
ઉલ્લેખ કરવામાં આવ્યો હતો તે ફોલ્ડર.

540
00:29:50,510 --> 00:29:52,290
જેથી ઉલ્કા બધી ફાઇલોને ચાલશે.

541
00:29:52,290 --> 00:29:55,210
તે પર તે બંને સ્કોર પડશે
ક્લાઈન્ટ, સર્વર પર બંને.

542
00:29:55,210 --> 00:29:58,840
>> અને તમે તમારા જાવાસ્ક્રિપ્ટ ભાગો માંગતા હોય તો
કોડ, માત્ર ક્લાઈન્ટ પર ચલાવવા માટે

543
00:29:58,840 --> 00:30:02,350
તેઓ તમારી પાસે તેની ખાતરી કરવા માટે જરૂર
એક નિવેદનમાં તો પ્રકારની જેવી શું

544
00:30:02,350 --> 00:30:04,890
અમે અહીં અમારા જાવાસ્ક્રિપ્ટ ફાઈલમાં હોય છે.

545
00:30:04,890 --> 00:30:08,010
જેથી ઉલ્કા, તો જ
તે પછી, ક્લાઈન્ટ છે કે હું

546
00:30:08,010 --> 00:30:12,355
એક નમૂનો વ્યાખ્યાયિત કરવા માંગતા
મદદગાર કહેવાય ક્રિયાઓ.

547
00:30:12,355 --> 00:30:15,050

548
00:30:15,050 --> 00:30:19,260
શું આ કોડ ખરેખર
એ નથી કે તે ત્યાં કહે છે

549
00:30:19,260 --> 00:30:21,800
એક પદાર્થ કહેવાય નમૂનો
કે ઉલ્કા પાડે છે.

550
00:30:21,800 --> 00:30:23,270
અને અમે એક મદદગાર ઉમેરો રહ્યા છીએ.

551
00:30:23,270 --> 00:30:27,680
મદદગારો આ ક્રિયાઓ હોય છે,
કાર્યો જેવા આ વસ્તુઓ.

552
00:30:27,680 --> 00:30:33,890
>> તમે જોશો કે અમે પાછા જાઓ તો તે
HTML ફાઇલ, અમે કાર્યો પર દરેક કહેવાય.

553
00:30:33,890 --> 00:30:35,750
કાર્યો એ HTML માં વ્યાખ્યાયિત થયેલ નથી.

554
00:30:35,750 --> 00:30:37,770
તે જાવાસ્ક્રિપ્ટ વ્યાખ્યાયિત છે.

555
00:30:37,770 --> 00:30:42,610
અને ઉલ્કા શું ક્રિયાઓ છે ખબર જરૂર
અમે અહીં આ જાવાસ્ક્રિપ્ટ જાય ત્યારે.

556
00:30:42,610 --> 00:30:45,550
કાર્યો આ મદદગાર છે.

557
00:30:45,550 --> 00:30:49,830
હેલ્પર, તમે વિચાર કરી શકો છો
તે એક નમૂનો ચલ તરીકે.

558
00:30:49,830 --> 00:30:51,000
અને કાર્યો શું કરે છે?

559
00:30:51,000 --> 00:30:53,580
વેલ, તે કિંમતો યાદીમાં આપે છે.

560
00:30:53,580 --> 00:30:56,750
તે યાદી છે, કારણ કે
અમે તેને દરેક ફોન કરી શકો છો.

561
00:30:56,750 --> 00:30:58,590
અમે કાર્યો પર દરેક કૉલ તેથી કે શા માટે.

562
00:30:58,590 --> 00:30:59,730
અને હવે અમે કાર્ય છે.

563
00:30:59,730 --> 00:31:02,850

564
00:31:02,850 --> 00:31:03,990
>> કાર્ય શું કરે છે?

565
00:31:03,990 --> 00:31:07,740
વેલ, તે આ તીર છે
અહીં સર્પાકાર કૌંસ પછી.

566
00:31:07,740 --> 00:31:09,130
કે કાર્ય એક નમૂનો છે થાય છે.

567
00:31:09,130 --> 00:31:11,100
તે મદદગાર નથી
અમે ફક્ત શું જોયું જેવી.

568
00:31:11,100 --> 00:31:12,872
તે અમે નિર્ધારિત કર્યું છે એક નમૂનો છે.

569
00:31:12,872 --> 00:31:14,080
અને જ્યાં અમે તેને વ્યાખ્યાયિત છે?

570
00:31:14,080 --> 00:31:16,950
અમે અહીં તેને નીચે વ્યાખ્યાયિત કર્યું છે.

571
00:31:16,950 --> 00:31:21,160
>> આ બધા નમૂના રેન્ડર છે નથી
યાદી આઇટમ, અને તે લખાણ કહે છે.

572
00:31:21,160 --> 00:31:24,160
હવે, લખાણ એક હોય તેમ લાગે છે
મદદગાર, પણ હું તમને બતાવીશું

573
00:31:24,160 --> 00:31:26,610
આ હજુ ખરેખર છે કે
કાર્યો ડેટા સભ્ય.

574
00:31:26,610 --> 00:31:29,230

575
00:31:29,230 --> 00:31:33,670
તમે દરેક ફોન કરો ત્યારે તે જાય
આ માહિતી માળખું થોડુંક.

576
00:31:33,670 --> 00:31:39,130
આ foreach લૂપ જેમ, તે હવે માત્ર જુએ
અમારા પદાર્થ માં પ્રથમ તત્વ છે.

577
00:31:39,130 --> 00:31:41,850
અમે તે લખાણ છે તે જોવા
અમારા પદાર્થ માં અહીં વ્યાખ્યાયિત.

578
00:31:41,850 --> 00:31:45,350
જેથી ઉલ્કા કે ખબર સ્માર્ટ છે
અમે આ લખાણ વિશે વાત કરી રહ્યા છીએ

579
00:31:45,350 --> 00:31:47,630
ન લખાણ નામના મદદગાર.

580
00:31:47,630 --> 00:31:52,120
તે માત્ર આ ની કિંમત નહીં
અહીં લખાણ અને એચટીએમએલ તરીકે ડિસ્પ્લે તે,

581
00:31:52,120 --> 00:31:55,475
અને તે ડેટા કેવી રીતે જાય છે
એ HTML માટે જાવાસ્ક્રિપ્ટ થી.

582
00:31:55,475 --> 00:32:03,320

583
00:32:03,320 --> 00:32:07,030
>> આ ઉદાહરણમાં, જોકે પર જતાં
અમે સખત તે કિંમતો કોડેડ.

584
00:32:07,030 --> 00:32:10,440
ઉલ્કા ખરેખર બે કરે
અમારા માટે સરસ વસ્તુઓ.

585
00:32:10,440 --> 00:32:15,050
લાઇવ તાજું ઉપરાંત કે આપણે
બતાવ્યું છે, તે પણ અમારી ડેટાબેઝ વ્યવસ્થા કરે છે.

586
00:32:15,050 --> 00:32:18,750
તમે PHP સાથે કામ કરવા હોય તો,
તમે phpMyAdmin રૂપરેખાંકિત કરવા માટે હતી.

587
00:32:18,750 --> 00:32:21,320
તમે ખાતરી કરી હતી તમારા
કોષ્ટકો બધી તપાસ હતા.

588
00:32:21,320 --> 00:32:24,760
તમે બનાવવા માટે કામ ઘણું કરવું હતું
તમારી માહિતી સાચી રીતે ફોર્મેટ કરવામાં આવ્યું હતું તેની ખાતરી

589
00:32:24,760 --> 00:32:27,880
અને PHP તેની સાથે વાતચીત કરી શકે છે.

590
00:32:27,880 --> 00:32:30,170
>> હવે, ઉલ્કા નવી નમૂનારૂપ ઉપયોગ કરે છે.

591
00:32:30,170 --> 00:32:32,310
આ એક વધુ આધુનિક રીત છે
એક ડેટાબેઝ સંભાળવા.

592
00:32:32,310 --> 00:32:34,580
તે MongoDB કહેવાય ટેકનોલોજી છે.

593
00:32:34,580 --> 00:32:38,740
જસ્ટ જાવાસ્ક્રિપ્ટ જેવા, અમે તેને જોયું કે
ડેટા હતી શું પ્રકારની કોઈ વાંધો ન હતો.

594
00:32:38,740 --> 00:32:39,640
બધું એક વાર હતી.

595
00:32:39,640 --> 00:32:40,570
જો તે charstar ન હતી.

596
00:32:40,570 --> 00:32:40,930
તે પૂર્ણાંક ન હતી.

597
00:32:40,930 --> 00:32:41,970
તે સ્ટ્રક્ટ ન હતી.

598
00:32:41,970 --> 00:32:44,210
તે કે var, ફક્ત આ var હતી.

599
00:32:44,210 --> 00:32:46,320
>> MongoDB તે જ રીતે પ્રકારની કામ કરે છે.

600
00:32:46,320 --> 00:32:48,160
તમે તમારા કોષ્ટકો વ્યાખ્યાયિત કરવાની જરૂર નથી.

601
00:32:48,160 --> 00:32:50,860
જો તમે કોષ્ટક કહેવું ન હોય
પૂર્ણાંક છે કે જે એક નામ ધરાવે છે.

602
00:32:50,860 --> 00:32:54,710
તે મને ખબર નથી, એક છે
દશાંશ છે જે ડોલર,.

603
00:32:54,710 --> 00:32:58,360
તે માત્ર આ જાવાસ્ક્રિપ્ટ પદાર્થો છે
આ બધા Vars, અનિવાર્યપણે.

604
00:32:58,360 --> 00:33:02,780
અને આ એક ખરેખર શક્તિશાળી છે
તમારી એપ્લિકેશન પ્રોટોટાઇપ માટે માર્ગ.

605
00:33:02,780 --> 00:33:06,190
અને તે ઉલ્કા શા માટે છે
આ લાભ લે છે.

606
00:33:06,190 --> 00:33:11,080
>> અમે ત્રણ સ્ટેપ પર જાવ છો,
માતાનો બદલાઈ ગઈ છે તે જોવા દો.

607
00:33:11,080 --> 00:33:15,480
આપણે todos એચટીએમએલ જોવા, ખૂબ નથી.

608
00:33:15,480 --> 00:33:17,170
સીએસએસ બધા બદલાઈ નથી.

609
00:33:17,170 --> 00:33:22,420
પરંતુ નાના ફેરફાર આપણે HTML માં જોવા
કાર્યો વ્યાખ્યાયિત કરવામાં આવે છે કેવી રીતે અમે બદલ્યું છે.

610
00:33:22,420 --> 00:33:23,800
કાર્યો હવે એક કાર્ય છે.

611
00:33:23,800 --> 00:33:25,800
જે દરેક જે થાય
અમે ક્રિયાઓ મેળવવા માંગો છો સમય,

612
00:33:25,800 --> 00:33:27,480
અમે આ કાર્ય ચલાવવા રહ્યા છીએ.

613
00:33:27,480 --> 00:33:29,230
તે નહિં આપે
નીચેની તરીકે કાર્ય.

614
00:33:29,230 --> 00:33:33,710
>> ઉલ્કા વાસ્તવમાં ચલાવવા માટે સ્માર્ટ છે
કાર્ય અમે નીકળી જાય છે તે જોવા માટે.

615
00:33:33,710 --> 00:33:36,650
અને તે ક્રિયાઓ કહેવાય વસ્તુ આપે છે.

616
00:33:36,650 --> 00:33:40,650
અમે વાક્ય એક પર ક્રિયાઓ વ્યાખ્યાયિત કર્યું
અને તે એક Mongo સંગ્રહ છે.

617
00:33:40,650 --> 00:33:43,170
Mongo ઉલ્લેખ છે
ઉલ્કા વાપરે ડેટાબેઝ,

618
00:33:43,170 --> 00:33:48,420
અને આ નવા ફક્ત માતાનો બનાવવા દો અર્થ થાય
એક નવો સંગ્રહ, તે ક્રિયાઓ ફોન કરો.

619
00:33:48,420 --> 00:33:53,540
MySQL, આ માટે સમકક્ષ હશે
ટેબલ કહેવાય કાર્યો માટે જોઈ.

620
00:33:53,540 --> 00:33:56,350
Mongo સંગ્રહો, ન કોષ્ટકો છે.

621
00:33:56,350 --> 00:34:00,100
તેથી આ માત્ર કાર્યો માટે જુએ છે.

622
00:34:00,100 --> 00:34:04,820
>> હવે, નમૂનો અમારા
આ નમૂનામાં મદદગાર, બધા

623
00:34:04,820 --> 00:34:08,380
અમે તમામ વિચાર શું કરવું છે
કાર્યો આ કાર્ય, શોધો થયેલ

624
00:34:08,380 --> 00:34:11,710
અને આ ખાલી તાણવું.

625
00:34:11,710 --> 00:34:14,150
આ Mongo વાક્યરચના માટે વધુ ચોક્કસ છે.

626
00:34:14,150 --> 00:34:16,159
પુષ્કળ છે
કેવી ઓનલાઇન દસ્તાવેજીકરણ

627
00:34:16,159 --> 00:34:19,360
તમે કાર્યક્ષમ બનાવવા કરી શકો છો અને
ખરેખર ઉપયોગી Mongo પ્રશ્ન કરે છે.

628
00:34:19,360 --> 00:34:25,560
પરંતુ આ કંઈક સારી છે
ફક્ત તમામ માહિતી શોધવા માટે પૂરતી.

629
00:34:25,560 --> 00:34:30,100
>> હવે, આ મુદ્દાઓ પૈકી એક છે તમે જોઈ શકો
અમે ખરેખર માહિતી ઉમેરવા ક્યારેય કે છે.

630
00:34:30,100 --> 00:34:35,020
તેથી શું જ્યારે અમે બને
વાસ્તવમાં પગલું ત્રણ ચલાવી?

631
00:34:35,020 --> 00:34:37,550
માતાનો ઝડપથી જાય દો
ત્રણ પગલું અને ઉલ્કા ચલાવો.

632
00:34:37,550 --> 00:34:42,870

633
00:34:42,870 --> 00:34:45,650
હું અન્ય ઉલ્કા હતી કે નોટિસ
પ્રોજેક્ટ, બીજે ક્યાંય ચાલી

634
00:34:45,650 --> 00:34:49,110
જેથી ઉલ્કા કે પસંદ નથી.

635
00:34:49,110 --> 00:34:52,810
હું માત્ર કરવા માટે ઝડપથી નજીક જઇ રહ્યો છું
નિયંત્રણ સી સાથે અન્ય ઉલ્કા,

636
00:34:52,810 --> 00:34:55,780
પગલું ત્રણ જાય,
અને ફરી ઉલ્કા ચલાવો.

637
00:34:55,780 --> 00:35:01,070

638
00:35:01,070 --> 00:35:03,180
તે શરૂ કરવામાં આવ્યું છે નોટિસ
MongoDB કારણ MongoDB

639
00:35:03,180 --> 00:35:06,370
દરેક ઉલ્કા પ્રોજેક્ટ એક ભાગ છે.

640
00:35:06,370 --> 00:35:09,190
>> તેથી તે મારી અરજી ભૂલ છે કહે છે.

641
00:35:09,190 --> 00:35:10,590
કે ઉલ્કા છે એક સરસ લક્ષણ છે.

642
00:35:10,590 --> 00:35:13,700
તે ખાતરી કરે છે તમારા
એચટીએમએલ સાથે સાથે માન્ય કરવામાં આવે છે.

643
00:35:13,700 --> 00:35:17,710
માતાનો ઝડપથી આ હોઈ શકે છે શા માટે જુઓ.

644
00:35:17,710 --> 00:35:26,110
તે હું અકસ્માતે હોય તેમ લાગે
ખોટી એચટીએમએલ કોડ નકલ.

645
00:35:26,110 --> 00:35:30,610
હું હવે તેને સંગ્રહો તો, ઉલ્કા
આપમેળે, સર્વર પુનઃશરૂ

646
00:35:30,610 --> 00:35:34,650
ઈચ્છિત તરીકે અને હવે એપ્લિકેશન ચાલી રહી છે.

647
00:35:34,650 --> 00:35:39,220
આ સુધારવા માટે નોટિસ, તમે માત્ર ચલાવી શકો છો
પગલું બે ના જ HTML ફાઇલ,

648
00:35:39,220 --> 00:35:40,380
પગલું ત્રણ મા નકલ કરો.

649
00:35:40,380 --> 00:35:43,290

650
00:35:43,290 --> 00:35:45,917
>> અમે અમારા સ્થાનિક યજમાન પર પાછા જઈ શકે છે.

651
00:35:45,917 --> 00:35:47,500
અને હવે અમે અમે યાદી કરવું આપણા હોય જુઓ.

652
00:35:47,500 --> 00:35:50,070
ગ્રેટ છે, પણ તે ખાલી છે.

653
00:35:50,070 --> 00:35:54,210
અમે ખરેખર કોઇ જરૂર નથી
અમારા Mongo ડેટાબેઝમાં ક્રિયાઓ.

654
00:35:54,210 --> 00:35:57,930
તેથી આપણે એક વિશે વાત કરો
થોડા રીતે અમે તે કરી શકો છો.

655
00:35:57,930 --> 00:36:03,240
આપણે ટર્મિનલ પર પાછા જાઓ, અમે
તેને બંધ કરો અને ઉલ્કા Mongo ચલાવી શકો છો.

656
00:36:03,240 --> 00:36:05,320
>> તમે પરિચિત છો તો
ઉલ્કા કેવી રીતે કામ કરે છે સાથે,

657
00:36:05,320 --> 00:36:14,100
આ ખરેખર તમને ઍક્સેસ આપે
ઉલ્કા માટે સંપૂર્ણ MongoDB માટે.

658
00:36:14,100 --> 00:36:17,570
તમે ચાલી આવે છે કે નોટિસ
આ કામ કરવા માટે પ્રથમ ઉલ્કા.

659
00:36:17,570 --> 00:36:23,840
તેથી હું એક નવા ટૅબમાં આ સ્કોર તો હું
એ જ ડિરેક્ટરીમાં પાછા જઈ શકે છે.

660
00:36:23,840 --> 00:36:29,040

661
00:36:29,040 --> 00:36:32,570
અને હવે ઉલ્કા માત્ર દંડ કામ કરે છે.

662
00:36:32,570 --> 00:36:33,600
આ પ્રોમ્પ્ટ છે.

663
00:36:33,600 --> 00:36:36,350

664
00:36:36,350 --> 00:36:38,790
મને તે થોડી બનાવવા દો
અમે જોઈ શકો છો જેથી મોટી.

665
00:36:38,790 --> 00:36:41,550
આ કરતાં થોડી અલગ દેખાય
શું તમે ખરેખર કરવા માટે વપરાઈ શકે

666
00:36:41,550 --> 00:36:42,869
ખરેખર Mongo વાપરવા માટે જરૂર નથી.

667
00:36:42,869 --> 00:36:45,410
મારી સમગ્ર બિંદુ અહીં છે
કે જેથી તમે JavaScript નો ઉપયોગ કરી શકે છે.

668
00:36:45,410 --> 00:36:48,250
પણ તમે વિચિત્ર છો,
આ Mongo API નહી હોય

669
00:36:48,250 --> 00:36:50,730
એસક્યુએલ, એ સ્ટ્રક્ચર્ડ ક્વેરી લેંગ્વેજ વાપરો.

670
00:36:50,730 --> 00:36:55,570
તે તેની પોતાની ભાષામાં વાપરે છે કે
જાવાસ્ક્રિપ્ટ જેવા ઘણો લાગે.

671
00:36:55,570 --> 00:37:00,520
ખૂબ જ ઝડપથી, અમે શોધી શકો છો
db.tasks મારફતે ટેબલ.

672
00:37:00,520 --> 00:37:08,940
અને તે મને કહેવાની છે
અમે શોધવા ચલાવી રહ્યા હોય તો બહાર કરે,

673
00:37:08,940 --> 00:37:13,450
અમે સાથે હતા તે સમાન પ્રકારની
ઉલ્કા, અમે બધા તત્વો લાવી શકો છો.

674
00:37:13,450 --> 00:37:17,330
સમસ્યા એ છે કે અમે નથી કરી
ખરેખર વ્યાખ્યાયિત કોઈપણ ક્રિયાઓ ધરાવે છે.

675
00:37:17,330 --> 00:37:20,600
એટલે તેમને ન મળી શકે.

676
00:37:20,600 --> 00:37:22,130
>> અમે જોકે, દાખલ કરી શકો છો.

677
00:37:22,130 --> 00:37:25,170
તેથી અમે શામેલ ચાલી શકે છે
આદેશ insert સાથે.

678
00:37:25,170 --> 00:37:29,140
અને અમે હમણાં જ તે આપી
એક પદાર્થ છે, અને અમે હમણાં જ

679
00:37:29,140 --> 00:37:31,840
બંધારણ અમે અપેક્ષા શું છે તેની ખાતરી કરો.

680
00:37:31,840 --> 00:37:35,030
અમે પગલું બે પર હતા તો,
અમે દરેક કાર્ય જોયું કે

681
00:37:35,030 --> 00:37:39,590
એક ટેક્સ્ટ સાથે એક પદાર્થ હતો
કી અને ગમે તેમ

682
00:37:39,590 --> 00:37:41,640
તમારા કરવું વસ્તુ ચલ તરીકે હતી.

683
00:37:41,640 --> 00:37:44,680
તેથી અમે અહીં કંઈક કરી શકો છો.

684
00:37:44,680 --> 00:37:50,160
>> અમે તેને એક કાર્ય દાખલ કરી શકે છે
હું Mongo આવે કહેવાય.

685
00:37:50,160 --> 00:37:52,570
અને અમે દાખલ દબાવો, અને તે ચાલે છે.

686
00:37:52,570 --> 00:37:56,900
અમે ફરીથી શોધવામાં ચલાવો, અને અમે કરી શકો છો
એક પદાર્થ અહીં છે કે જુઓ.

687
00:37:56,900 --> 00:38:01,810
Mongo તે એક ID, સોંપે જે તમને
ખરેખર ચિંતા કરવાની જરૂર નથી.

688
00:38:01,810 --> 00:38:06,690
શું તમે મહત્વપૂર્ણ છે ડેટા છે
તમે સાઇન મૂકી, તમે વિચાર ડેટા છે.

689
00:38:06,690 --> 00:38:10,500
>> ચાલો અમારી વેબસાઇટ પર જાઓ દો
અને હેય, અમારા કાર્ય લોડ.

690
00:38:10,500 --> 00:38:13,987
અને તમે તે જોઈ શકો છો
ઉલ્કા ખૂબ સ્માર્ટ છે, કારણ કે

691
00:38:13,987 --> 00:38:16,570
અને હંમેશા હું તમારા માટે રીફ્રેશ
આ પાનું સ્પર્શ ન હતી.

692
00:38:16,570 --> 00:38:19,160
તે આપોઆપ લોડ.

693
00:38:19,160 --> 00:38:23,520
>> માતાનો કેટલાક કોડ ચલાવો
જાવાસ્ક્રિપ્ટ છતાં આ કરવા માટે.

694
00:38:23,520 --> 00:38:26,120
અમે પાછળ નોડ હોય છે જેમ
જાવાસ્ક્રિપ્ટ બહાર ચલાવવા માટે અંત,

695
00:38:26,120 --> 00:38:29,280
અમે પણ જાવાસ્ક્રિપ્ટ ચાલી શકે છે
સીધા અમારા બ્રાઉઝર્સમાં.

696
00:38:29,280 --> 00:38:31,970
જો તમે લક્ષણ દ્વારા આ કરી શકો
એલિમેન્ટ નિરીક્શણ કહેવાય.

697
00:38:31,970 --> 00:38:34,210
હું અધિકાર એક પર ક્લિક કરો, તો
પાનાંની વિભાગ,

698
00:38:34,210 --> 00:38:36,730
એક વિકલ્પ છે
એલિમેન્ટ નિરીક્શણ કહેવાય.

699
00:38:36,730 --> 00:38:38,840
તમે ચલાવી રહ્યા છો તો એક
સફારી, તમારા જેવા બ્રાઉઝર

700
00:38:38,840 --> 00:38:45,430
તમારા વિકાસકર્તા માટે સક્રિય કરવાની જરૂર પડી શકે
તમે પહેલાં સાધનો આ લક્ષણ મળે છે.

701
00:38:45,430 --> 00:38:46,930
>> શું અમે વિશે કાળજી કન્સોલ છે.

702
00:38:46,930 --> 00:38:48,930
તેથી અમે ફક્ત પર જશે
તળિયે કન્સોલ.

703
00:38:48,930 --> 00:38:52,110

704
00:38:52,110 --> 00:38:55,970
હવે અમે કોઈ જાવાસ્ક્રિપ્ટ ચાલી શકે છે
અહીં, આ જાવાસ્ક્રિપ્ટ જેવી

705
00:38:55,970 --> 00:38:58,860
ફાઇલો હું જેએસ ઉદાહરણમાં જોવા મળ્યો છે.

706
00:38:58,860 --> 00:39:02,040
પરંતુ હવે આપણે ક્રિયાઓ જુઓ.

707
00:39:02,040 --> 00:39:04,955
અમે અમારા આદેશ ચલાવી શકો છો.

708
00:39:04,955 --> 00:39:07,830
અને આશા છે કે હું બનાવવા કરી શકશો
તે થોડી મોટી છે તેથી અમે બધા જોઈ શકે છે.

709
00:39:07,830 --> 00:39:14,390

710
00:39:14,390 --> 00:39:18,450
>> અમે tasks.find ચલાવો, અને જો તમે પડશે
આ ચોક્કસ જ કોડ છે કે જુઓ

711
00:39:18,450 --> 00:39:24,840
આ જાવાસ્ક્રિપ્ટ ફાઈલ વાપરે છે કે
પગલું ત્રણ માં, આ task.find.

712
00:39:24,840 --> 00:39:29,100
અમે આ જ વાત ચલાવો, અને શકે છે
હવે અમે કેટલીક વિચિત્ર સામગ્રી વિચાર.

713
00:39:29,100 --> 00:39:31,050
અમે કેવી રીતે વાસ્તવમાં ડેટા મેળવી શકું?

714
00:39:31,050 --> 00:39:34,860
વેલ, અમે આ ચલાવવા માટે છે
કહેવાય આદેશ મેળવે.

715
00:39:34,860 --> 00:39:37,150
>> આ ડિબગીંગ માટે ખૂબ જ ઉપયોગી છે.

716
00:39:37,150 --> 00:39:41,000
શું તમે અહીં મેળવી છે
એક કર્સર, અને આ છે

717
00:39:41,000 --> 00:39:44,890
ઉલ્કા છે એક સરસ રીત
ઑપ્ટિમાઇઝ લાવતી માહિતી.

718
00:39:44,890 --> 00:39:48,270
આ કર્સર માટે તમામ સુવિધાઓ છે
લાઇવ અપડેટ અને પ્રેરણાદાયક પૃષ્ઠ

719
00:39:48,270 --> 00:39:49,650
કંઈક બદલાઈ ગયો છે.

720
00:39:49,650 --> 00:39:51,280
પરંતુ તે અમને ડેટા મળશે નહીં.

721
00:39:51,280 --> 00:39:52,720
અમે મેળવે મારફતે ડેટા મેળવી શકો છો.

722
00:39:52,720 --> 00:39:56,880
અને જો અમે એક પદાર્થ હોય તે જોવા માટે, અને
તે માત્ર અમે Mongo હતી શું જેવું છે

723
00:39:56,880 --> 00:40:00,040
એક ID અને લખાણ સાથે આપણે મૂકવા.

724
00:40:00,040 --> 00:40:04,200
>> તેથી અમે કેવી રીતે ઉલ્કા માં આઇટમ દાખલ કરી શકું?

725
00:40:04,200 --> 00:40:07,250
વેલ, અમે માત્ર ક્રિયાઓ ધરાવે છે.

726
00:40:07,250 --> 00:40:09,990
અને પછી અમે ચલાવી શકો છો
જ દાખલ આદેશ,

727
00:40:09,990 --> 00:40:17,520
એક શબ્દકોશ અથવા પદાર્થ આપ્યા
એ જ બંધારણ, લખાણ સાથે

728
00:40:17,520 --> 00:40:22,340
અને પછી હું કન્સોલ આવે.

729
00:40:22,340 --> 00:40:27,240
ઉપર એક નજર કારણ કે જ્યારે હું
આ કરવા માટે, તે વેબસાઈટ પર દેખાય છે

730
00:40:27,240 --> 00:40:29,660
આપમેળે.

731
00:40:29,660 --> 00:40:33,291
>> તમે કંઈપણ મૂકી શકે છે કે નોટિસ
તમે આ વસ્તુઓ માં માંગો છો.

732
00:40:33,291 --> 00:40:35,040
તે છે નથી
એક નિશ્ચિત માળખા હોય છે.

733
00:40:35,040 --> 00:40:39,790
હું એક સમાન હોય શકે
નંબર ત્રણ અને ખોટા બરાબર બી.

734
00:40:39,790 --> 00:40:41,600
અને તે બધા કામ કરે છે.

735
00:40:41,600 --> 00:40:46,000
હું પણ પસંદ કરી શકો છો નથી માટે
બધા પર લખાણ સમાવેશ થાય છે.

736
00:40:46,000 --> 00:40:48,320
આ માત્ર આગ્રહણીય નથી
છતાં પછી ઉલ્કા કારણ

737
00:40:48,320 --> 00:40:50,920
પ્રદર્શિત કરવું તે ખબર નહીં.

738
00:40:50,920 --> 00:40:53,110
પરંતુ દરેક કિસ્સામાં, અમે
એક ID વિચાર, અને તે છે

739
00:40:53,110 --> 00:40:54,785
તમે ઉપયોગ કરી શકો પદાર્થ ની આઈડી.

740
00:40:54,785 --> 00:41:01,120

741
00:41:01,120 --> 00:41:03,280
>> અમે સાથે ચાલુ તરીકે
ચાર પગલું અને પાંચ પગલું,

742
00:41:03,280 --> 00:41:06,870
આ ટ્યુટોરીયલ તમે માર્ગો બતાવશે કે
તમે ઉપયોગ કરી UI ઘટકો બનાવી શકો

743
00:41:06,870 --> 00:41:13,130
તમને ખબર એચટીએમએલ
વિવિધ કાર્યો બનાવો.

744
00:41:13,130 --> 00:41:15,440
માતાનો ખરેખર ઝડપથી પગલાં ચાર જુઓ.

745
00:41:15,440 --> 00:41:18,290
અમે અમે ઉમેર્યું છે કે જોશો
ઘટનાઓ વિશે એક વિભાગ.

746
00:41:18,290 --> 00:41:20,874
નમૂનાઓ હોઈ શકે છે
અમને માહિતી મળી છે કે જેમાં મદદગારો,.

747
00:41:20,874 --> 00:41:22,040
પરંતુ તે પણ ઘટનાઓ કૉલ કરી શકો છો.

748
00:41:22,040 --> 00:41:25,300
અને આ છે જ્યાં સામગ્રી છે
, ઘટનાઓ, કારણ ઉપયોગી બને

749
00:41:25,300 --> 00:41:28,590
તમે પર ક્લિક કરો ત્યારે શું થાય રહ્યા
તમારી વેબસાઇટ પર અલગ વસ્તુઓ.

750
00:41:28,590 --> 00:41:33,790
>> અહીં અમારા કોડ કહેવાની છે
અમને આ ઘટના ઉમેરો.

751
00:41:33,790 --> 00:41:38,860
તમે સબમિટ કર્યા ત્યારે તેને ઉમેરી
વર્ગ નવા કાર્ય સાથે કંઈક.

752
00:41:38,860 --> 00:41:41,910
શું તમે અહીં છે એક સીએસએસ પસંદગીકાર છે.

753
00:41:41,910 --> 00:41:45,870
તેથી આ માત્ર એક HTML માટે જુએ
વર્ગ નવા કાર્ય છે તે તત્વ.

754
00:41:45,870 --> 00:41:47,940
અને તે ઘટના માટે, જેવી submit જુએ છે.

755
00:41:47,940 --> 00:41:51,050
અન્ય ઇવેન્ટ્સ સમાવેશ
હોવર, ક્લિક, ડબલ ક્લિક,

756
00:41:51,050 --> 00:41:54,450
તમે સામાન્ય HTML માં વિચાર શું જેવું જ.

757
00:41:54,450 --> 00:41:56,770
>> શું તમે તેને અહીં આપી હવે એક કાર્ય છે.

758
00:41:56,770 --> 00:42:01,210
અને તમે હોઈ શકે છે તમારા
તે કાર્ય માં કોડ.

759
00:42:01,210 --> 00:42:06,360
મેળવવામાં થાય છે તે આ કાર્ય છે
જો તમે આ નવી કાર્ય સુપ્રત કરો ત્યારે કહેવાય.

760
00:42:06,360 --> 00:42:12,170
માતાનો માત્ર જેથી તે HTML જુઓ અમે
આ નવી કાર્ય છે તે સમજવા.

761
00:42:12,170 --> 00:42:15,570
અમે અહીં એક ફોર્મ ઉમેર્યા છે
વર્ગ નવા કાર્ય સાથે.

762
00:42:15,570 --> 00:42:19,880
અને તે લખાણ લે છે કે ઇનપુટ છે.

763
00:42:19,880 --> 00:42:22,605
અને આ છે જ્યાં અમે
અમારા નવા કાર્યો ઉમેરો કરશે.

764
00:42:22,605 --> 00:42:25,520

765
00:42:25,520 --> 00:42:29,780
>> ચાલો આ પગલું ચાર ચલાવો
વેબસાઇટ તે જેવી લાગે છે તે જોવા માટે.

766
00:42:29,780 --> 00:42:32,710
અમે પ્રથમ બહાર નીકળવા કરી શકો
આ MongoDB ના અમે હતી

767
00:42:32,710 --> 00:42:35,300
અમારા અગાઉના થી
નિયંત્રણ સી સાથે ઉદાહરણ

768
00:42:35,300 --> 00:42:37,690
અને ચાલો તેને બદલવા દો
આ પગલું ચાર ડિરેક્ટરી.

769
00:42:37,690 --> 00:42:41,000

770
00:42:41,000 --> 00:42:42,920
અમે ફરી ઉલ્કા સ્કોર પડશે
સર્વર શરૂ કરવા માટે.

771
00:42:42,920 --> 00:42:46,850

772
00:42:46,850 --> 00:42:50,510
અને કમનસીબે, હું ઉલ્કા હતી
બીજા ટર્મિનલમાં ચાલી.

773
00:42:50,510 --> 00:42:53,080
તેથી હું માત્ર જાઉં છું
આ બંધ ખાતરી કરો.

774
00:42:53,080 --> 00:43:01,805
ચાલો આ અને બદલો છોડી દો
ભાગ ચાર, ચાર કદમ.

775
00:43:01,805 --> 00:43:02,305
ઓકે.

776
00:43:02,305 --> 00:43:11,220

777
00:43:11,220 --> 00:43:13,250
>> હવે અમારી ઉલ્કા કોડ ચાલી રહ્યું છે.

778
00:43:13,250 --> 00:43:19,480
અને તમે વિના, તેને અપડેટ જોઈ શકો છો કે
અમને પણ પૃષ્ઠને તાજું કર્યા.

779
00:43:19,480 --> 00:43:24,410
શું અહીં બદલી નાંખી છે હવે છે
અમે કોઈ ક્રિયાઓ નથી કે,

780
00:43:24,410 --> 00:43:29,530
પરંતુ અમે અહીં, આ એક સ્વરૂપ છે
લખાણ બોક્સમાં અમારા નવા કાર્યો ઉમેરો.

781
00:43:29,530 --> 00:43:31,550
અને અમે અહીં અમારા કાર્ય લખી શકો છો.

782
00:43:31,550 --> 00:43:34,564
હું HTML પાનામાં આવે.

783
00:43:34,564 --> 00:43:36,105
હું દાખલ કરો દબાવો, ત્યારે તે રજૂ મળ્યો.

784
00:43:36,105 --> 00:43:39,180

785
00:43:39,180 --> 00:43:44,540
>> અમે તરીકે થયું છે તે જોવા કરી શકો છો
આ JavaScript કોડ દ્વારા વ્યાખ્યાયિત.

786
00:43:44,540 --> 00:43:49,930
શું આ કાર્ય કર્યું હતું
ફોર્મ માંથી લખાણ લાગી,

787
00:43:49,930 --> 00:43:53,680
અને પછી માત્ર, tasks.insert કહેવાય
જેવા આપણે કન્સોલ માં કર્યું.

788
00:43:53,680 --> 00:43:56,410
તેઓ પણ એક createdAt તારીખ ઉમેરો પસંદ કર્યું.

789
00:43:56,410 --> 00:43:59,840
આ તમે કેવી રીતે કરશે છે
વર્તમાન સમય સ્પષ્ટ કરો.

790
00:43:59,840 --> 00:44:03,220
કે પછી, તે કરીને ફોર્મ સાફ કરે
ખાતરી કિંમત ખાલી શબ્દમાળા છે.

791
00:44:03,220 --> 00:44:06,550
>> અને પછી તે માટે ખોટા પાછા કહે
બીજું ખાતરી કંઇ થાય બનાવે છે.

792
00:44:06,550 --> 00:44:10,350
જો તમે ના ખોટા પાછા જ્યારે
અમલ અટકે છે કે ફોર્મ ઘટના,.

793
00:44:10,350 --> 00:44:14,520
, એક ફોર્મ એક ક્રિયા છે કહે
જેમ એક PHP, પાનું માટે સબમિટ કરો.

794
00:44:14,520 --> 00:44:16,980
તમે પાછા ફર્યા હોત તો
ખોટા, તમે સાચું પાછા લેતો.

795
00:44:16,980 --> 00:44:18,500
તે કે વિનંતી કરી રહ્યા અંત આવશે.

796
00:44:18,500 --> 00:44:20,590
ખોટા રોકનાર તે અને
અહિ તે અટકી જાય છે.

797
00:44:20,590 --> 00:44:23,510

798
00:44:23,510 --> 00:44:28,610
>> જેથી થોડી ડેમો અંગે હતું
ઉલ્કા કામ કરે છે, અને અમે કર્યું છે કે કેવી રીતે

799
00:44:28,610 --> 00:44:30,980
થોડા સમય માટે આ ટ્યુટોરીયલ નીચેની રહ્યો.

800
00:44:30,980 --> 00:44:33,560
અને તમે લાગે કૃપા કરીને કરી શકો છો
મફત આમ ચાલુ રાખવા માટે.

801
00:44:33,560 --> 00:44:37,760
સ્રોતો પુષ્કળ હોય છે,
અને ટ્યુટોરીયલ માત્ર ખરેખર છે

802
00:44:37,760 --> 00:44:40,400
સમજાવીને વિશે ખૂબ જ સારી
શું થઈ રહ્યું છે.

803
00:44:40,400 --> 00:44:44,362
હું માં, હવે તમે બતાવવા માંગો છો નથી
અમે છોડી ગયા છે એ મિનિટો,

804
00:44:44,362 --> 00:44:46,320
આ કેટલાક શું છે
ઉલ્કા ના ઠંડા લક્ષણો,

805
00:44:46,320 --> 00:44:48,772
અને કેટલાક શું છે
વધુ ઉપયોગી પેકેજો.

806
00:44:48,772 --> 00:44:51,730
ઉલ્કા વિશે મહાન વસ્તુઓ છે કે
જો તમે પેકેજ સિસ્ટમ હોય છે.

807
00:44:51,730 --> 00:44:55,620
તમે સરળતાથી કોડ સમાવેશ થઈ શકે
વિકાસકર્તાઓ કે હજારો

808
00:44:55,620 --> 00:44:58,840
વિશ્વભરમાં લખ્યું છે
તમારા ઉલ્કા પ્રોજેક્ટ માં.

809
00:44:58,840 --> 00:45:02,410
આ એક ઉદાહરણ છે તે તમને કદાચ છે
આ ટ્યુટોરીયલ, જ્યાં પગલું નવ માં કરી

810
00:45:02,410 --> 00:45:07,435
તમે ખાતાઓ ઉમેરવા માટે પ્રયાસ કરી રહ્યા છે
તમારા ઉલ્કા પ્રોજેક્ટ માટે.

811
00:45:07,435 --> 00:45:10,010

812
00:45:10,010 --> 00:45:13,690
અમે એક CS50 PHP હોય
પ્રોજેક્ટ, અમે હશે

813
00:45:13,690 --> 00:45:17,810
આ માળખા પર આધાર રાખે છે
અથવા અમારી પોતાની કોડ બનાવવા માટે

814
00:45:17,810 --> 00:45:20,820
અમે સુરક્ષિત સંભાળી ખાતરી
પાસવર્ડ્સ અને વપરાશકર્તા નામો

815
00:45:20,820 --> 00:45:23,120
અને ડેટાબેઝ સ્ટોર
અને તે તમામ.

816
00:45:23,120 --> 00:45:25,670
>> તે ઉલ્કા ધરાવે છે બહાર વળે
પેકેજો, તમારા માટે તે કરવા માટે

817
00:45:25,670 --> 00:45:29,160
અને ખૂબ જ સરળતાથી તે કરવા.

818
00:45:29,160 --> 00:45:31,950
અમે શું કરી શકો છો થોડા પેકેજો ઉમેરવા છે.

819
00:45:31,950 --> 00:45:37,450
તેથી આપણે કે અધિકાર કરવા દો
હવે અમારી કન્સોલમાં.

820
00:45:37,450 --> 00:45:42,460
હું આ પ્રોજેક્ટ છોડી જાઉં છું અને
હમણાં સરળ-todos જાય.

821
00:45:42,460 --> 00:45:47,450

822
00:45:47,450 --> 00:45:50,050
હવે, સરળ-todos છે
આ પ્રોજેક્ટ કે જે તમે

823
00:45:50,050 --> 00:45:53,500
પૂર્ણ બાદ હશે
પગલું 11 અથવા પગલાંની 12 સાથે,

824
00:45:53,500 --> 00:45:55,250
આ ટ્યુટોરીયલ ઓવરને અંતે.

825
00:45:55,250 --> 00:45:58,642
અને તે જોવા માટે ઓછામાં માતાનો ઝડપથી જોવા દો
અમે હોય વિવિધ લક્ષણો શું છે.

826
00:45:58,642 --> 00:46:01,610
ચાલો માત્ર તે ચાલી રહ્યું ખાતરી કરો દો.

827
00:46:01,610 --> 00:46:04,400
ક્યારેક તે જ્યારે લે
તાજું, પરંતુ અહીં તે છે માટે.

828
00:46:04,400 --> 00:46:09,710
>> અમે છુપાવવા માટે અમારા વિકલ્પ હોય
સંપૂર્ણ ક્રિયાઓ, અને અમે સાઇન ઇન કરી શકો છો.

829
00:46:09,710 --> 00:46:11,770
અને આ સાથે કરવામાં આવી હતી
આ ઉલ્કા પેકેજ.

830
00:46:11,770 --> 00:46:12,270
તે મહાન છે.

831
00:46:12,270 --> 00:46:14,910
આપણે હવે વપરાશકર્તા નામ આવ્યા
માં અને પાસવર્ડ સાઇન.

832
00:46:14,910 --> 00:46:19,170
અમે ઉમેરવા માગે તો શું
પ્રવેશ પદ્ધતિ અન્ય પ્રકારનું?

833
00:46:19,170 --> 00:46:22,560
માતાનો હું પ્રવેશ કરવા માગે હવે કહો
મારા ઉલ્કા એકાઉન્ટથી.

834
00:46:22,560 --> 00:46:27,270
હું ઉલ્કા ઉમેરો સ્કોર જાઉં, અને આ રહ્યો
પેકેજો ઉમેરવા માટે વાક્યરચના છે.

835
00:46:27,270 --> 00:46:32,160
હું એકાઉન્ટ્સ, અને accounts.meteor કહી શકો છો.

836
00:46:32,160 --> 00:46:35,720
તે હવે શોધી રહ્યું છે
પેકેજ અને તે ભાર.

837
00:46:35,720 --> 00:46:40,480
તમે મને ન હોય તે જોઈ શકે
જમણી પેકેજ નામ જોવા મળે છે.

838
00:46:40,480 --> 00:46:42,820
>> તેથી તમે કેવી રીતે પેકેજો વિશે શોધવા શકું?

839
00:46:42,820 --> 00:46:46,380
સારું બનાવી એક મહાન વેબસાઇટ, છે
આ ઉલ્કા લોકો દ્વારા ઉપલબ્ધ,

840
00:46:46,380 --> 00:46:47,780
atmospherejs.com કહેવાય.

841
00:46:47,780 --> 00:46:52,520
Atmospherejs, એક શબ્દ, કોઈ
કોમ, એક મહાન ભંડાર છે

842
00:46:52,520 --> 00:46:57,660
આ ઉલ્કા તમામ શોધવા માટે
રીપોઝીટરીમાં પેકેજો.

843
00:46:57,660 --> 00:47:05,140
હું પછી હિસાબ શોધવા, અને કરી શકે છે
તે બધા સંબંધિત સામગ્રી મને બતાવો પડશે,

844
00:47:05,140 --> 00:47:07,320
એકાઉન્ટ નામ સાથે બધા પેકેજો.

845
00:47:07,320 --> 00:47:10,180

846
00:47:10,180 --> 00:47:13,270
>> કે લોડ કરે છે, જ્યારે અમે પ્રયાસ કરી શકો છો
કેટલાક અન્ય પેકેજો ઉમેરી રહ્યા છે.

847
00:47:13,270 --> 00:47:19,380
કદાચ આ ઉલ્કા પેકેજ કામ નથી
હમણાં, પણ મને ફેસબુક ઉમેરી શકો છો.

848
00:47:19,380 --> 00:47:22,860

849
00:47:22,860 --> 00:47:27,190
હું પછી એકાઉન્ટ ઉમેરો અને શકો
ફરીથી ઉલ્કા પ્રોજેક્ટ ચલાવો.

850
00:47:27,190 --> 00:47:33,260

851
00:47:33,260 --> 00:47:36,900
આ શરૂ થાય જાય, માતાનો જોવા દો
શું આ વેબસાઇટ પર બદલાઈ છે.

852
00:47:36,900 --> 00:47:40,010

853
00:47:40,010 --> 00:47:44,580
તમે મને કદાચ see-- શકો
તેને અહીં તાજું કરો છે.

854
00:47:44,580 --> 00:47:47,320
>> હું એક બટન હોય છે
ફેસબુક પ્રવેશ રૂપરેખાંકિત કરો.

855
00:47:47,320 --> 00:47:49,765
અને અહીં, હું બધા પાસે
સૂચનો ઉલ્કા

856
00:47:49,765 --> 00:47:52,960
માટે તમારા માટે તૈયાર કરી છે
એક ફેસબુક એપ્લિકેશન સુયોજિત.

857
00:47:52,960 --> 00:47:58,990
અને તમે તે વાપરી શકો છો
માહિતી તમારી આઇડી ઉમેરો.

858
00:47:58,990 --> 00:48:04,130
તે થઈ રહ્યું એકવાર તમે પડશે
તમારી એપ્લિકેશન માં કામ ફેસબુક પ્રવેશ.

859
00:48:04,130 --> 00:48:08,559
>> હું માત્ર વિચાર જાઉં છું
એક એપ્લિકેશન ID અને એક ગુપ્ત,

860
00:48:08,559 --> 00:48:10,100
ફક્ત આ કામ કરી શકે છે તમે કેવી રીતે બતાવવા માટે.

861
00:48:10,100 --> 00:48:16,000

862
00:48:16,000 --> 00:48:20,360
જો તમે ફેસબુક એકાઉન્ટ જરૂર પડશે
ફેસબુક વિકાસકર્તા વિકલ્પો વાપરવા માટે.

863
00:48:20,360 --> 00:48:31,160

864
00:48:31,160 --> 00:48:35,290
મને માત્ર ઝડપથી શોધવા દો
જરૂરી છે કે ઉલ્કા કીઓ.

865
00:48:35,290 --> 00:48:46,994

866
00:48:46,994 --> 00:48:49,160
હું અન્ય ઉલ્કા પ્રોજેક્ટ હોય
હું ઉપયોગ જાઉં છું કે,

867
00:48:49,160 --> 00:48:55,590
અને હું માત્ર લેવા જાઉં છું
કે ફાઇલમાંથી કીઓ.

868
00:48:55,590 --> 00:49:14,410

869
00:49:14,410 --> 00:49:20,930
>> હું તેને શોધી અને એકવાર, હું હમણાં જ કરી શકશો
મારી ફેસબુક માં આ કીઓ નકલ કરવા.

870
00:49:20,930 --> 00:49:23,489
તેથી અહીં કી છે.

871
00:49:23,489 --> 00:49:24,280
અને આ રહસ્ય છે.

872
00:49:24,280 --> 00:49:26,071
તમને ન હોવી જોઈએ
લોકો સાથે આ શેર.

873
00:49:26,071 --> 00:49:28,870

874
00:49:28,870 --> 00:49:30,910
અને પછી તમે તેને તમારી એપ્લિકેશન ગુપ્ત આપી.

875
00:49:30,910 --> 00:49:33,560
અને આ જેથી ફેસબુક છે
શું તમે ખરેખર હોય જાણે.

876
00:49:33,560 --> 00:49:37,630

877
00:49:37,630 --> 00:49:39,080
અને તમે રૂપરેખાંકન સાચવો.

878
00:49:39,080 --> 00:49:45,160

879
00:49:45,160 --> 00:49:48,640
>> હું પ્રક્રિયા મેં માં લાગે
મારા ઉલ્કા એપ્લિકેશન અટકાવી દેવાયેલ છે.

880
00:49:48,640 --> 00:49:52,290
તેથી હું માત્ર બનાવવા માંગો છો
ખાતરી કરો કે તે હજુ પણ છે.

881
00:49:52,290 --> 00:49:54,962

882
00:49:54,962 --> 00:49:58,610
ઓકે, ચાલો ખાતરી અમારી ઉલ્કા સર્વર બનાવવા દો
તેથી વેબ પૃષ્ઠ ચાલી રહ્યું છે ચાલી રહ્યું છે.

883
00:49:58,610 --> 00:50:02,440
આપણે ઉલ્કા અટકાવવા માટે જો નોટિસ
સર્વર, પાનાંની હજુ પણ અહીં છે.

884
00:50:02,440 --> 00:50:04,700
તે માત્ર હવે અપડેટ નહીં.

885
00:50:04,700 --> 00:50:10,290
આ ઉલ્કા સર્વર જરૂરી છે
ખાતરી કરીને માટે પાનું લાઇવ છે.

886
00:50:10,290 --> 00:50:14,050
>> બરાબર, હું તે રજૂ, અને હવે કર્યું
હું ફેસબુક સાથે સાઇન ઇન કરી શકો છો.

887
00:50:14,050 --> 00:50:17,400
હવે તે માત્ર એક બાબત છે
એક ફેસબુક પોપ અપ કર્યા

888
00:50:17,400 --> 00:50:21,710
અને તમારા એકાઉન્ટમાં મૂકવા
માહિતી અને લોગીંગ માં.

889
00:50:21,710 --> 00:50:24,520

890
00:50:24,520 --> 00:50:27,930
તમે આ કરી જાય, ફેસબુક કદાચ
તમે કેટલાક વધુ સુરક્ષા માટે નાગ.

891
00:50:27,930 --> 00:50:29,810
તેથી અમે માત્ર ત્યાં બંધ કરશો.

892
00:50:29,810 --> 00:50:34,110
આ બિંદુ છે તમે પૂર્ણ કરી ત્યારે તે
તે સાથે, તમે ફેસબુક લૉગિન પડશે.

893
00:50:34,110 --> 00:50:37,850
>> ઉલ્કા સમૂહ છે
અન્ય પેકેજો સાથે સાથે.

894
00:50:37,850 --> 00:50:39,200
તમે Google+ સાથે લોગ ઇન કરી શકો છો.

895
00:50:39,200 --> 00:50:40,500
તમને GitHub સાથે લોગ ઇન કરી શકો છો.

896
00:50:40,500 --> 00:50:42,170
તમે Twitter સાથે લોગ ઇન કરી શકો છો.

897
00:50:42,170 --> 00:50:44,870
તમે શોધવા જો કે, તમે પડશે
અન્ય વસ્તુઓ પુષ્કળ શોધવા

898
00:50:44,870 --> 00:50:49,170
Meetup, LinkedIn જેવી,
અને ઉલ્કા વિકાસકર્તા.

899
00:50:49,170 --> 00:50:53,100
જેથી ઉલ્કા વિકાસકર્તા હતી
પેકેજ હું માટે જોઈ હતી.

900
00:50:53,100 --> 00:50:56,170
ઉલ્કા એકાઉન્ટ્સ-ઉલ્કા-ડેવલપર ઉમેરો.

901
00:50:56,170 --> 00:51:06,192

902
00:51:06,192 --> 00:51:07,900
આ દરમિયાન, હું
પણ ભલામણ કરવા માંગો છો

903
00:51:07,900 --> 00:51:11,340
તમારા પ્રોજેક્ટ માટે અન્ય કેટલાક પેકેજો.

904
00:51:11,340 --> 00:51:14,670
તે ઉપયોગી સાબિત થઈ શકે
જો jQuery પેકેજ સમાવેશ થાય છે.

905
00:51:14,670 --> 00:51:17,909
આ તમે ઉપયોગ કરવા માટે પરવાનગી આપે છે
તમારા ક્લાઈન્ટો માં jQuery.

906
00:51:17,909 --> 00:51:21,200
તમે માત્ર એક વાક્ય સાથે કરી છે, અને શકે
ઉલ્કા ખાતરી કરો કે તમે તારીખ સુધી છો કરશે

907
00:51:21,200 --> 00:51:21,825
jQuery પર.

908
00:51:21,825 --> 00:51:24,330

909
00:51:24,330 --> 00:51:27,450
હું પણ હ્યુસ્ટન ભલામણ: admin.

910
00:51:27,450 --> 00:51:31,550
>> આ એક phpMyAdmin જેવા પ્રકારની છે
તમારા MongoDB માટે સાધન પ્રકારની.

911
00:51:31,550 --> 00:51:33,890
આ તમને સુધારવા દે છે
તમારી માહિતી એકદમ સરળતાથી

912
00:51:33,890 --> 00:51:37,950
આ Mongo શેલ પર જવા કર્યા વગર,
જેમ હું અગાઉ આ પરિસંવાદ માં કર્યું હતું.

913
00:51:37,950 --> 00:51:43,160

914
00:51:43,160 --> 00:51:47,101
તેથી હવે તે ચાલી રહ્યું છે કે, ચાલો ચલાવો
ફરી ઉલ્કા અને અમે શું કરી શકો છો તે જુઓ.

915
00:51:47,101 --> 00:51:56,240

916
00:51:56,240 --> 00:52:00,720
>> તમે અમુક પેકેજોને ઉમેરી રહ્યા છે કે નોટિસ
તેમને કેટલાક ચેતવણીઓ પ્રસ્તુત હોય શકે છે.

917
00:52:00,720 --> 00:52:02,720
તમને ચિંતા કરવાની જરૂર નથી
હ્યુસ્ટન સાથે તે વિશે.

918
00:52:02,720 --> 00:52:06,040

919
00:52:06,040 --> 00:52:10,810
તેથી અમે હવે વિકલ્પ હોય શકે છે
ઉલ્કા સંચાલક રૂપરેખાંકિત કરવા.

920
00:52:10,810 --> 00:52:15,080
અને તેઓ તમને દિશાઓ આપી
તમે તે સેટ કરવા માંગો છો.

921
00:52:15,080 --> 00:52:17,750

922
00:52:17,750 --> 00:52:20,440
>> અમે પણ હવે / સંચાલક જઈ શકો છો.

923
00:52:20,440 --> 00:52:23,280
આ તમે લાવ્યા છે
આ હ્યુસ્ટન પેકેજ દ્વારા.

924
00:52:23,280 --> 00:52:27,470
અને આ ઉલ્કા એડમિન ઈન્ટરફેસ છે.

925
00:52:27,470 --> 00:52:30,660
તમે માત્ર એક બનાવો
સંચાલક ખાતું, જેવા છો.

926
00:52:30,660 --> 00:52:38,150
તમે પાનું તાજું, તો તમે કદાચ
કેટલાક સંગ્રહો બતાવવાનું હોય છે.

927
00:52:38,150 --> 00:52:40,980

928
00:52:40,980 --> 00:52:43,460
>> તે ખૂબ જ ઉપયોગી સાધન છે
અને હું ભારપૂર્વક ભલામણ કરે છે.

929
00:52:43,460 --> 00:52:46,717

930
00:52:46,717 --> 00:52:49,050
તમે કારણ કે જોઈ શકો છો
હ્યુસ્ટન અમુક ભૂલો આપી હતી,

931
00:52:49,050 --> 00:52:52,330
અમે કોઈ સંગ્રહો ન હોય
હમણાં બતાવવાનું.

932
00:52:52,330 --> 00:52:56,800
તમે હ્યુસ્ટન ઉપયોગ કરશે માર્ગ છે
આ કાર્ય નહીં તેની ખાતરી કરીને

933
00:52:56,800 --> 00:52:58,860
તમારા સરળ-todos બોલાવવામાં.

934
00:52:58,860 --> 00:53:01,370
જેથી હ્યુસ્ટન નહી હોય
મારા ક્રિયાઓ શું છે તેની ખબર.

935
00:53:01,370 --> 00:53:04,490
>> અમે એક Mongo સુયોજિત
સંગ્રહ કહેવાય ક્રિયાઓ.

936
00:53:04,490 --> 00:53:11,390
માતાનો સરળ-todos અને માત્ર જાય દો
કે જાવાસ્ક્રિપ્ટ ખાતરી કરો,

937
00:53:11,390 --> 00:53:16,295
અમે અમારા સંગ્રહો ક્રિયાઓ ઉમેર્યું છે.

938
00:53:16,295 --> 00:53:19,340

939
00:53:19,340 --> 00:53:25,670
આપણે હવે સાચવી લીધો છે, અને તે મકાન છે
આ એપ્લિકેશન, પ્રેરણાદાયક.

940
00:53:25,670 --> 00:53:26,750
અને માતાનો જોવા દો.

941
00:53:26,750 --> 00:53:29,090
હવે અમે કેટલીક ક્રિયાઓ ધરાવે છે.

942
00:53:29,090 --> 00:53:32,630
અને અમે કેટલાક નવા કાર્યો ઉમેરી શકો છો.

943
00:53:32,630 --> 00:53:35,840
પરંતુ અમે ક્રિયાઓ ઉમેરવા માંગતા હોય તો,
માતાનો એપ્લિકેશન પોતે સાથે કરી દો.

944
00:53:35,840 --> 00:53:39,660

945
00:53:39,660 --> 00:53:41,050
>> હવે અમે અમુક માહિતી ઉમેરી શકો છો.

946
00:53:41,050 --> 00:53:53,410
હાય, આ એક કાર્ય છે.

947
00:53:53,410 --> 00:53:57,080
તે પ્રકારની વિચિત્ર કે લાગે
અમે કોઈ ક્રિયાઓ જોયા નથી.

948
00:53:57,080 --> 00:54:00,290

949
00:54:00,290 --> 00:54:05,260
અમે કોઈ મળ્યું તો અમે તપાસ કરવા માંગો છો શકે છે
અહીં, અથવા કદાચ બીજે ક્યાંય ભૂલો.

950
00:54:05,260 --> 00:54:08,810

951
00:54:08,810 --> 00:54:20,260
અમે સંચાલક જાય તો, તે વિચિત્ર લાગે છે.

952
00:54:20,260 --> 00:54:24,080
તમે રીપોઝીટરી ખેંચી તો
આ પરિસંવાદ પછી,

953
00:54:24,080 --> 00:54:27,580
હું ખાતરી કરો કે કરશે
સરળ-todos હ્યુસ્ટન સાથે કામ કરે છે.

954
00:54:27,580 --> 00:54:30,370
કમનસીબે, તે નથી લાગતું નથી
આ ખૂબ જ ક્ષણે કામ કરી.

955
00:54:30,370 --> 00:54:34,810

956
00:54:34,810 --> 00:54:37,640
>> અન્ય કોઇ પ્રશ્નો હોય છે?

957
00:54:37,640 --> 00:54:41,800
હ્યુસ્ટન સામાન્ય છે એક
ખૂબ જ સારી રીતે કામ કરે છે કે સાધન.

958
00:54:41,800 --> 00:54:44,510
હ્યુસ્ટન ખાસ થોડી છે
બીજી કરતા buggier,

959
00:54:44,510 --> 00:54:49,470
પણ હું તે કામ કરે છે જ્યારે તેને ભલામણ કરું છું.

960
00:54:49,470 --> 00:54:50,080
હા.

961
00:54:50,080 --> 00:54:52,395
>> પ્રેક્ષક: તમે શું કરી શકો
આ ફેસબુક પેકેજ સાથે

962
00:54:52,395 --> 00:54:54,270
વપરાશકર્તા લોગ થયેલ વાર
તેમના ફેસબુક સાથે?

963
00:54:54,270 --> 00:54:55,978
>> ROGER ZURAWICKI: એકવાર
વપરાશકર્તા, પ્રવેશેલ

964
00:54:55,978 --> 00:54:59,540
તમે ફેસબુક API માં કોલ કરી શકશો.

965
00:54:59,540 --> 00:55:02,890
કે ઘણાં વધારે આવેલું
કેવી ફેસબુક તેમના API ખોલે છે.

966
00:55:02,890 --> 00:55:05,120
ઉલ્કા, તમે ખાતરી કરો
આ કનેક્શન છે.

967
00:55:05,120 --> 00:55:09,300
પરંતુ તે પછી બધું બાબત છે
ના ફેસબુક API નો ઉપયોગ કેવી રીતે શીખવા.

968
00:55:09,300 --> 00:55:10,216
AUDIENCE: [અશ્રાવ્ય].

969
00:55:10,216 --> 00:55:17,756

970
00:55:17,756 --> 00:55:18,880
ROGER ZURAWICKI: બધા અધિકાર.

971
00:55:18,880 --> 00:55:21,670
માટે ખૂબ ખૂબ આભાર
ઉલ્કા માં આ CS50 સેમિનાર.

972
00:55:21,670 --> 00:55:24,060
જો તમે કોઇ પ્રશ્નો હોય તો,
તમે મને ઇમેઇલ કરી શકો છો

973
00:55:24,060 --> 00:55:28,319
મારા ઇમેઇલ સરનામાં પર
આ પરિસંવાદ નીચે યાદી થયેલ.

974
00:55:28,319 --> 00:55:30,110
અને હું ખુશ રહેશો
તમારા પ્રશ્નો જવાબ.

975
00:55:30,110 --> 00:55:33,020
હું પણ અંતે હશો
CS50 Hackathon જોઇએ

976
00:55:33,020 --> 00:55:35,550
તમે તમારા ઉલ્કા પ્રોજેક્ટ સાથે મદદ જરૂર છે.

977
00:55:35,550 --> 00:55:37,650
જોવાનું બદલ આભાર.

978
00:55:37,650 --> 00:55:38,816