1
00:00:00,000 --> 00:00:08,350

2
00:00:08,350 --> 00:00:09,710
>> કેપી સ્ચમિડ: બધાને હેલો.

3
00:00:09,710 --> 00:00:12,640
આ CS50 પરિસંવાદ પર આપનું સ્વાગત છે
Node.js. પર

4
00:00:12,640 --> 00:00:13,955
મારું નામ કેપી છે.

5
00:00:13,955 --> 00:00:15,580
હું એક CS50 ટીએફ છું.

6
00:00:15,580 --> 00:00:17,650
અને હું પ્રકારના ખરેખર ઉત્સાહિત છું,
આ સેમિનાર વિશે.

7
00:00:17,650 --> 00:00:20,430
હું Node.js ખૂબ ઠંડી છે.

8
00:00:20,430 --> 00:00:24,200
હું આ પરિસંવાદ ઉપયોગ કરી શકાય છે આશા
માટે એક સારા, હું માનું, springboard તરીકે

9
00:00:24,200 --> 00:00:26,380
તમારી અંતિમ પ્રોજેક્ટ, તો કેટલાક
તમે ઉપયોગ કરવા માંગતા હો

10
00:00:26,380 --> 00:00:27,630
Node.js. કંઈક

11
00:00:27,630 --> 00:00:29,770

12
00:00:29,770 --> 00:00:33,320
>> અમે પ્રકારના દ્વારા સેમિનાર બંધ શરૂ કરી શકશો
માત્ર એક થોડો વિશે વાત

13
00:00:33,320 --> 00:00:36,970
પૃષ્ઠભૂમિ માપનીયતા કાઇન્ડ
પછી Node.js પર્સ્પેક્ટિવ ઓફ, અને

14
00:00:36,970 --> 00:00:39,240
અમે કેટલાક કોડ ઉદાહરણો ખસેડવા પડશે.

15
00:00:39,240 --> 00:00:42,340
અને હું એક વેબસાઇટ પર કોડ પડશે,
અને તમે કોડ જોવા કરી શકો છો.

16
00:00:42,340 --> 00:00:45,475
અને સેમિનાર બાદ, હું ચર્ચા સૉર્ટ પડશે
તમે Node.js સેટ કરી શકો છો તે વિશે

17
00:00:45,475 --> 00:00:48,220
તમારા કમ્પ્યુટર પર.

18
00:00:48,220 --> 00:00:48,710
>> બરાબર.

19
00:00:48,710 --> 00:00:49,760
તેથી આપણે પ્રારંભ કરીએ.

20
00:00:49,760 --> 00:00:53,700
તેથી હું માત્ર વિશે વાત કરવા માંગો છો ધારી
વેબ સર્વરો, ખરેખર, પ્રથમ.

21
00:00:53,700 --> 00:00:59,730
અને આ ચર્ચા શરૂ કરવા માટે, હું
મૂળભૂત છે કે જે આકૃતિ છે

22
00:00:59,730 --> 00:01:04,269
CS61 માટે વપરાય પુસ્તક, જે
મૂળભૂત રીતે અરસપરસ છે

23
00:01:04,269 --> 00:01:08,510
તમારા વેબ જેવા ક્લાયન્ટ પ્રક્રિયા વચ્ચે
બ્રાઉઝર અથવા તમારા હેતુ ક્લાઈન્ટ અથવા જેમ

24
00:01:08,510 --> 00:01:11,340
તે કંઈક, અને વેબ સર્વર.

25
00:01:11,340 --> 00:01:15,150
તેથી આ પ્રકારની જેવું જ દેખાય છે
તમે પર વ્યાખ્યાન માં જોયું કે ચિત્ર

26
00:01:15,150 --> 00:01:19,270
બુધવાર જ્યાં મૂળભૂત રીતે અમે કેટલાક છે
ગૂગલ ક્રોમ જેવા ક્લાયન્ટ પ્રક્રિયા.

27
00:01:19,270 --> 00:01:22,980
>> અને પછી પગલું એક છે
ક્લાઈન્ટ વિનંતી મોકલે છે.

28
00:01:22,980 --> 00:01:27,510
જેથી કંઈક જેમ જ આપણે બની શકે છે
મુલાકાત, હું CS50.net ખબર નથી.

29
00:01:27,510 --> 00:01:29,320
તેથી અમે તે વિનંતી બહાર પાડે છે.

30
00:01:29,320 --> 00:01:34,280
અને કોઇપણ નામ યાદ નથી
કેવી રીતે સ્પષ્ટ કરે છે કે કે પ્રોટોકોલ

31
00:01:34,280 --> 00:01:35,610
વિનંતી રચાયેલ જોઇએ?

32
00:01:35,610 --> 00:01:36,382
હા.

33
00:01:36,382 --> 00:01:37,650
>> પ્રેક્ષક: [અશ્રાવ્ય].

34
00:01:37,650 --> 00:01:38,150
>> કેપી સ્ચમિડ: ચોક્કસ.

35
00:01:38,150 --> 00:01:40,100
તેથી તે, HTTP, જેવું છે?

36
00:01:40,100 --> 00:01:44,720
કેવી રીતે જેથી મૂળભૂત સ્પષ્ટીકરણ
કે વિનંતી ખરેખર નાખ્યો જોઈએ

37
00:01:44,720 --> 00:01:47,450
બહાર, કારણ કે આ દિવસે ઓવરને અંતે,
કે વિનંતી ખરેખર માત્ર ગમે છે

38
00:01:47,450 --> 00:01:50,240
શબ્દમાળા કે મૂળભૂત રીતે
હું આ કરવા માંગો છો કહે છે.

39
00:01:50,240 --> 00:01:53,580
અને સ્પષ્ટીકરણ
તે માટે HTTP છે.

40
00:01:53,580 --> 00:01:55,270
જેથી એ પ્રોટોકોલ જેવું છે.

41
00:01:55,270 --> 00:01:57,920
>> તેથી પછી સર્વર મેળવે
કે વિનંતી.

42
00:01:57,920 --> 00:02:01,610
તેથી જો તમે ગાય્સ એક વેબ સર્વર સ્થાપિત કરેલ છે
CS50 સાધન છે.

43
00:02:01,610 --> 00:02:02,460
તે અપાચેના.

44
00:02:02,460 --> 00:02:06,230
અને આ અઠવાડિયે તમે સમસ્યા પર કામ જ્યારે
સાત સેટ, તમે ખરેખર કામ કરીશું

45
00:02:06,230 --> 00:02:08,160
કે વેબ સર્વર સાથે.

46
00:02:08,160 --> 00:02:12,380
તેથી આ સર્વર તે અરજી મેળવે છે, અને
પછી તે પ્રકારની ખંજવાળી છે તેના

47
00:02:12,380 --> 00:02:15,090
માથા અને શું સારી રીતે જેમ કહે
હું આ સાથે શું છે?

48
00:02:15,090 --> 00:02:20,060
>> તેથી તે પછી, કરવા માટે નક્કી છે તેના પર આધારિત છે
તે અમુક પ્રકારના સંપર્ક હોઈ શકે છે

49
00:02:20,060 --> 00:02:20,730
સ્ત્રોત છે.

50
00:02:20,730 --> 00:02:23,700
અને તે સ્ત્રોત એક હોઈ શકે છે
અલગ વસ્તુઓ ઘણો.

51
00:02:23,700 --> 00:02:26,810
એક, તે હોઈ શકે છે માત્ર
સ્થિર HTML ફાઇલ છે.

52
00:02:26,810 --> 00:02:29,820
તેથી તે માત્ર કેટલાક જેવા છે
માટે જેમ કે એચટીએમએલ

53
00:02:29,820 --> 00:02:31,100
તમારી વ્યક્તિગત વેબસાઇટ.

54
00:02:31,100 --> 00:02:35,360
તે એક છબી જેવા સ્થિર ફાઇલ હોય શકે છે
અથવા તમારી પાસે છે કે જે ફિલ્મ જેવી.

55
00:02:35,360 --> 00:02:37,660
તે પણ વાત કરી શકે છે
ડેટાબેઝ અમુક પ્રકારના માટે

56
00:02:37,660 --> 00:02:39,530
એક માયએસક્યુએલ ડેટાબેઝ જેવા હોય છે.

57
00:02:39,530 --> 00:02:43,910
તેથી તે હંમેશા વાતચીત નથી
એક સાધન છે, પરંતુ સાથે

58
00:02:43,910 --> 00:02:45,700
કેટલાક કિસ્સાઓમાં, તે કરી શકે.

59
00:02:45,700 --> 00:02:47,800
>> તેથી પછી તે કરી રહ્યું છે તે
કે પછી તે હશે છે

60
00:02:47,800 --> 00:02:49,430
પ્રતિભાવ પાછા મોકલો.

61
00:02:49,430 --> 00:02:53,130
અને આ માટે જવાબ છે
પણ HTTP, સ્પષ્ટ કરેલ છે.

62
00:02:53,130 --> 00:02:54,830
તેથી પછી ક્લાઈન્ટ તે મેળવી શકે છે.

63
00:02:54,830 --> 00:02:56,740
તે સિવાય તે નાખીને તેની પર પ્રક્રિયા કરી શકો છો.

64
00:02:56,740 --> 00:03:00,900
અને પછી તમે વેબ પાનું વિચાર
જેમ Google અથવા CS50.net અથવા

65
00:03:00,900 --> 00:03:02,240
તમે ગયા ગમે.

66
00:03:02,240 --> 00:03:03,100
બરાબર?

67
00:03:03,100 --> 00:03:06,080
>> તેથી આ મૂળભૂત આદાનપ્રદાન છે કે
અમે સાથે કામ કરી રહ્યા છીએ.

68
00:03:06,080 --> 00:03:08,770
અને અમે ખૂબ ખૂબ કરી રહ્યા છીએ
આ આ ભાગ પર ધ્યાન કેન્દ્રિત

69
00:03:08,770 --> 00:03:10,640
ક્રિયાપ્રતિક્રિયા, સર્વર.

70
00:03:10,640 --> 00:03:10,990
બરાબર.

71
00:03:10,990 --> 00:03:12,210
કૂલ.

72
00:03:12,210 --> 00:03:15,500
ત્યાં જવા માટે કોઇપણ અત્યાર સુધી કોઇ પ્રશ્નો હોય?

73
00:03:15,500 --> 00:03:17,720
બરાબર.

74
00:03:17,720 --> 00:03:22,430
>> અમે જણાવ્યું હતું કે જેથી, વેબ સર્વર મેળવે
પછી આ HTTP વિનંતિ અને આ મુદ્દાઓ

75
00:03:22,430 --> 00:03:24,760
HTTP પ્રતિસાદ.

76
00:03:24,760 --> 00:03:29,100
અને જેમ અમે પહેલાં વિશે વાત કરી
CS50 સાધન વેબ સર્વર અપાચે છે.

77
00:03:29,100 --> 00:03:32,490
તમે ગાય્ઝ પર કામ તેથી જ્યારે પી, સાત સેટ
તમે સાથે કામ કરી રહ્યા છીએ

78
00:03:32,490 --> 00:03:34,120
અપાચે વેબ સર્વર.

79
00:03:34,120 --> 00:03:37,890
તમે ખરેખર કામ હોય છે ક્યારેય પડશે
સીધા ખૂબ જ અપાચે સાથે.

80
00:03:37,890 --> 00:03:41,920
તમે પ્રકારના અપાચે થોડી રૂપરેખાંકિત
તમે વર્ચ્યુઅલ યજમાનો અથવા સ્પષ્ટ જ્યારે

81
00:03:41,920 --> 00:03:44,970
વી યજમાનો, અને અમે મળશે
થોડો માં કે.

82
00:03:44,970 --> 00:03:50,620
>> પરંતુ મૂળભૂત રીતે, અપાચે વેબ સર્વર
PHP, પ્રકારની સાથે કામ કરવા માટે સેટ

83
00:03:50,620 --> 00:03:51,730
ના બોક્સની બહાર.

84
00:03:51,730 --> 00:03:56,170
જ્યારે તમે જાઓ તો શું ખરેખર થાય છે
કહે છે, જેમ તમારા વેબસાઇટ્સ માટે,

85
00:03:56,170 --> 00:04:00,360
સ્થાનિક યજમાન સ્લેશ index.php અથવા કંઈક,
તમારા બ્રાઉઝર મોકલે છે

86
00:04:00,360 --> 00:04:04,330
વિનંતી અને પછી અપાચે બેઠક છે
ત્યાં અને તેની સાથે શું કરવું આંકડા.

87
00:04:04,330 --> 00:04:08,840
અને ક્રિયા ચલાવવાની છે
કે index.php માં કોડ અને

88
00:04:08,840 --> 00:04:11,330
પછી પાછા તે બંધ મોકલો.

89
00:04:11,330 --> 00:04:15,640
જેથી તે ત્યાં છે.

90
00:04:15,640 --> 00:04:16,980
તેથી અમે પ્રકારની આ વિશે વાત કરી હતી.

91
00:04:16,980 --> 00:04:21,990
તેથી તે માત્ર એક સ્થિર ફાઇલને સેવા કરી શકે છે
અથવા મુદ્દો પછી કેટલાક PHP કોડ ચલાવો અને

92
00:04:21,990 --> 00:04:23,510
પ્રતિભાવ.

93
00:04:23,510 --> 00:04:27,670
>> આવી શકે છે કે તેથી તો એક સામાન્ય પ્રશ્ન
ઉપર સારી છે, અમે કેવી રીતે ખરેખર કામ પાર કરી શકું

94
00:04:27,670 --> 00:04:31,750
ઘણા વપરાશકર્તાઓ ધરાવતા
તે જ સમયે?

95
00:04:31,750 --> 00:04:36,930
તમે વેબ લખી હતી તેથી જો કલ્પના
સર્વર, તમે વેબ સર્વર હોય તો કે

96
00:04:36,930 --> 00:04:39,900
તમે કંઈક લખી પ્રયાસ કરી રહ્યા હતા
સી કે કંઈક જેમ,

97
00:04:39,900 --> 00:04:45,150
મૂળભૂત રીતે તમે વિશે વિચાર કરી શકો છો કેવી રીતે ત્યાં
કોડ અમુક પ્રકારના હોઈ શકે છે

98
00:04:45,150 --> 00:04:49,330
પછી પ્રાપ્ત છે, પરંતુ કરશે
તે તેના પર આ બધા કામ કરી છે.

99
00:04:49,330 --> 00:04:53,060
તે, ઉદાહરણ તરીકે, સંપર્ક હોઈ શકે છે આ
ડેટાબેઝ અથવા તે કંઈક.

100
00:04:53,060 --> 00:04:53,300
અધિકાર?

101
00:04:53,300 --> 00:04:56,010
અને પછી તેને તે પ્રકારના કરી શકે છે
પ્રક્રિયા અને પછી

102
00:04:56,010 --> 00:04:57,060
પ્રતિભાવ પરત મોકલવામાં.

103
00:04:57,060 --> 00:04:58,950
જેથી ઉચ્ચ જેવું છે
સ્તર ઝાંખી.

104
00:04:58,950 --> 00:05:04,210
>> પરંતુ તે તરત જ સ્પષ્ટ નથી તમે કેવી રીતે
કરી શકો છો કે જે બે લોકો અથવા

105
00:05:04,210 --> 00:05:09,040
પણ 1,000 લોકો સાથે કામ કરી શકે છે તમારા
તે જ સમયે વેબ સર્વર.

106
00:05:09,040 --> 00:05:14,880
તેથી અપાચે ઉપયોગ કરે છે ઉકેલ
થ્રેડો અથવા પ્રક્રિયાઓ કહેવામાં આવે છે.

107
00:05:14,880 --> 00:05:16,770
તેથી તમે સાંભળ્યું હશે
પહેલાં આ શબ્દો.

108
00:05:16,770 --> 00:05:22,190
તે તમે ન હોય તો બરાબર છે, પરંતુ માત્ર લાગે છે
માટે રીતે તરીકે થ્રેડો અથવા પ્રક્રિયાઓ વિશે

109
00:05:22,190 --> 00:05:26,290
ઓપરેટિંગ સિસ્ટમ અથવા વપરાશકર્તા કાર્યક્રમ અથવા
તે કંઈક કે વેબ સર્વર

110
00:05:26,290 --> 00:05:28,810
પ્રકારના ઘણા ચલાવવા માટે
એક જ સમયે વસ્તુઓ.

111
00:05:28,810 --> 00:05:31,760
તેથી તમે આ શબ્દ સાંભળ્યું હશે
અમલ થ્રેડો છે.

112
00:05:31,760 --> 00:05:34,140
તમે છો તેથી તે પ્રકારની છે
મલ્ટીટાસ્કીંગની સૉર્ટ કરો.

113
00:05:34,140 --> 00:05:37,710
>> અને તમે ના બોક્સ પર જોઇ છે તો તમારા
લેપટોપ, અથવા તે કંઈક,

114
00:05:37,710 --> 00:05:43,040
તમે શું કરી શકો મલ્ટિકોર, તમે આ કરી શકો છે
વિવિધ પર બે અલગ અલગ થ્રેડો ચલાવો

115
00:05:43,040 --> 00:05:46,700
એ CPU ભાગો તેઓ કરી શકે છે કે જેથી
ખરેખર તે જ સમયે થાય છે.

116
00:05:46,700 --> 00:05:48,100
તેથી આ ખરેખર શક્તિશાળી છે.

117
00:05:48,100 --> 00:05:52,270
અને આ અપાચેના પ્રકારની છે
આ સમસ્યા માટે ઉકેલ.

118
00:05:52,270 --> 00:05:57,900
>> તેથી પ્રકારની કોઈપણ મુદ્દાઓ જેવા છે
જોકે આ અભિગમ સાથે?

119
00:05:57,900 --> 00:05:59,870
તેથી હું હું પ્રકારની ત્યાં તેમને લખ્યું ધારી.

120
00:05:59,870 --> 00:06:03,440
પરંતુ બંને પ્રકારના
મેમરીની જરુર ઉપયોગ કરે છે.

121
00:06:03,440 --> 00:06:07,490
તે બનાવવા માટે ખૂબ જ ખર્ચાળ છે
એક થ્રેડ અથવા પ્રક્રિયા.

122
00:06:07,490 --> 00:06:11,750
>> અને તર્ક ભાગ છે કે જે હમણાં જ
જેમ તમે એક સી કાર્યક્રમ ચલાવી રહ્યા છો ત્યારે

123
00:06:11,750 --> 00:06:15,090
તમારા મુખ્ય જેમ અને પછી તે કોલ
અન્ય કાર્ય, કે છે

124
00:06:15,090 --> 00:06:16,520
સ્ટેક અમુક પ્રકારના.

125
00:06:16,520 --> 00:06:19,910
તેથી થ્રેડો પણ સંપૂર્ણપણે એક જરૂરી
અલગ સ્ટેક જે

126
00:06:19,910 --> 00:06:21,220
ખૂબ મોટી હોઈ શકે છે.

127
00:06:21,220 --> 00:06:25,170
અને તમે કલ્પના કરી શકો છો જો ટન કર્યા
તમારી વેબસાઇટ પર વપરાશકર્તાઓ, તમારી પાસે હોત

128
00:06:25,170 --> 00:06:26,280
અલગ થ્રેડો ઘણો.

129
00:06:26,280 --> 00:06:28,230
તે માટે રન ટાઇમ સ્ટેકનું ઘણો છે
વ્યવસ્થા કરો અને જાળવી રાખે છે.

130
00:06:28,230 --> 00:06:31,280
તેથી તે મોટા મેમરી વપરાશ છે.

131
00:06:31,280 --> 00:06:35,650
>> અને પછી, પણ, તમે જ હવે કહો
એક સીપીયુ, અથવા તમારી પાસે કહેવું

132
00:06:35,650 --> 00:06:38,460
તમારી પાસે કરતાં વધુ થ્રેડો
તે multicores.

133
00:06:38,460 --> 00:06:38,730
અધિકાર?

134
00:06:38,730 --> 00:06:43,280
તેથી આપણે તમે 10 થ્રેડો હતી કહેવું
અને તમે માત્ર પાંચ સીપીયુ હતી.

135
00:06:43,280 --> 00:06:46,260
તમે પ્રકારની આ વસ્તુ કરવા માટે હોય છે
તમે વર્તમાન વચ્ચે ફેરબદલી

136
00:06:46,260 --> 00:06:49,090
તમે કારણ કે ચાલી રહ્યું છે કે એક
એક જ સમયે તમામ 10 રન કરી શકતા નથી.

137
00:06:49,090 --> 00:06:50,980
અને તે એક સંદર્ભ સ્વીચ તરીકે ઓળખાય છે.

138
00:06:50,980 --> 00:06:54,260
અને તે શબ્દ ખરેખર એક દંપતિ છે
અલગ અલગ સંદર્ભમાં, પરંતુ માત્ર દો

139
00:06:54,260 --> 00:06:56,620
સ્વિચ તરીકે તેનો વિચાર કરો
બે થ્રેડો વચ્ચે.

140
00:06:56,620 --> 00:06:59,730
કે ખૂબ ખર્ચાળ હોઇ શકે છે, કારણ કે
મૂળભૂત રીતે તમે શું કરવા છે કે તમે છે

141
00:06:59,730 --> 00:07:03,340
તમે શું કરી રહ્યાં છો રોકવા પડે છે, સંગ્રહો
કે ચાલી થ્રેડ રાજ્ય

142
00:07:03,340 --> 00:07:05,440
પછી બીજે ક્યાંય પર સ્વિચ.

143
00:07:05,440 --> 00:07:09,420
>> તેથી બધાને પ્રકારની શું વિચારે છે
શા માટે થ્રેડો અને પ્રેરણા

144
00:07:09,420 --> 00:07:12,030
પ્રક્રિયા થોડી ભારે છે?

145
00:07:12,030 --> 00:07:13,840
અને તમે એક પ્રશ્ન છે?

146
00:07:13,840 --> 00:07:14,376
બરાબર.

147
00:07:14,376 --> 00:07:15,070
કૂલ.

148
00:07:15,070 --> 00:07:18,090
ત્યાં જવા માટે કોઇપણ કોઇ પ્રશ્નો હોય?

149
00:07:18,090 --> 00:07:19,620
બરાબર.

150
00:07:19,620 --> 00:07:26,720
>> તેથી અમે એક બીજા માટે એક પગલું લઈ જો,
પ્રકારની એક જેવા છે

151
00:07:26,720 --> 00:07:30,350
અમે વિશે કરી શકો છો કે અવલોકન
વેબ એપ્લિકેશન્સ ઘણો.

152
00:07:30,350 --> 00:07:34,810
અને તે ખરેખર છે કે તેમને ઘણો
ખરેખર નથી કે ખૂબ ઉપયોગી

153
00:07:34,810 --> 00:07:37,140
એક થ્રેડ ની અંદર કામ કરે છે.

154
00:07:37,140 --> 00:07:41,170
તેથી કોઈની પર શરૂ કરી છે
પી બધા સાત સેટ?

155
00:07:41,170 --> 00:07:45,650
તેથી તમે કદાચ વર્ણન કરવા માંગો છો
આ ભાગમાં કેટલાક?

156
00:07:45,650 --> 00:07:47,850
You પ્રવેશ પર કામ કર્યું છે
અથવા તે કંઈક?

157
00:07:47,850 --> 00:07:49,330
>> પ્રેક્ષક: ના,

158
00:07:49,330 --> 00:07:49,780
>> કેપી સ્ચમિડ: બરાબર.

159
00:07:49,780 --> 00:07:50,150
કશો વાંધો નહીં.

160
00:07:50,150 --> 00:07:50,900
માફ કરશો.

161
00:07:50,900 --> 00:07:55,790
પરંતુ મૂળભૂત રીતે, આ પૃષ્ઠ સેટ, તમે છો
જેવું ઘણો કરી રહ્યા

162
00:07:55,790 --> 00:07:59,760
કેટલાક વિચાર ડેટાબેઝ માટે પ્રશ્નો
કે ડેટાબેઝમાંથી માહિતી.

163
00:07:59,760 --> 00:08:03,330
અને શું તમારો કોડ કરવાનું કરી રહ્યું છે,
શું કે અપાચે પ્રક્રિયા અથવા

164
00:08:03,330 --> 00:08:06,030
અપાચે થ્રેડ કરી શકાય તેવું રહ્યું છે
તે સંપર્ક છે, જ્યારે

165
00:08:06,030 --> 00:08:08,990
ડેટાબેઝ તે પ્રકારના જ હશે છે
ત્યાં બેઠક અને તે જ હશે

166
00:08:08,990 --> 00:08:12,130
ડેટાબેઝ જવાબ માટે રાહ જોઈ રહ્યું.

167
00:08:12,130 --> 00:08:16,290
>> હવે કે જે મોટા જેમ અવાજ નથી શકે છે
ડેટાબેઝ તમારા પર છે કારણ કે વ્યવહાર

168
00:08:16,290 --> 00:08:18,240
CS50 સાધન, અધિકાર?

169
00:08:18,240 --> 00:08:22,930
પરંતુ નેટવર્ક અમુક પ્રકારના છે
ત્યાં લેટન્સીના હવે વેબ કારણ કે

170
00:08:22,930 --> 00:08:26,830
સર્વર સાથે તેની પોતાની વિનંતી અદા છે
આ સાથે વાતચીત કરવા માટે ડેટાબેઝ

171
00:08:26,830 --> 00:08:29,520
ડેટાબેઝ અને પછી તે વિષે
માહિતી પાછા.

172
00:08:29,520 --> 00:08:33,190
તેથી હવે હું છું, સાથે સાથે મારા માટે રાહ જેવું છે
જાઓ જઈને માંથી કંઈક વિચાર

173
00:08:33,190 --> 00:08:35,770
ડેટાબેઝ અને પછી છે
રહ્યું રાહ ઘણો.

174
00:08:35,770 --> 00:08:36,870
કે અર્થમાં છે?

175
00:08:36,870 --> 00:08:38,580
>> અને કેટલીક વસ્તુઓ માટે છે કે ખરાબ નથી.

176
00:08:38,580 --> 00:08:41,950
તે માત્ર છે, ઉદાહરણ તરીકે,
એક્સેસ મેમરી, આવું જ નથી

177
00:08:41,950 --> 00:08:44,100
ભયાનક I / O નો લેટન્સી.

178
00:08:44,100 --> 00:08:47,110
અને જ્યારે હું કહી, I / O નો લેટન્સી, હું છું શું
ઉલ્લેખ જેવા કોઇ પણ પ્રકારની જેવું છે

179
00:08:47,110 --> 00:08:48,290
ઇનપુટ આઉટપુટ.

180
00:08:48,290 --> 00:08:52,950
પરંતુ, જેમ કે ડિસ્ક પર ફાઈલ વાપરવા માટે
હું સ્થિર એચટીએમએલ સેવા કરવા ઇચ્છતા હોય તો

181
00:08:52,950 --> 00:08:57,850
ફાઈલ કે મારી વેબ પર હતી અથવા
તે કંઈક, હું પ્રકારની છે

182
00:08:57,850 --> 00:09:02,310
ઘડીભર બંધ, તે ફાઇલ વાંચી
ડિસ્ક પ્રમાણે, અને પછી માં માં

183
00:09:02,310 --> 00:09:04,400
તે પ્રક્રિયા હું રાહ જોઈ રહ્યો છું.

184
00:09:04,400 --> 00:09:06,700
હું ઉપયોગી કામ નથી કરી રહ્યો છું.

185
00:09:06,700 --> 00:09:11,270
>> આ બધું સાચું નથી, પરંતુ
પી સેટ જેવા કાર્યક્રમોમાં સામાન્ય છે

186
00:09:11,270 --> 00:09:13,960
સાત અને કાર્યક્રમો ઘણો
તમે નથી કે

187
00:09:13,960 --> 00:09:15,440
ખરેખર ખૂબ વિચાર કરી.

188
00:09:15,440 --> 00:09:19,090
હું વિચાર કહે છે ત્યારે, હું તેનો અર્થ
કોમ્પ્યુટેશનલ કામ ગમે છે.

189
00:09:19,090 --> 00:09:23,270
તેથી કોમ્પ્યુટેશનલ કામ કંઈક હોઈ શકે છે
જેમ કહે છે, તમે ઇચ્છતા

190
00:09:23,270 --> 00:09:26,590
માત્ર ગણતરી કે વેબ સર્વર લખો
આ nth ફિબોનાકી નંબર.

191
00:09:26,590 --> 00:09:29,300
કે જે ખાસ કરીને જેમ અવાજ નથી
મજા વેબ સર્વર.

192
00:09:29,300 --> 00:09:34,220
જેમ હું તે સાઇટ નથી અપેક્ષા નથી
આગામી ફેસબુક, પરંતુ તે કેટલાક છે

193
00:09:34,220 --> 00:09:35,610
કોમ્પ્યુટેશનલ કામ પ્રકારની.

194
00:09:35,610 --> 00:09:39,570
>> અને તમે સાથે બદલી કલ્પના કરી શકો છો
રસપ્રદ કેટલાક અન્ય પ્રકારની

195
00:09:39,570 --> 00:09:43,070
કોમ્પ્યુટેશનલ કામ કરે છે.

196
00:09:43,070 --> 00:09:46,050
માતાનો તમે કંઈક લખી હતી કહો
કે ડિગ્રી ગણતરી

197
00:09:46,050 --> 00:09:49,170
બે લોકો વચ્ચે અલગ
અથવા તે કંઈક.

198
00:09:49,170 --> 00:09:51,860
જેથી અમુક પ્રકારના સમાવેશ કરે છે
ગણતરી, અધિકાર?

199
00:09:51,860 --> 00:09:56,630
પણ પછી, તમે હજુ પણ હોય છે તે કરવા માટે
કદાચ પ્રતીક્ષા માટે ઘણો કરવા માટે

200
00:09:56,630 --> 00:09:59,550
તમે જોવા માટે ડેટાબેઝ ક્વેરી હોય છે
ઉપર જે જે અથવા મિત્ર છે

201
00:09:59,550 --> 00:10:00,600
તે કંઈક.

202
00:10:00,600 --> 00:10:03,510
તેથી કલ્પના તે પ્રકારના છે
ના કોમ્પ્યુટેશનલ કામ કરે છે.

203
00:10:03,510 --> 00:10:05,260
કે અર્થમાં છે?

204
00:10:05,260 --> 00:10:08,258
કોઈની કોઇ પ્રશ્નો હોય તો?

205
00:10:08,258 --> 00:10:11,960
>> ઓહ અને હું હું ત્યાં ચેટ સર્વરો મૂકી ધારી
ચેટ સર્વરો પ્રકારની છે કારણ કે

206
00:10:11,960 --> 00:10:13,240
આ અન્ય સારું ઉદાહરણ.

207
00:10:13,240 --> 00:10:15,250
ચેટ સર્વર નથી
ખૂબ વિચાર કરવા માટે.

208
00:10:15,250 --> 00:10:18,350
તે માત્ર લોકો માટે રાહ છે
સંદેશા અને પછી જ્યારે મોકલો

209
00:10:18,350 --> 00:10:19,800
તેઓ મોકલી છે.

210
00:10:19,800 --> 00:10:21,050
બરાબર?

211
00:10:21,050 --> 00:10:23,410

212
00:10:23,410 --> 00:10:28,180
>> તેથી માત્ર ફરીથી રીકેપ માટે, અપાચે અને
કે કાંટો એક જેવી જ વેબ સર્વરો

213
00:10:28,180 --> 00:10:31,470
સૂત્રો અને પ્રક્રિયાઓ ઘણો જે
પ્રકારની ઉડાઉ બની શકે છે.

214
00:10:31,470 --> 00:10:37,530
તેથી હું આવે છે કે પ્રશ્ન ધારી
કે અમે જરૂર છે છે

215
00:10:37,530 --> 00:10:39,610
મલ્ટીપલ થ્રેડો અને પ્રક્રિયાઓ?

216
00:10:39,610 --> 00:10:41,890
અમે માત્ર એક હોય તો?

217
00:10:41,890 --> 00:10:45,710
>> તેથી આપણે પ્રકારની એક ચિત્રણ દો
આના જેવો દેખાશે શું.

218
00:10:45,710 --> 00:10:47,810
તેથી આપણે માત્ર એક થ્રેડ ઉપયોગ કરીએ.

219
00:10:47,810 --> 00:10:48,660
બરાબર?

220
00:10:48,660 --> 00:10:52,790
તેથી માત્ર એક થ્રેડ સાથે આ કલ્પના.

221
00:10:52,790 --> 00:10:56,600
>> કે અમે ખરેખર કરી ન હોય તો દો
તે ખૂબ ઉપયોગી છે - અને જ્યારે હું કહી

222
00:10:56,600 --> 00:10:59,450
ઉપયોગી, હું કોમ્પ્યુટેશનલ કામ અર્થ -

223
00:10:59,450 --> 00:11:01,130
પહેલાં તે ઘણા થ્રેડો છે.

224
00:11:01,130 --> 00:11:04,180
તેથી આપણે પ્રકારની એકત્રિત દો
એક થ્રેડ માં બધું.

225
00:11:04,180 --> 00:11:07,780
તેથી શું આપણે એક થ્રેડ તે પ્રકારના હોય તો
માત્ર લૂપ આસપાસ જાય છે અને

226
00:11:07,780 --> 00:11:10,880
સતત ચકાસણી કાર્ય કર્યું છે
નવી થાય છે.

227
00:11:10,880 --> 00:11:15,130
તેથી ઉદાહરણ તરીકે, કંઈક નવું થયું
હું કંઈક પાછું મળી અર્થ કરી શકે છે

228
00:11:15,130 --> 00:11:19,310
મોકલવામાં ડેટાબેઝ, અથવા કોઈકને
મને એક નવી HTTP વિનંતિ.

229
00:11:19,310 --> 00:11:22,290
તેથી તે ઘટનાઓ પ્રકારની છે
કે અધિકાર, થાય?

230
00:11:22,290 --> 00:11:26,130
>> અને પછી હું શું કરી શકો છો જ્યારે તે નવા
શું વસ્તુઓ આ જ થ્રેડમાં છે

231
00:11:26,130 --> 00:11:30,120
અમલ, આ એક થ્રેડ
અમલ, હું અમુક કોડ ફોન કરી શકો છો કે જે

232
00:11:30,120 --> 00:11:32,410
ચોક્કસ વસ્તુ નિયંત્રિત કરશે.

233
00:11:32,410 --> 00:11:36,640
તેથી ઉદાહરણ તરીકે, હું કંઈક મળી તો પાછા
ડેટાબેઝમાંથી, હું ચાલે છે મારા

234
00:11:36,640 --> 00:11:40,960
તે નાના કોમ્પ્યુટેશનલ ભાગ કે
ખરેખર માત્ર આ વસ્તુ તૈયાર

235
00:11:40,960 --> 00:11:42,620
વપરાશકર્તા પાછા મોકલો.

236
00:11:42,620 --> 00:11:46,710
તેથી અર્થમાં છે તે પ્રકારના છે?

237
00:11:46,710 --> 00:11:49,940
>> પરંતુ શું છે
આ અસરો?

238
00:11:49,940 --> 00:11:50,660
અધિકાર?

239
00:11:50,660 --> 00:11:53,730
અમે તેવા પરચૂરણ ખર્ચ કર્યો કારણ કે
કોડ કે ઘણો -

240
00:11:53,730 --> 00:11:58,330
અને હું માત્ર આગળ કૂદી જાઉં છું
તે બરાબર છે જો સ્લાઇડ્સ માં.

241
00:11:58,330 --> 00:12:00,930
તમને વાંધો ન હોય તો તેથી, હું છું માત્ર
એક પગલું લઈ રહ્યું.

242
00:12:00,930 --> 00:12:03,410
તેથી વસ્તુ આ પ્રકારની છે
એક ઘટના લૂપ કહેવાય છે.

243
00:12:03,410 --> 00:12:04,070
બરાબર?

244
00:12:04,070 --> 00:12:07,240
અને તે મૂળભૂત પ્રકારની છે
Node.js. પાછળ વિચાર

245
00:12:07,240 --> 00:12:11,240
>> Node.js ખરેખર વેબ તરીકે કરી છે તેથી શું
સર્વર એક થ્રેડ છે છે

246
00:12:11,240 --> 00:12:14,850
તે મૂળભૂત રીતે લૂપ આસપાસ રહ્યું છે
હેઠળ એક જ્યારે એક પ્રકારની જેમ

247
00:12:14,850 --> 00:12:18,510
સતત છે કે Node.js ના હૂડ
ચકાસણી, અમે નવા વસ્તુઓ પ્રાપ્ત કરી?

248
00:12:18,510 --> 00:12:22,720
અને પછી તેને હેન્ડલર્સ ચાલશે
તમે સુયોજિત છે.

249
00:12:22,720 --> 00:12:26,720
પરંતુ પૂછો સારો પ્રશ્ન છે,
આપણે કઈ રીતે આ શક્ય બની શકે છે

250
00:12:26,720 --> 00:12:28,090
હાલની વસ્તુઓ સાથે?

251
00:12:28,090 --> 00:12:32,440
>> તેથી હું અહીં સી કોડ એક વાક્ય મૂકો કે
તે ખોલીને મૂળભૂત જેમ દેખાય છે એક

252
00:12:32,440 --> 00:12:33,060
હક, ફાઈલ?

253
00:12:33,060 --> 00:12:36,090
હું તે માત્ર એક આલ્બમ સાથે બહાર આવી છે.

254
00:12:36,090 --> 00:12:39,600
તેથી હું તેના એક નવી ફાઇલ ખોલવા માટે હતી.

255
00:12:39,600 --> 00:12:43,810
તેથી જે રીતે સંચાલન માટે અમારા સી કોડ -

256
00:12:43,810 --> 00:12:47,890
અને હું હું ફાઈલો પસંદ કર્યું કારણ હતું ધારી
આ હદ પ્રકારની છે કારણ કે

257
00:12:47,890 --> 00:12:52,000
અમે સી માં કર્યું છે કે I / O કામ
ઇનપુટ આઉટપુટ છે તે એક અર્થમાં.

258
00:12:52,000 --> 00:12:55,070
તેથી અમે આ કોડ તરીકે ઓળખાવવામાં આવતી
આ એફ ઓપન કરે છે.

259
00:12:55,070 --> 00:12:59,370
અને પછી અમારી આગામી વાક્ય પર
કાર્યક્રમ, આપણે હવે એફ સાથે કામ કરી શકે.

260
00:12:59,370 --> 00:13:02,710
>> તેથી આ કંઈક એક ઉદાહરણ છે
કે સિંક્રનસ અથવા જેવું છે

261
00:13:02,710 --> 00:13:06,850
કે પહેલી લીટી પર, કારણ કે અવરોધિત
ત્યાં આપણે ત્યાં સુધી પ્રતીક્ષા કરી રહી છે

262
00:13:06,850 --> 00:13:08,110
ફાઇલ ખોલો વિશે.

263
00:13:08,110 --> 00:13:12,260
તેથી બીજા વાક્ય પર, અમે જાણીએ છીએ કે અમે
એફ સાથે કામ કરે છે, પરંતુ આ અર્થ એ કરી શકે છે

264
00:13:12,260 --> 00:13:16,240
કે બીજા વાક્ય ખરેખર ચાલી શકતું નથી
પ્રથમ વાક્ય કરવામાં આવે છે ત્યાં સુધી.

265
00:13:16,240 --> 00:13:17,760
કે અર્થમાં છે?

266
00:13:17,760 --> 00:13:20,890
>> તેથી આ મૂકવા માટે ખરાબ હશે
એક ઘટના સંભાળનાર છે.

267
00:13:20,890 --> 00:13:23,920
અને તે માટે કારણ છે
રાહ જુએ છે આ પ્રકારની, અધિકાર?

268
00:13:23,920 --> 00:13:26,500
તેથી આ અમને પાછા ફેરવી શકે છે
આ જ વાત છે.

269
00:13:26,500 --> 00:13:29,470
અને હવે અમે પણ ન હોય તે
ઘણા થ્રેડો ફાયદો કે

270
00:13:29,470 --> 00:13:32,390
પ્રક્રિયાઓ અમે મળી કારણ કે
Node.js. એક થ્રેડ

271
00:13:32,390 --> 00:13:35,496
કે દરેકને અર્થમાં છે?

272
00:13:35,496 --> 00:13:35,990
>> પ્રેક્ષક: રાહ જુઓ.

273
00:13:35,990 --> 00:13:36,980
તેથી સ્થાને છે?

274
00:13:36,980 --> 00:13:37,840
>> કેપી સ્ચમિડ: ઓહ, તેથી હા.

275
00:13:37,840 --> 00:13:39,560
તેથી હું વિચાર કરવા જઇ રહ્યો છું
ફેરબદલી.

276
00:13:39,560 --> 00:13:40,430
બરાબર.

277
00:13:40,430 --> 00:13:42,960
અમે કંઈક હતું તેથી શું જો
કે આ જેવો દેખાતો હતો?

278
00:13:42,960 --> 00:13:45,730
તેથી શું હું ફેરફાર હવે તો
F થોડી ખોલો?

279
00:13:45,730 --> 00:13:48,370
તેથી હું જ માં પસાર છું
પહેલાં બે દલીલો.

280
00:13:48,370 --> 00:13:52,610
હું હજુ પણ નવા ગીત પ્રેમ
તે સાથે બહાર આવી છે.

281
00:13:52,610 --> 00:13:57,260
પરંતુ હું ત્રીજા વસ્તુ પસાર છું જે
આ ચલ કોડ તરીકે ઓળખાય છે.

282
00:13:57,260 --> 00:14:02,280
>> પરંતુ કોડ શું ખરેખર છે
આ સંદર્ભમાં?

283
00:14:02,280 --> 00:14:05,360
તે નિયમિત સી ચલ જેવા છે?

284
00:14:05,360 --> 00:14:06,740
તે હક, એક કાર્ય છે?

285
00:14:06,740 --> 00:14:09,450
અને તે છે, કારણ કે થોડી વિચિત્ર હોઈ શકે છે
હું ખરેખર હવે પસાર જેવી છું એક

286
00:14:09,450 --> 00:14:12,320
અન્ય કાર્ય માં કામ કરે છે.

287
00:14:12,320 --> 00:14:14,400
>> આ અંગે નોંધ કરો તેથી બે વસ્તુઓ.

288
00:14:14,400 --> 00:14:17,145
એક, હું ખરેખર ફોન કરું છું
FIPS એ કાર્ય કરે છે.

289
00:14:17,145 --> 00:14:20,650
તેથી તમે સાથે કોડ દેખાય નહિં
ડાબો કૌંસ, જમણો કૌંસ.

290
00:14:20,650 --> 00:14:23,010
હું માત્ર કોડ માં પસાર છું.

291
00:14:23,010 --> 00:14:26,990
અને સી, આ ખરેખર શું કરશો
કે વાસ્તવિક મને એક નિર્દેશક આપે છે

292
00:14:26,990 --> 00:14:29,740
કોડ છે, અને પછી આ તે ચાલે છે.

293
00:14:29,740 --> 00:14:33,350
તમે પણ માત્ર તે વિશે વિચારો
ચલાવવા માટે કોડ પસાર જ્યારે

294
00:14:33,350 --> 00:14:35,150
તે ફાઇલ ખોલવામાં આવે છે.

295
00:14:35,150 --> 00:14:41,430
>> પરંતુ આ અર્થ એ છે કે હવે
કરી શકે છે, જે મારા કાર્યક્રમની બાકીના

296
00:14:41,430 --> 00:14:47,050
અન્ય સામગ્રી, અન્ય કરવાનું ચાલુ રાખી શકો છો
સામગ્રી અમે ખરેખર રાહ, પરંતુ જ્યારે

297
00:14:47,050 --> 00:14:50,890
અમારા હેડ પાછળ છે
જ્યારે તે ફાઈલ ઓપન, રન કે

298
00:14:50,890 --> 00:14:52,130
ટોચ પર કોડ.

299
00:14:52,130 --> 00:14:53,390
કે અર્થમાં છે?

300
00:14:53,390 --> 00:14:58,060
>> અને હવે Node.js પાછળનો છે
એફ સાથે શું સામગ્રી માં કોડ

301
00:14:58,060 --> 00:15:04,590
ભાગ ખૂબ ટૂંકા અને સરળ હોવી જોઈએ
ખરેખર હોઇ શકે છે અને સરળ અને નથી

302
00:15:04,590 --> 00:15:06,160
સઘન ખૂબ કોમ્પ્યુટેશનલ.

303
00:15:06,160 --> 00:15:09,390
તે બીજી ફાઇલ ખોલવા માટે હોય છે, પરંતુ શકે છે
તે પણ ખૂબ પાડવી જોઈએ

304
00:15:09,390 --> 00:15:14,710
તે માત્ર અન્ય એફ કરવા કહેવું જોઈએ, કારણ કે
ખોલો અને પછી આ બીજા કોડ ફોન કરો.

305
00:15:14,710 --> 00:15:19,100
>> તેથી માત્ર સંપૂર્ણપણે સ્પષ્ટ, એફ હોય
ખુલ્લા નવા પેરી Katy ગીત કરે છે

306
00:15:19,100 --> 00:15:23,060
થાય છે એમપી 3, કે ચાલી રહ્યું છે ખૂબ
ખૂબ તરત જ આવો.

307
00:15:23,060 --> 00:15:27,820
અને પછી અમે માત્ર કરી ચાલુ રાખી શકો છો
અન્ય સામગ્રી કે કારણ કે હવે એફ બધા

308
00:15:27,820 --> 00:15:33,410
ઓપન કોલ મૂળભૂત રીતે કહેવું છે નથી
અંતર્ગત એફ ઓપન કોડ આ ફાઈલની ખોલો

309
00:15:33,410 --> 00:15:36,020
અને તમે આ ખોલીને પૂર્ણ કરી ત્યારે
તમે તેને પાછી મેળવવા જ્યારે ફાઈલ અથવા,

310
00:15:36,020 --> 00:15:37,480
પછી તે કોડ ચલાવો.

311
00:15:37,480 --> 00:15:39,540
પરંતુ તે ખરેખર છે કે કોડ ચાલે છે.

312
00:15:39,540 --> 00:15:41,815
અને તમે એક પ્રશ્ન હતો?

313
00:15:41,815 --> 00:15:46,180
>> પ્રેક્ષક: તમે થોડા સૂચિત લાગતું હતું
ગણતરીની ઉમેરી રહ્યા છે કે વખત

314
00:15:46,180 --> 00:15:50,545
સઘન કોડ સૉર્ટ તોડી પાંચ
[અશ્રાવ્ય] આધારિત સિસ્ટમ.

315
00:15:50,545 --> 00:15:51,795
[અશ્રાવ્ય]?

316
00:15:51,795 --> 00:15:54,450

317
00:15:54,450 --> 00:15:55,290
>> કેપી સ્ચમિડ: કે જે મહાન પ્રશ્ન છે.

318
00:15:55,290 --> 00:15:59,280
તેથી હું ખરેખર કેવી રીતે એક ઉદાહરણ છે
તમે ગણતરીની સંકલિત કરી શકે છે

319
00:15:59,280 --> 00:16:01,090
થોડો માં સઘન કોડ.

320
00:16:01,090 --> 00:16:03,620
તેથી અમે કોડ ઉદાહરણો માટે વિચાર,
હું એક કે જે ખેંચવાનો ખાતરી કરી શકશો.

321
00:16:03,620 --> 00:16:04,700
તે બરાબર છે?

322
00:16:04,700 --> 00:16:05,950
આભાર.

323
00:16:05,950 --> 00:16:07,690

324
00:16:07,690 --> 00:16:08,750
>> તમારું નામ શું હતું?

325
00:16:08,750 --> 00:16:10,620
>> પ્રેક્ષક: આરોન.

326
00:16:10,620 --> 00:16:14,830
>> કેપી સ્ચમિડ: આરોન ખૂબ જ લઈ આવે છે
જે સારી બિંદુ, કે હું હતો તો

327
00:16:14,830 --> 00:16:18,560
કેટલાક કોમ્પ્યુટેશનલ સઘન કોડ
F ભાગ બાકીના સાથે આ દો સામગ્રી

328
00:16:18,560 --> 00:16:22,880
મારા કાર્યક્રમ ચાલી શકતું નથી અને સાંભળવા કરી શકો છો
બધા ત્યાં સુધી નવી અરજીઓ અથવા કંઈપણ માટે

329
00:16:22,880 --> 00:16:24,270
સામગ્રી સમાપ્ત થાય છે.

330
00:16:24,270 --> 00:16:27,390
તેથી હું સામાન્ય રીતે નોડ કોડ લખી રહ્યો છું જો
હું જાઉં છું જેમ અમે કંઈક જ્યાં સુધી

331
00:16:27,390 --> 00:16:33,060
અમે જુઓ ત્યારે સૂચવે છે
કોડ ઉદાહરણો, મને ખાતરી છે કે હોય છે

332
00:16:33,060 --> 00:16:36,060
મારા સુધી કોડ ગૂંચ નથી
આ ઘટના લૂપ.

333
00:16:36,060 --> 00:16:38,120
કે અર્થમાં છે?

334
00:16:38,120 --> 00:16:38,350
બરાબર.

335
00:16:38,350 --> 00:16:40,040
કૂલ.

336
00:16:40,040 --> 00:16:47,090
>> તેથી Node.js આ માળખું આપે છે
તમે નહીં આ ઘટના બનાવી શકો છો

337
00:16:47,090 --> 00:16:48,210
સાથે સર્વરો.

338
00:16:48,210 --> 00:16:53,460
તેથી તે અસમકાલીક આ પ્રકારની છે
જ્યારે, I / O નો લાઈબ્રેરીઓ બિન અવરોધિત

339
00:16:53,460 --> 00:16:56,800
અમે કરી છે કે મૂળભૂત C લાઈબ્રેરીઓ
, સાથે કામ પસંદ હોય તો તમે માત્ર

340
00:16:56,800 --> 00:16:59,500
અમે કરેલો જ રીતે તેમને વાપરવા માટે
એફ સાથે ઉપયોગ કરી રહ્યો ખોલે છે અને

341
00:16:59,500 --> 00:17:03,000
સામગ્રી, તે અવરોધિત છે કારણ કે
તમે ખરેખર માટે રાહ જોવી પડે છે

342
00:17:03,000 --> 00:17:04,470
ખોલવા માટે તે ફાઇલ.

343
00:17:04,470 --> 00:17:09,290
>> પરંતુ Node.js તે છે કે જે તમને આપે છે અને
મૂળભૂત રીતે Google ની વી 8 માં જોડાણ

344
00:17:09,290 --> 00:17:14,030
કારણ એ છે કે જે જાવાસ્ક્રિપ્ટ એન્જિન
ક્રોમ પ્રક્રિયા પર જેથી ઝડપી છે કે

345
00:17:14,030 --> 00:17:17,040
જાવાસ્ક્રિપ્ટ કારણ કે
આ વી 8 એન્જિન છે.

346
00:17:17,040 --> 00:17:22,460
તેથી મને લાગે છે કે તે એક જેવી લાગે છે
WWDC વિકાસકર્તા પરિષદો વસ્તુ

347
00:17:22,460 --> 00:17:25,390
તેઓ માત્ર એક ટોળું ફેંકવું જ્યાં
પ્રોસેસરો માટે પત્ર નંબર વસ્તુઓ

348
00:17:25,390 --> 00:17:26,910
અને આ તેથી સરસ છે છે.

349
00:17:26,910 --> 00:17:34,200
પરંતુ તે તેઓ કે સરસ છે
આ કારણ જાવાસ્ક્રિપ્ટ -

350
00:17:34,200 --> 00:17:37,010
અથવા કદાચ તમે પરિચિત ન હો તો
જાવાસ્ક્રિપ્ટ છતાં આપણે થયું નથી કારણ કે

351
00:17:37,010 --> 00:17:38,180
તેની પર વ્યાખ્યાન -

352
00:17:38,180 --> 00:17:40,770
પરંતુ જાવાસ્ક્રિપ્ટ એક અર્થઘટન છે
ઓનલાઇન.

353
00:17:40,770 --> 00:17:41,970
>> અને આ પણ એક મહત્વનો મુદ્દો છે.

354
00:17:41,970 --> 00:17:45,790
તેથી તે અમારી વેબ માટે મહત્વપૂર્ણ છે
સર્વર્સ જમણે ઝડપી થવું?

355
00:17:45,790 --> 00:17:49,970
અને અમે માત્ર જાવાસ્ક્રિપ્ટ ચાલી હતી જો
સાથે અર્થઘટન કરવામાં આવ્યું હતું કે માત્ર કોડ

356
00:17:49,970 --> 00:17:52,130
કોઇ જૂના દુભાષિયો તે ધીમું હોઈ શકે છે.

357
00:17:52,130 --> 00:17:55,980
આ ધરાવતી તેથી નોડ લાભો
સુપર ફાસ્ટ વી 8 દુભાષિયો.

358
00:17:55,980 --> 00:17:59,580
તેઓ તેને નામ આપવામાં આવ્યું અને જો મને ખબર નથી
કારણ કે કપાળ માં વી 8 slap

359
00:17:59,580 --> 00:18:01,110
વસ્તુ છે, પરંતુ બરાબર.

360
00:18:01,110 --> 00:18:07,070
>> તેથી હું કેટલાક ઉદાહરણો છે
આ URL પર.

361
00:18:07,070 --> 00:18:10,490
આ પરિસંવાદ પછી, હું પ્રકારના જાઉં છું
તમે નોડ સેટ મળી શકે છે તે વિશે વાત

362
00:18:10,490 --> 00:18:13,570
છે, પણ હવે, હું હમણાં જ પ્રકારની માંગો છો
અમુક કોડ ઉદાહરણો લઈ જવામાં.

363
00:18:13,570 --> 00:18:17,250
તેથી તમે અનુસરવા માંગો છો, બધી
સોર્સ કોડ ઉપલબ્ધ છે.

364
00:18:17,250 --> 00:18:18,720
બરાબર?

365
00:18:18,720 --> 00:18:22,280
>> તેથી હું આ URL છોડી જાય છે
થોડો માટે.

366
00:18:22,280 --> 00:18:24,440
અને પછી હું માત્ર જાઉં છું
ટર્મિનલ માં કરો.

367
00:18:24,440 --> 00:18:29,670

368
00:18:29,670 --> 00:18:34,400
બધાને આ URL સાથે સારી છે?

369
00:18:34,400 --> 00:18:37,990
તેથી હું પર સ્વિચ કરવા માટે જઈ રહ્યો છું
અહીં મારા ટર્મિનલ પર.

370
00:18:37,990 --> 00:18:42,030
>> તેથી અહીં કોડ કે
હું આજે માટે છે.

371
00:18:42,030 --> 00:18:43,960
શા માટે અમે સાથે શરૂ થતું
simpler.js નોંધાવી?

372
00:18:43,960 --> 00:18:49,110

373
00:18:49,110 --> 00:18:52,100
અન્ય બાબત એ છે કે આ તમામ
કોડ લખી શકાય રહ્યું છે

374
00:18:52,100 --> 00:18:56,660
જાવાસ્ક્રિપ્ટ જે તમે કરી શકો છો અથવા
સાથે પરિચિત ન પણ હોય.

375
00:18:56,660 --> 00:19:00,170
હું થોડા વસ્તુઓ છે ધારી કે ઘણો
જાવાસ્ક્રિપ્ટ કોડ શાળા સ્થાન પ્રકારની છે

376
00:19:00,170 --> 00:19:04,000
સિન્ટેક્સ અને માળખું ખૂબ સમાન છે
સી, તરીકે તમે પ્રકારની તેને પસંદ કરી શકો છો જેથી

377
00:19:04,000 --> 00:19:05,020
તમે સાથે જાઓ.

378
00:19:05,020 --> 00:19:08,750
હું ઘણો લખી કરવાનો પ્રયત્ન કર્યો છે
છે તે રીતે આ માટે શરૂ કોડ

379
00:19:08,750 --> 00:19:11,230
તે છે કે જેથી સે સમાન
થોડી વધુ વાંચી શકાય.

380
00:19:11,230 --> 00:19:15,980
પરંતુ અમે પ્રગતિ તરીકે, હું હશો
વધારાના કેટલાક દર્શાવીને

381
00:19:15,980 --> 00:19:18,980
જાવાસ્ક્રિપ્ટ ના લક્ષણો કે
પ્રકારની ઠંડી રહે છે.

382
00:19:18,980 --> 00:19:21,510
>> પરંતુ આ નમૂના કાર્યક્રમ જુઓ.

383
00:19:21,510 --> 00:19:24,820
હું બધું ત્યાં કાપી છે ધારી.

384
00:19:24,820 --> 00:19:28,500
હું માત્ર કે વાસ્તવિક સુધારવા માટે જાઉં છું
તે બરાબર છે કે નહીં ઝડપી છે.

385
00:19:28,500 --> 00:19:31,400
હું આ કરી રહ્યું છે તે ખબર નથી.

386
00:19:31,400 --> 00:19:34,660
થોડો સારો છે?

387
00:19:34,660 --> 00:19:36,510
તમે var અને સામગ્રી જોઈ શકો છો?

388
00:19:36,510 --> 00:19:39,320
બરાબર.

389
00:19:39,320 --> 00:19:44,120
>> તેથી પ્રથમ વાક્ય જાવાસ્ક્રિપ્ટ જેવી છે
ચલ આવૃત્તિ

390
00:19:44,120 --> 00:19:44,800
જાહેરાત.

391
00:19:44,800 --> 00:19:49,870
તેથી માત્ર આ રીતે પ્રકાશિત કરવા માટે
તેથી આ માત્ર જેવું છે સી માં જેમ દેખાય છે

392
00:19:49,870 --> 00:19:52,620
મને કહે ઈન્ડેક્સ ત્રણ જેટલી જ થાય છે
અથવા તે કંઈક.

393
00:19:52,620 --> 00:19:55,740
તેથી હું પ્રકાર સ્પષ્ટ કરેલ નથી.

394
00:19:55,740 --> 00:20:00,780
જાવાસ્ક્રિપ્ટ પ્રકારના હોય છે, પરંતુ તે છે
ખૂબ ગતિશીલ પ્રકૃતિ લખ્યો છે, તેથી

395
00:20:00,780 --> 00:20:02,580
તેના પર પ્રકારની કોઇ પણ પ્રકારના આપ્યા ન હતા.

396
00:20:02,580 --> 00:20:03,670
તેથી તે માત્ર વાર છે.

397
00:20:03,670 --> 00:20:05,320
ચલ છે કે જે જેવું છે.

398
00:20:05,320 --> 00:20:05,920
બરાબર?

399
00:20:05,920 --> 00:20:08,340
>> અને હું આ ચલ HTTP ફોન છું.

400
00:20:08,340 --> 00:20:12,480
અને મારા જમણા હાથમાં બાજુ પર, હું છે
હું HTTP માં મૂકેલ કે અભિવ્યક્તિ.

401
00:20:12,480 --> 00:20:14,960
અને આ HTTP જરૂર કહે છે.

402
00:20:14,960 --> 00:20:18,500
તેથી આ પ્રકારની જ સમાવેશ થાય છે.

403
00:20:18,500 --> 00:20:22,940
તે થોડું વધુ જેવા શક્તિશાળી કરતાં
સમાવેશ થાય છે કે જે અર્થમાં સમાવેશ થાય છે

404
00:20:22,940 --> 00:20:26,100
માત્ર કૉપિ કરો અને પેસ્ટ કરો હેડર કરશે
કાર્ય પ્રોટોટાઇપ માટે ફાઇલ અથવા

405
00:20:26,100 --> 00:20:27,930
પ્રકાર વ્યાખ્યાઓ સાથે ગમે.

406
00:20:27,930 --> 00:20:30,590
પરંતુ જરૂર ખરેખર રહ્યું છે
ચાલો કોડ મળે છે.

407
00:20:30,590 --> 00:20:33,280
>> તેથી તમે તે વિચાર કરી શકો છો
અમુક કોડ આયાત.

408
00:20:33,280 --> 00:20:37,960
તેથી ક્યાંક Node.js મોડ્યુલ માં
સિસ્ટમ અથવા જે, તેઓ આ બધા છે

409
00:20:37,960 --> 00:20:40,790
HTTP સર્વર કોડ તેથી હું માત્ર છું
મારી પોતાની માટે લાવતી

410
00:20:40,790 --> 00:20:43,130
આ કાર્યક્રમ વ્યક્તિગત ઉપયોગ.

411
00:20:43,130 --> 00:20:44,260
બરાબર?

412
00:20:44,260 --> 00:20:46,930
>> તેથી તો હું આ કાર્ય હોય છે
હું તેવા પરચૂરણ ખર્ચ કર્યો છે.

413
00:20:46,930 --> 00:20:50,330
અને હું સ્પષ્ટ કરવા માટે ન હતી નોટિસ
પરત પ્રકાર અથવા પ્રકાર

414
00:20:50,330 --> 00:20:51,140
દલીલો ફરી.

415
00:20:51,140 --> 00:20:54,440
તેથી પ્રકારની છૂટક લખ્યો
અર્થમાં તે પ્રકારના.

416
00:20:54,440 --> 00:20:57,290
તે લે છે કે બે દલીલો,
વિનંતી અને પ્રતિભાવ.

417
00:20:57,290 --> 00:21:02,080
જેથી ખ્યાલ પ્રમાણે આ એવો કિસ્સો છે
અમે હતી કે ચિત્ર થી પરિચિત

418
00:21:02,080 --> 00:21:05,280
સ્ક્રીન પર કારણ કે પહેલાં
અમે આ વિનંતી મળી છે કે જે અમે

419
00:21:05,280 --> 00:21:06,410
વપરાશકર્તા તરફથી છે.

420
00:21:06,410 --> 00:21:09,170
અને પછી અમે પ્રતિભાવ હોય છે
અમે વસ્તુઓ લખી શકો છો.

421
00:21:09,170 --> 00:21:15,060
>> તેથી આ પ્રથમ વાક્ય છે
200 res.writeHead અને પછી આ

422
00:21:15,060 --> 00:21:17,070
સામગ્રી પ્રકાર લખાણ સાદા.

423
00:21:17,070 --> 00:21:19,300
તેથી આપણે થોડી આ સિવાય ભાગ છે.

424
00:21:19,300 --> 00:21:22,340
તેથી આપણે માત્ર res.write પર ધ્યાન કેન્દ્રિત દો
થોડો માટે.

425
00:21:22,340 --> 00:21:28,420
તેથી લખવા, મૂળભૂત રીતે છે, અને હેડ લખો
સૉર્ટ બહાર લખવા માટે માત્ર માર્ગો છે

426
00:21:28,420 --> 00:21:29,960
આ પ્રતિભાવ વસ્તુઓ.

427
00:21:29,960 --> 00:21:30,770
બરાબર?

428
00:21:30,770 --> 00:21:36,230
કોઈની યાદ તેથી જો, હેડ લખો
જે HTTP વ્યાખ્યાન, તમે ગાય્ઝ કરવું

429
00:21:36,230 --> 00:21:39,940
આ પર હેડરો યાદ
જે HTTP વસ્તુ ઉપર?

430
00:21:39,940 --> 00:21:43,580
તેથી શા માટે હું માત્ર ડેમો નથી
વાસ્તવિક ઝડપી હેડરો.

431
00:21:43,580 --> 00:21:44,640
કે મદદરૂપ થશે?

432
00:21:44,640 --> 00:21:45,500
અથવા જોઈએ અમે માત્ર સૉર્ટ -

433
00:21:45,500 --> 00:21:46,070
બરાબર.

434
00:21:46,070 --> 00:21:46,740
ખાતરી કરો કે.

435
00:21:46,740 --> 00:21:52,340
>> તેથી તમારા બ્રાઉઝર google.com પર જાય છે
અથવા તે કંઈક,

436
00:21:52,340 --> 00:21:54,250
ખરેખર થોડી વધુ છે -

437
00:21:54,250 --> 00:21:55,380
આ ગુપ્ત જેવું છે -

438
00:21:55,380 --> 00:21:58,340
થોડી વધુ માહિતી જોઈતી છે
કે જે હમણાં જ કરતાં પાઇપ મારફતે આવે છે

439
00:21:58,340 --> 00:22:00,180
ધ લીટલ શોધ અને બધું.

440
00:22:00,180 --> 00:22:03,550
તેથી જો તમે આ બતાવવા માટે, હું જાઉં છું
કર્લ કહેવાય કાર્યક્રમ વાપરવા માટે.

441
00:22:03,550 --> 00:22:04,260
બરાબર?

442
00:22:04,260 --> 00:22:08,020
તેથી આ તમે ચલાવી શકો છો કે જે કંઈક છે
તમારા મેક OSX આદેશ વાક્ય અથવા માં

443
00:22:08,020 --> 00:22:09,830
સાધન અથવા જે.

444
00:22:09,830 --> 00:22:17,050
અને તેથી હું કર્લ તો HTTP google.com,
હું એચટીએમએલ જોવા જાઉં છું.

445
00:22:17,050 --> 00:22:21,230
અને આ, ઔચિત્યની, છે માત્ર
જેવું તમને કહે છે કે એચટીએમએલ

446
00:22:21,230 --> 00:22:24,695
તમારા બ્રાઉઝર નહી હોય તો www રીડાયરેક્ટ
આપોઆપ નિયંત્રિત પાંચ

447
00:22:24,695 --> 00:22:27,110
પુનર્નિર્દેશન.

448
00:22:27,110 --> 00:22:33,390
>> તેથી આ માત્ર HTML છે, પણ હું જાઉં છું
હું ફ્લેગ આ હાયફન કર્લ ઉમેરો.

449
00:22:33,390 --> 00:22:33,600
બરાબર?

450
00:22:33,600 --> 00:22:35,600
અને આ શો ચાલે છે
મને હેડરો.

451
00:22:35,600 --> 00:22:40,640
તેથી આ પણ આવે છે તે માહિતી છે
દ્વારા હું આ પ્રતિક્રિયા મળી છે.

452
00:22:40,640 --> 00:22:41,260
બરાબર?

453
00:22:41,260 --> 00:22:45,320
>> તેથી ટોચ પર, તો તમે આ જુઓ
HTTP 301 કાયમી ખસેડો.

454
00:22:45,320 --> 00:22:49,470
અને આ પ્રકારની મહત્વપૂર્ણ છે, કારણ કે
આ પરિસ્થિતિ કોડ માટે વપરાય છે.

455
00:22:49,470 --> 00:22:53,750
તેથી અહીં 301, સ્થિતિ કોડ છે
મૂળભૂત રીતે માત્ર એક પૂર્ણાંક છે કે જે

456
00:22:53,750 --> 00:22:57,750
કે બ્રાઉઝર અથવા વિષયક છે કહે છે
તમે ડોળ કરવો કે, આ વાંચન

457
00:22:57,750 --> 00:23:01,460
તમે બ્રાઉઝર છો અને તમે જોઈ રહ્યાં છો,
મૂળભૂત રીતે હવે તમે જુઓ તો

458
00:23:01,460 --> 00:23:04,960
કે અને તમે 301 જુઓ, તમે મને હોય છે
પર આધારિત ખાસ કંઈક કરવું

459
00:23:04,960 --> 00:23:08,810
301, અથવા કંઈક ખાસ થયું
આ 301 પર આધારિત છે.

460
00:23:08,810 --> 00:23:12,640
તેથી તે કાયમ માટે ખસેડવામાં કહે છે.

461
00:23:12,640 --> 00:23:17,700
>> અને પછી, મૂળભૂત રીતે, અમે
કી કિંમત જોડીઓને સમૂહ.

462
00:23:17,700 --> 00:23:22,100
તેથી અમે પાંચ વિષે
www.google.com છે.

463
00:23:22,100 --> 00:23:25,190
અને પછી એવા બધા પ્રકારની આ અન્ય સામગ્રી,
પરંતુ મૂળભૂત રીતે, શું સ્થાન છે

464
00:23:25,190 --> 00:23:29,662
કહેવત નવી સ્થાન છે
www.google.com પર છે.

465
00:23:29,662 --> 00:23:33,800
તમે google.com પર જાઓ તેથી હવે, તો તમે
પ્રકારના આંખ મારવી ના બ્રાઉઝર પ્રકારની જુઓ

466
00:23:33,800 --> 00:23:38,770
તમે પુનઃદિશામાન પછી બીજા અને માટે
અધિકાર પાછા www.google.com છે.

467
00:23:38,770 --> 00:23:41,840
તેથી જવાબો હોય છે
આ હેડરો.

468
00:23:41,840 --> 00:23:43,330
>> અને વસ્તુઓ એક દંપતિ નિર્દેશ કરે છે.

469
00:23:43,330 --> 00:23:46,890
તેથી આપણે ખરેખર સફળ હતા કહેવું
વેબ પૃષ્ઠની મુલાકાત છે.

470
00:23:46,890 --> 00:23:49,040
તેથી મને જવા દો -

471
00:23:49,040 --> 00:23:51,080
એક સારી વેબસાઈટ શું છે?

472
00:23:51,080 --> 00:23:53,285
હું સારી વિચારસરણી પર ખરાબ છું
સ્થળ પર વેબસાઇટ્સ.

473
00:23:53,285 --> 00:23:53,640
>> પ્રેક્ષક: વિકિપીડિયા.

474
00:23:53,640 --> 00:23:54,160
>> કેપી સ્ચમિડ: બરાબર.

475
00:23:54,160 --> 00:23:56,040
માતાનો વિકિપીડિયા દો.

476
00:23:56,040 --> 00:23:58,680
તેથી અહીં હું ખસેડવામાં આવી હતી.

477
00:23:58,680 --> 00:23:59,240
ઓહ રાહ જુઓ.

478
00:23:59,240 --> 00:24:00,160
હું હતી?

479
00:24:00,160 --> 00:24:00,890
હા, હું હતી.

480
00:24:00,890 --> 00:24:01,100
બરાબર.

481
00:24:01,100 --> 00:24:03,005
તેથી હું www કરવા માટે મળી.

482
00:24:03,005 --> 00:24:06,006
તેથી હું www કરવા જાઉં છું.

483
00:24:06,006 --> 00:24:09,680
તમે જોઈ શકો છો અને, અહીં તમામ એચટીએમએલ છે
બ્રાઉઝર પ્રક્રિયા છે કે જે

484
00:24:09,680 --> 00:24:10,910
વિકિપીડિયા માટે.

485
00:24:10,910 --> 00:24:14,055
>> પરંતુ હું અહીં સરકાવનાર રાખો,
હું ટોચ પર જોશો શું -

486
00:24:14,055 --> 00:24:17,800
વાહ, ઘણો છે
વિકિપીડિયા પર એચટીએમએલ -

487
00:24:17,800 --> 00:24:22,550
પરંતુ હું અહીં ટોચ પર જોઈ શકો છો છે
એ તરીકે વિરોધ આ 200 પરિસ્થિતિ કોડ

488
00:24:22,550 --> 00:24:24,570
હું અગાઉ જોયું કે 301.

489
00:24:24,570 --> 00:24:27,100
અને તે એક સરસ છે નોંધ્યું છે કે
આગામી તે માટે અનુકૂળ બરાબર.

490
00:24:27,100 --> 00:24:29,470
તેથી આ સારા પરિસ્થિતિ કોડ જેવું છે.

491
00:24:29,470 --> 00:24:31,160
>> કે 200 નંબર પરિચિત નથી લાગતું?

492
00:24:31,160 --> 00:24:34,120

493
00:24:34,120 --> 00:24:39,880
હા, કારણ કે હું simpler.js હતી, જ્યારે
હું ત્યાં એક 200 લખ્યું હતું.

494
00:24:39,880 --> 00:24:43,290
જેથી મૂળભૂત રીતે કહી કહે છે
બ્રાઉઝર અથવા વિષયક મેળવવા પ્રયાસ કરી રહી છે

495
00:24:43,290 --> 00:24:45,440
તેઓ સફળ રહ્યા હતા કે આ.

496
00:24:45,440 --> 00:24:49,040
અથવા જેમ અમે તે પ્રકારના
પણ સફળ રહી હતી.

497
00:24:49,040 --> 00:24:54,320
>> અને ખાસ વાક્યરચના આ પ્રકારની છે
જાવા એક જાહેર માટે

498
00:24:54,320 --> 00:24:59,870
સામગ્રી પ્રકાર જેમ આ કીઓ નકશો
અને લખાણ સાદા જેમ આ કિંમતો.

499
00:24:59,870 --> 00:25:03,780
તેથી તમે પ્રતિભાવ જોવા કે અમે
પહેલાં પાછા વિકિપીડિયા તરફથી મળી -

500
00:25:03,780 --> 00:25:06,200
હું સ્ક્રોલ પ્રયાસ જાઉં છું
થોડી ઝડપી અપ -

501
00:25:06,200 --> 00:25:09,900
તમે સર્વર જેમ આ કીઓ છે
અને આ કિંમતો અપાચે.

502
00:25:09,900 --> 00:25:12,120
તેથી તમે કીઓ અને કિંમતો મળી છે.

503
00:25:12,120 --> 00:25:15,930
અને જો તમે આ સ્પષ્ટ કરી શકો છો
પાછા મોકલવા શું નોડ.

504
00:25:15,930 --> 00:25:19,380
>> તેથી આ કેટલાક ખરેખર પ્રકારની છે
માર્ગો, અને કેટલીક રીતે તે નથી

505
00:25:19,380 --> 00:25:23,170
ખરેખર, પરંતુ તે થોડો નીચા સ્તરે છે
તમે હોઇ શકે છે કે PHP કોડ કરતાં

506
00:25:23,170 --> 00:25:26,980
પી માટે લેખિત સાત સેટ કારણ કે PHP અને
અપાચે સૉર્ટ અમુક કાળજી લેવા

507
00:25:26,980 --> 00:25:28,150
તમારા માટે આ બધી વસ્તુઓ.

508
00:25:28,150 --> 00:25:32,520
PHP માં જેમાં તમે મૂળભૂત પર ફરીથી લખી શકો છો
તમારા પોતાના હેડરો લખીને વર્તન.

509
00:25:32,520 --> 00:25:35,520
પરંતુ આ હેતુ માટે, અમે વિચાર
અમારી પોતાની હેડરો લખો.

510
00:25:35,520 --> 00:25:38,210

511
00:25:38,210 --> 00:25:41,105
>> તેથી તે લીટી માટે વ્યવહારું છે
બધાને, લખો વડા લાઇન?

512
00:25:41,105 --> 00:25:41,380
બરાબર.

513
00:25:41,380 --> 00:25:42,280
ઓસમ.

514
00:25:42,280 --> 00:25:45,870
>> તેથી તો હું શું મારે માટે જવાબ અંત છે
વિશ્વ હેલો કહેતા.

515
00:25:45,870 --> 00:25:47,040
બરાબર.

516
00:25:47,040 --> 00:25:49,920
પરંતુ તે માત્ર એક કાર્ય છે
વિનંતી સંભાળનાર છે.

517
00:25:49,920 --> 00:25:53,510
તેથી હવે હું ખરેખર પ્રકારની શું કરવું છે
આ કાર્ય સાથે કંઈક, અધિકાર?

518
00:25:53,510 --> 00:25:59,170
>> તેથી અહીં હું શું આનો મતલબ એ કે છે
var સર્વર સમકક્ષ કરે જે વાક્ય

519
00:25:59,170 --> 00:26:03,530
HTTP.create સર્વર, અને પછી હું
વિનંતી સંભાળનાર માં પસાર કરે છે.

520
00:26:03,530 --> 00:26:06,080
તેથી આ નોડ પ્રકારની છે
સર્વર બનાવવાની રીત.

521
00:26:06,080 --> 00:26:08,790
અને હું પસાર છું નોટિસ
વિનંતી સંભાળનાર છે.

522
00:26:08,790 --> 00:26:12,290
તેથી આ createServer કહેવાની છે
હું તમને મને બનાવવા માંગો છો તે કાર્ય

523
00:26:12,290 --> 00:26:16,270
સર્વર, અને જ્યારે તે સર્વર મેળવે
પ્રતિભાવ, હું તમને આ કૉલ કરવાની જરૂર

524
00:26:16,270 --> 00:26:18,680
સંભાળનાર કાર્ય કરવા વિનંતી છે.

525
00:26:18,680 --> 00:26:18,990
બરાબર?

526
00:26:18,990 --> 00:26:22,290
>> તેથી તે લીટી ખૂબ ખૂબ
સીધા સમાપ્ત.

527
00:26:22,290 --> 00:26:28,780
તેથી વાર સર્વર લાઇન અધિકાર થાય છે
તમે ખૂબ ખૂબ તે કરવા છે.

528
00:26:28,780 --> 00:26:31,770
હું તેનો અર્થ, તે કેટલીક આંતરિક સુયોજિત કરવા માટે છે
તમારે એ જાણવું રાજ્ય

529
00:26:31,770 --> 00:26:35,400
કે વિનંતી સંભાળનાર કાર્ય કહી, પરંતુ
તે ત્યાં બેસી રહ્યું છે અને નથી

530
00:26:35,400 --> 00:26:37,730
કહે છે મોકલવામાં વપરાશકર્તા છે
મને હજુ સુધી એક વિનંતી?

531
00:26:37,730 --> 00:26:39,270
વપરાશકર્તા હજુ સુધી મને એક વિનંતિ મોકલી છે?

532
00:26:39,270 --> 00:26:40,780
તેથી તે અવરોધિત નથી.

533
00:26:40,780 --> 00:26:41,650
બરાબર?

534
00:26:41,650 --> 00:26:46,120
>> તેથી શું આ થશે તે વાસ્તવમાં છે
હવે આ કોડ માટે નિર્દેશક સંગ્રહ કરે છે,

535
00:26:46,120 --> 00:26:49,670
પછી આ વિનંતી સંભાળનાર કાર્ય, અને
તે કોડ ચાલશે જ્યારે કોઈકને

536
00:26:49,670 --> 00:26:52,170
વિનંતી છે.

537
00:26:52,170 --> 00:26:54,120
અને પછી અમે server.listen નથી.

538
00:26:54,120 --> 00:26:56,950

539
00:26:56,950 --> 00:26:59,960
>> આ 1337 ખૂબ મનસ્વી છે.

540
00:26:59,960 --> 00:27:02,285
હું કોઈ ચોક્કસ કારણ હતું
કે જે નંબર ચૂંટવું માટે.

541
00:27:02,285 --> 00:27:03,860
તે તદ્દન રેન્ડમ હતી.

542
00:27:03,860 --> 00:27:07,010
પરંતુ તે માત્ર પોર્ટ સ્પષ્ટ કરે છે.

543
00:27:07,010 --> 00:27:10,640
તેથી મોટા ભાગનાં વેબ સર્વરો તમે જોશો કે તેઓ
તે પ્રકારના છે, કારણ કે પોર્ટ 80 ઉપયોગ

544
00:27:10,640 --> 00:27:11,810
ના સંમેલનમાં છે.

545
00:27:11,810 --> 00:27:16,170
તેથી હું કંઈક પર જાઓ,
મને ખબર નથી, Wikipedia.org,

546
00:27:16,170 --> 00:27:17,700
અને હું કોલોન 8 મૂકે છે -

547
00:27:17,700 --> 00:27:18,610
વાહ ઓહ, તમે તે જોઈ શકે છે.

548
00:27:18,610 --> 00:27:19,370
હું દિલગીર છું.

549
00:27:19,370 --> 00:27:21,820
પરંતુ હું વિકિપીડિયા કરો તો -

550
00:27:21,820 --> 00:27:24,810
હું તેને અહીં લખીશ એ જ છે કે
તે કેમેરા પર સ્પષ્ટ છે.

551
00:27:24,810 --> 00:27:29,150
પરંતુ હું સાથે બ્રાઉઝરમાં આ કરો નહિં તો
સ્પષ્ટ કરે છે કે જે કોલોન 80, પર જાઓ

552
00:27:29,150 --> 00:27:31,430
Wikipedia.org પોર્ટ 80 ખાતે.

553
00:27:31,430 --> 00:27:36,200
તેથી તે અમેરિકામાં છે કેવી રીતે જેવું છે
તમે મોકલી શકો છો કે જ્યાં જેવા ઘણાબધા પોર્ટ

554
00:27:36,200 --> 00:27:37,440
પ્રકારની વસ્તુઓ.

555
00:27:37,440 --> 00:27:40,730
તેથી તે આ ચોક્કસ પર જાઓ જેવું છે
આ સર્વર પર મૂકો.

556
00:27:40,730 --> 00:27:40,990
બરાબર.

557
00:27:40,990 --> 00:27:45,730
>> તેથી હું ફક્ત 1337 પસંદ કર્યું હતું.

558
00:27:45,730 --> 00:27:47,910
નંબરો સંપૂર્ણ શ્રેણી છે
તમે પસંદ કરી શકો છો કે.

559
00:27:47,910 --> 00:27:50,390
તે તદ્દન ખાસ ન હતી.

560
00:27:50,390 --> 00:27:54,560
>> પરંતુ હવે હું કરવા જાઉં છું
હું નોડ સ્કોર જાઉં છું છે.

561
00:27:54,560 --> 00:27:59,730
મને ખરેખર દાખલ કરો કે જે દંપતિ
તમે તેને જોઈ શકે છે કે જેથી નીચે રેખાઓ.

562
00:27:59,730 --> 00:28:03,130
હું નોડ કરવા જાઉં છું, અને હું છું
simpler.js સ્કોર જાઉં.

563
00:28:03,130 --> 00:28:06,880
અને અમે કેવી રીતે વિશે વાત કરીશું
નોડ થોડો માં સ્થાપના કરી હતી.

564
00:28:06,880 --> 00:28:09,350
પરંતુ હવે તે માત્ર સર્વર ચાલી રહ્યો છે.

565
00:28:09,350 --> 00:28:14,360
>> તેથી એક વસ્તુ અમે પ્રયત્ન કરી શકો છો કે જે નથી કરી શકે છે
ઉત્તેજક અમે ખરેખર આ કરી શકો છો કે કરી

566
00:28:14,360 --> 00:28:16,300
કર્લ માં ઍક્સેસ કરવાનો પ્રયાસ કરો.

567
00:28:16,300 --> 00:28:20,680
તેથી હું કર્લ કરે છે, અને મારા
મશીન સ્થાનિક યજમાન છે.

568
00:28:20,680 --> 00:28:24,600
તમે પણ આ લેખિત જોશો
ક્યારેક આ જેવા હોય છે.

569
00:28:24,600 --> 00:28:29,810
સ્થાનિક યજમાન અને 127.0.0.1 પ્રકારની છે
તમારા ઘરમાં કમ્પ્યુટર ગમે છે.

570
00:28:29,810 --> 00:28:33,180
તેથી તે માટે વાત જેવું છે
તમારા પોતાના કમ્પ્યુટર.

571
00:28:33,180 --> 00:28:33,760
બરાબર.

572
00:28:33,760 --> 00:28:36,030
>> અને પછી હું 1337 કહી શકો છો.

573
00:28:36,030 --> 00:28:39,630
તેથી હું કોડ આ વાક્ય ચલાવવા માટે,
વર્લ્ડ હેલો કહે છે.

574
00:28:39,630 --> 00:28:44,050
અને હું સામગ્રી જોવા ઇચ્છતા જો કે
હતી સામગ્રી પ્રકાર લખાણ સાદા અથવા

575
00:28:44,050 --> 00:28:46,560
ગમે, હું પણ આ અહીં મૂકી શકે છે.

576
00:28:46,560 --> 00:28:48,810
અને તે બરાબર કહે છે કે નોટિસ.

577
00:28:48,810 --> 00:28:50,810
અને હું લખાણ સાદા ધરાવે છે.

578
00:28:50,810 --> 00:28:53,140
અને પછી આ બીજા એવા બધા પ્રકારની છે
નોડ માં ઉમેરશે સામગ્રી

579
00:28:53,140 --> 00:28:54,440
ત્યાં મારા માટે.

580
00:28:54,440 --> 00:28:55,700
તે સુપર અગત્યનું નથી.

581
00:28:55,700 --> 00:28:58,230
>> હું તેનો અર્થ, ટેકનિકલ અમુક પ્રકારના હોય છે
પ્રકારની છે તે પાસાં

582
00:28:58,230 --> 00:29:02,280
માત્ર બતાવવા માટે ની વિશે વાત ઠંડી, પરંતુ
તમે, હું પણ સત્તા પર છે

583
00:29:02,280 --> 00:29:03,070
આસપાસ આ બદલો.

584
00:29:03,070 --> 00:29:06,280
તેથી હું ફક્ત સમૂહ ઉમેરી શકો છો
જેમ સામગ્રી.

585
00:29:06,280 --> 00:29:11,780
અને પછી હવે, હું જુઓ મારા
આઉટપુટ, તે છે.

586
00:29:11,780 --> 00:29:19,740
તેથી આ હેડરો અમુક વસ્તુઓ અર્થ
જેમ બ્રાઉઝર્સ અને વસ્તુઓ છે.

587
00:29:19,740 --> 00:29:23,040
>> અને હેડરો મૂળભૂત બ્રાઉઝર કહી શકે છે
કેવી રીતે કંઈક પ્રતિભાવ આપવા માટે.

588
00:29:23,040 --> 00:29:26,280
શું તમે ક્યારેય પહેલાં કૂકીઝ સાંભળ્યું કર્યું છે
અથવા તમે ક્યારેય નારાજ થયા છો જો

589
00:29:26,280 --> 00:29:29,330
કૂકીઝ સેટ વેબ પેજ દ્વારા,
અથવા કૂકી બ્લોક અથવા ચાલુ

590
00:29:29,330 --> 00:29:30,320
તે કંઈક.

591
00:29:30,320 --> 00:29:33,040
તમે ખરેખર કૂકીઝ સેટ કરી શકો છો
આ હેડરો માં.

592
00:29:33,040 --> 00:29:36,990
તેથી તેઓ કેવી રીતે એક બ્રાઉઝર કહી
કેટલાક કિસ્સાઓમાં વર્તન.

593
00:29:36,990 --> 00:29:37,750
બરાબર.

594
00:29:37,750 --> 00:29:40,310
>> જેથી simpler.js હતી.

595
00:29:40,310 --> 00:29:42,780
કોઈની કોઇ પ્રશ્નો હોય તો
તે સ્રોતો કોડ ફાઇલ પર?

596
00:29:42,780 --> 00:29:45,420

597
00:29:45,420 --> 00:29:45,610
બરાબર.

598
00:29:45,610 --> 00:29:46,490
કૂલ.

599
00:29:46,490 --> 00:29:50,780
>> તેથી આપણે કે ના આર દૂર કરો
અને simple.js જુઓ.

600
00:29:50,780 --> 00:29:53,010
તેથી આ એક ખૂબ સુંદર છે
તે જ કાર્યક્રમ.

601
00:29:53,010 --> 00:29:56,030
હું થોડી અલગ તે લખ્યું
હું હાઇલાઇટ સૉર્ટ માગે છે, કારણ કે

602
00:29:56,030 --> 00:29:57,850
જાવાસ્ક્રિપ્ટ અમુક લક્ષણો છે.

603
00:29:57,850 --> 00:30:03,880
>> તેથી નોંધ્યું છે કે વિનંતી સંભાળનાર
કાર્ય સંપૂર્ણપણે અંત આવ્યો છે.

604
00:30:03,880 --> 00:30:05,800
હા ઓહ, તમે એક પ્રશ્ન છે?

605
00:30:05,800 --> 00:30:08,200
>> પ્રેક્ષક: અરે વાહ, દલીલો
તે માટે પસાર થાય છે

606
00:30:08,200 --> 00:30:10,120
કાર્ય, તેઓ શું છે?

607
00:30:10,120 --> 00:30:12,050
>> કેપી સ્ચમિડ: તેથી તે છે
જાવાસ્ક્રિપ્ટ વસ્તુઓ.

608
00:30:12,050 --> 00:30:15,230
આ Node.js દસ્તા, તે
મૂળભૂત પદ્ધતિઓ શું કહે છે

609
00:30:15,230 --> 00:30:15,910
તેમના પર ઉપલબ્ધ છે.

610
00:30:15,910 --> 00:30:19,602
અમે હમણાં જ ના વપરાશ હોય થાય છે
લખવા હેડ અને અંતિમ કહેવાય પદ્ધતિ

611
00:30:19,602 --> 00:30:20,730
અને જેમ સામગ્રી.

612
00:30:20,730 --> 00:30:22,590
પરંતુ સંપૂર્ણ જથ્થો છે
વધુ પદ્ધતિઓ.

613
00:30:22,590 --> 00:30:27,670
>> અને ઉદાહરણ તરીકે, એક તેમને જેવા
REC પર ખાસ કરીને, તમે કરી શકો છો

614
00:30:27,670 --> 00:30:34,540
rec.method કંઈક કે જે કરશે
તે HTTP વિચાર છે કે શું તમે કહો

615
00:30:34,540 --> 00:30:36,780
HTTP પોસ્ટ અરજીઓ અને
તે જેવી વસ્તુઓ.

616
00:30:36,780 --> 00:30:39,100
તેથી વિવિધ તમામ પ્રકારના છે
ગુણધર્મો છે, પરંતુ તેઓ બંને છો

617
00:30:39,100 --> 00:30:42,560
જાવાસ્ક્રિપ્ટ પદાર્થો, અને તેઓ માત્ર છે
તેમને સાથે જોડાયેલ કાર્યો તમે તે

618
00:30:42,560 --> 00:30:43,850
વસ્તુઓ લખી શકો છો.

619
00:30:43,850 --> 00:30:45,520
બરાબર?

620
00:30:45,520 --> 00:30:49,030
>> જેથી વિનંતી સંભાળનાર નોટિસ
તદ્દન ચાલ્યો આવે છે.

621
00:30:49,030 --> 00:30:52,650
પરંતુ હું વિનંતી કરી હતી કે કોડ
સંભાળનાર હજુ પણ અહીં છે.

622
00:30:52,650 --> 00:30:56,520
હું હજુ પણ આ res.writeHead છે
અને હું હજુ પણ આ res.end છે.

623
00:30:56,520 --> 00:31:00,270
અને આ માં એક ઉદાહરણ છે
જાવાસ્ક્રિપ્ટ એક આ વિચાર છે

624
00:31:00,270 --> 00:31:01,460
અનામી કાર્ય કરે છે.

625
00:31:01,460 --> 00:31:04,180
અને અનામી ફિટિંગ નામ જેવું છે
તે માટે તે શાબ્દિક નથી કારણ કે

626
00:31:04,180 --> 00:31:05,180
એક નામ છે.

627
00:31:05,180 --> 00:31:07,900
કોઈ કાર્ય વિનંતી છે
ત્યાં સંભાળનાર.

628
00:31:07,900 --> 00:31:10,110
>> કોઇ નામ ધરાવે છે, પરંતુ તે હજુ પણ
એક દલીલ લે છે.

629
00:31:10,110 --> 00:31:12,250
તેથી હું હજુ પણ REC અને અનામત બાદ કરતા થઈ જાય છે.

630
00:31:12,250 --> 00:31:16,180
અને હું હજુ પણ કોડ છે.

631
00:31:16,180 --> 00:31:18,930
આ સંપૂર્ણપણે દંડ છે
જાવાસ્ક્રિપ્ટ કોડ.

632
00:31:18,930 --> 00:31:22,540
તેથી હું વગર કાર્ય જાહેર કરી શકો છો
તેને બાહ્ય રીતે એક નામ આપી.

633
00:31:22,540 --> 00:31:24,250
તે પ્રથમ થોડો ચિંતામાં મૂકી દે છે.

634
00:31:24,250 --> 00:31:26,230
કેટલાક જેવા ઉપયોગી વસ્તુઓ છે
તમારી સાથે કરી શકો છો

635
00:31:26,230 --> 00:31:28,450
આ અનામી કાર્ય કરે છે.

636
00:31:28,450 --> 00:31:32,100
કોઇ આ પર કોઇ પ્રશ્નો હોય તો,
અથવા તે માત્ર માટે, હવે બરાબર છે

637
00:31:32,100 --> 00:31:34,130
જેવું જ સ્વીકારે છે કે તે
આ જ વાત કરશે?

638
00:31:34,130 --> 00:31:36,700

639
00:31:36,700 --> 00:31:37,125
હા?

640
00:31:37,125 --> 00:31:38,680
>> પ્રેક્ષક: વિધેયો પ્રથમ છે
જાવાસ્ક્રિપ્ટ વર્ગ?

641
00:31:38,680 --> 00:31:41,020
>> કેપી સ્ચમિડ છેઃ તેથી છે
જાવાસ્ક્રિપ્ટ વર્ગ.

642
00:31:41,020 --> 00:31:45,490
અને માત્ર ખબર કે આ ખ્યાલો
જેમ એક અનામી કાર્ય માં પસાર

643
00:31:45,490 --> 00:31:49,600
આ જાવાસ્ક્રિપ્ટ લાગુ પડે છે કે જો તમારી પાસે
માટે તમારી અંતિમ પ્રોજેક્ટમાં લખી શકે છે

644
00:31:49,600 --> 00:31:51,260
પણ વેબ બ્રાઉઝર.

645
00:31:51,260 --> 00:31:56,700
તેથી ઉદાહરણ તરીકે, જાવાસ્ક્રિપ્ટ માં
તમારા બ્રાઉઝર, તે કંઈક અંશે પણ ઘટના છે

646
00:31:56,700 --> 00:32:00,680
અર્થમાં નહીં કે શું તમે પડશે
વપરાશકર્તા આ ક્લિક કરે છે જ્યારે છે

647
00:32:00,680 --> 00:32:02,640
બટન, હું તમને આ કોડ ચલાવવા માંગો છો.

648
00:32:02,640 --> 00:32:07,070
>> તેથી તે વિચારો પણ તે જ પ્રકારની છે
ક્લાઈન્ટ બાજુ માઉસ ક્લિક કરો અથવા તેઓ જ્યારે

649
00:32:07,070 --> 00:32:09,870
પર કેટલાક છબી પર માઉસ તમારા
વેબ પૃષ્ઠ, આ કોડ ચલાવો.

650
00:32:09,870 --> 00:32:11,350
કે સર્વરો માટે અરજી કરી શકો છો.

651
00:32:11,350 --> 00:32:16,380
જેથી પ્રકારની ઉત્તેજક જેવું છે
જાવાસ્ક્રિપ્ટ ખરેખર શા માટે છે કારણ

652
00:32:16,380 --> 00:32:19,810
યોગ્ય અથવા અમુક લોકો તે લાગે છે
આ પ્રકારની માટે યોગ્ય ભાષા

653
00:32:19,810 --> 00:32:22,530
ઘટના ડ્રાઇવર સર્વર તમારું છે કારણ કે
આ અનામી કાર્ય કરે છે.

654
00:32:22,530 --> 00:32:26,150
તમે સમગ્ર વિચાર છે
આ અસમકાલીક કોડ.

655
00:32:26,150 --> 00:32:27,060
બરાબર.

656
00:32:27,060 --> 00:32:30,360
ત્યાં જવા માટે કોઇપણ કોઇ પ્રશ્નો હોય?

657
00:32:30,360 --> 00:32:30,470
>> બરાબર.

658
00:32:30,470 --> 00:32:33,440
જેથી simple.js હતી.

659
00:32:33,440 --> 00:32:38,070
તેથી આપણે વધુ એક જુઓ
અથવા થોડા વધુ.

660
00:32:38,070 --> 00:32:42,040
તેથી આ sleep.js છે.

661
00:32:42,040 --> 00:32:47,160
તેથી સાથે પરિચિત કોઇ છે
સી કાર્ય ઊંઘ?

662
00:32:47,160 --> 00:32:50,936
અગાઉના વ્યાખ્યાન કદાચ એક પ્રતિ
અથવા તે કંઈક?

663
00:32:50,936 --> 00:32:54,650
>> તેથી મૂળભૂત રીતે તમે મને લાગે છે માં પસાર કરી શકો છો એક
સેકન્ડ નંબર અથવા તમે યુ ઉપયોગ કરી રહ્યાં છો

664
00:32:54,650 --> 00:32:57,080
મિલિસેકન્ડોમાં છે ઊંઘ
અથવા નાનોસેકંડ્ઝ.

665
00:32:57,080 --> 00:33:00,450
અને મૂળભૂત કાર્યક્રમ માત્ર બંધ કરશે
સમય કે રકમ માટે ચાલી રહ્યું છે.

666
00:33:00,450 --> 00:33:01,280
અધિકાર?

667
00:33:01,280 --> 00:33:06,970
અને પછી તે આખરે જાગે અને કરશે
પછી તે માત્ર ચાલી ચાલુ રાખીશું

668
00:33:06,970 --> 00:33:08,340
કાર્યક્રમ.

669
00:33:08,340 --> 00:33:12,740
>> તેથી આ સર્વર પ્રકારના આપે છે
ઊંઘ ના છાપ.

670
00:33:12,740 --> 00:33:17,580
તેથી અમે એ જ છે કે નોટિસ
હેડર સાથે 200 res.writeHead

671
00:33:17,580 --> 00:33:22,130
પહેલાં, પરંતુ પછી અમે આ કૉલ કરી રહ્યાં છો
કાર્ય સેટ સમયસમાપ્તિ છે.

672
00:33:22,130 --> 00:33:26,170
સેટ કરો સમયસમાપ્તિ પણ ઉપલબ્ધ છે
તમારા વેબ બ્રાઉઝર Google Chrome

673
00:33:26,170 --> 00:33:28,000
અથવા સફારી અથવા જે.

674
00:33:28,000 --> 00:33:31,720
અને મૂળભૂત રીતે તે અહીં શું કરી રહ્યો છે
તે કાર્ય માં લેતી છે છે.

675
00:33:31,720 --> 00:33:33,360
નોંધ લો, ફરી, તે એક છે
અનામી કાર્ય કરે છે.

676
00:33:33,360 --> 00:33:36,310
અમે છો કારણ કે તે પ્રકારના ઠંડી છે
એક અંદર એક અનામી કાર્ય ઉપયોગ

677
00:33:36,310 --> 00:33:38,950
અનામી કાર્ય જે
થોડી વિચિત્ર લાગે છે.

678
00:33:38,950 --> 00:33:42,270
>> પરંતુ તે છે, કે જે તે કાર્ય લેતી છે
આ રીતે અને - મૂળભૂત કહી

679
00:33:42,270 --> 00:33:47,430
કામ કરે છે હું માંગો છો, 5,000 મિલિસેકન્ડોમાં છે
તમે તે કાર્ય ચલાવવા માટે જે

680
00:33:47,430 --> 00:33:50,830
માત્ર હે પ્રતિભાવ પૂરો થાય છે અને લખે છે.

681
00:33:50,830 --> 00:33:56,730
તેથી આ જેવી છાપ આપે છે
ઊંઘ, પરંતુ જે રીતે આ ખરેખર

682
00:33:56,730 --> 00:33:59,780
કામ કરે છે અમે મારફતે ચલાવવા પડશે છે
ખૂબ જ ઝડપથી આ વાક્ય.

683
00:33:59,780 --> 00:34:01,190
અમે હમણાં જ કંઈક લખી રહ્યાં.

684
00:34:01,190 --> 00:34:03,780
અને પછી અમે મારફતે ચલાવવા પડશે
ખૂબ જ ઝડપથી આ વાક્ય.

685
00:34:03,780 --> 00:34:08,620
તેથી અમે ખરેખર જઈ રહ્યાં છો
પાંચ સેકન્ડો રાહ જોવી.

686
00:34:08,620 --> 00:34:11,370
અમે હમણાં જ ચલાવવા રહ્યા છીએ
તરત આ કોડ.

687
00:34:11,370 --> 00:34:14,219
>> અને પછી, ફરીથી, આ થોડું છે
હવે આ વાત છે કે ઘટના લૂપ

688
00:34:14,219 --> 00:34:17,570
મૂળભૂત રીતે માત્ર કે રજિસ્ટર
સતત એક વર્તુળમાં આસપાસ રહ્યું

689
00:34:17,570 --> 00:34:21,620
અને એક ઘડિયાળ જોઈ
થ્રેડ અને કહ્યું હતું, પાંચ સેકન્ડો છે

690
00:34:21,620 --> 00:34:22,360
હજુ સુધી પસાર?

691
00:34:22,360 --> 00:34:26,409
અને પછી તે જુએ છે કે બીજા
હાથ પાંચ સેકન્ડો અથવા જેમ ખસેડવામાં આવી છે

692
00:34:26,409 --> 00:34:29,190
ગમે છે, પછી તે સહમત, અને કહે છે
ઓહ, હું શું કરવા છે?

693
00:34:29,190 --> 00:34:30,350
ઓહ હું આ કોડ સ્કોર છે.

694
00:34:30,350 --> 00:34:33,110
અને પછી તે ચાલી રહ્યું છે
અરે res.end ચલાવો.

695
00:34:33,110 --> 00:34:35,360
>> તેથી ફરી, અમે અહીં રાહ જોઈ ક્યારેય છો.

696
00:34:35,360 --> 00:34:38,590
તેથી તે નથી કે અંદર આ કોડ
આ કાર્ય પાંચ લાગી રહ્યું છે

697
00:34:38,590 --> 00:34:39,900
ચલાવવા માટે સેકન્ડ.

698
00:34:39,900 --> 00:34:43,090
આ કોડ ખૂબ ખૂબ ચાલશે
માટે તત્કાલ, ઓછામાં ઓછા સંબંધિત

699
00:34:43,090 --> 00:34:46,139
અમે વાત કરવામાં આવી હતી જે પાંચ સેકન્ડ
વિશે અગાઉ પહેલાં.

700
00:34:46,139 --> 00:34:52,100
>> તેથી માત્ર પગલાં આ દર્શાવે છે
હું Node.sleep.js કરી શકો છો.

701
00:34:52,100 --> 00:34:55,159
અને કંઈક હું ગડબડ કરી હતી?

702
00:34:55,159 --> 00:34:56,310
કદાચ.

703
00:34:56,310 --> 00:34:57,410
માફ કરશો.

704
00:34:57,410 --> 00:34:59,530
કે અમે આ ઠીક કરી શકે છે તે જોવા દો.

705
00:34:59,530 --> 00:35:10,830

706
00:35:10,830 --> 00:35:12,080
બરાબર.

707
00:35:12,080 --> 00:35:15,460

708
00:35:15,460 --> 00:35:17,464
તેથી ચોક્કસપણે Node.js. ઉપયોગ

709
00:35:17,464 --> 00:35:19,440
હું માત્ર મજાક કરું છું છું.

710
00:35:19,440 --> 00:35:19,570
બરાબર.

711
00:35:19,570 --> 00:35:20,820
માત્ર એક સેકન્ડ.

712
00:35:20,820 --> 00:35:27,380

713
00:35:27,380 --> 00:35:27,900
બરાબર.

714
00:35:27,900 --> 00:35:29,130
હું તે શું છે ખબર.

715
00:35:29,130 --> 00:35:34,440
>> તેથી આ મુદ્દો છે કે મારા અન્ય ટેબમાં
અહીં, હું પહેલેથી જ પર નોડ ચાલી રહ્યું હતું

716
00:35:34,440 --> 00:35:36,590
તે જ સરનામું 1337.

717
00:35:36,590 --> 00:35:43,370
અમે જુઓ આ દીધો કે જેથી ભૂલ
તે વાસ્તવિક નજીકથી માં છે

718
00:35:43,370 --> 00:35:45,180
, EADDRINUSE ઉપયોગ કરે છે.

719
00:35:45,180 --> 00:35:47,970
તેથી હું પહેલેથી જ અહીં 1337 ઉપયોગ કરવામાં આવ્યો હતો.

720
00:35:47,970 --> 00:35:52,210
હું હવે પછી આ બંધ છે, અને તેથી જો
, આસ્થાપૂર્વક, બધું આ સ્કોર પ્રયત્ન કરો

721
00:35:52,210 --> 00:35:53,210
દંડ થશે.

722
00:35:53,210 --> 00:35:53,440
બરાબર.

723
00:35:53,440 --> 00:35:57,020
તેથી જો તમે માત્ર એક જ વસ્તુ પ્રકારની હોય છે
ના એક જ સમયે એક પોર્ટ પર સાંભળી.

724
00:35:57,020 --> 00:35:59,660
અન્ય ઉકેલ મારા માટે કરવામાં આવ્યો હતો
માત્ર કે કાર્યક્રમ ફેરફાર કરો અને બનાવવા માટે

725
00:35:59,660 --> 00:36:02,370
તે 1338 અથવા કંઈક જેવી છે
કે.

726
00:36:02,370 --> 00:36:04,100
>> પરંતુ હવે ઊંઘ ચાલી રહ્યું છે.

727
00:36:04,100 --> 00:36:06,400
તેથી આપણે ખરેખર તે બહાર પ્રયાસ કરો
બ્રાઉઝર આ સમય તે છે, કારણ કે એક

728
00:36:06,400 --> 00:36:09,080
જોવા માટે થોડી unexciting
તે ટર્મિનલમાં.

729
00:36:09,080 --> 00:36:13,560
તેથી હું ફક્ત કે ઈચ્છા પર જાઉં છું
127 આંકડાના ફરી 1337 પર.

730
00:36:13,560 --> 00:36:14,850
અને જો તમે તેને જોઈ શકે છે -

731
00:36:14,850 --> 00:36:18,050
હું તમે કરી શકો છો જો ખબર નથી - પરંતુ મારા
બ્રાઉઝરની ખૂબ, ખૂબ લાંબો સમય લેતું

732
00:36:18,050 --> 00:36:20,600
અથવા પાંચ સેકન્ડ જેવા લાવવા માટે સમય.

733
00:36:20,600 --> 00:36:23,460
>> અને પછી તે પછી, તે છેવટે
પ્રતિભાવ રહ્યો હતો.

734
00:36:23,460 --> 00:36:29,070
અને તમે તેને જોઈ શકે છે, કારણ કે આ વસ્તુ
હું બનાવવા જો થોડો વળી ગયા છે, પરંતુ

735
00:36:29,070 --> 00:36:32,500
આ થોડી નાની, તમે
તે હેય કહે છે જોઈ શકે છે.

736
00:36:32,500 --> 00:36:35,130
તેથી હું હે મળી છે, પણ
પાંચ સેકન્ડો પછી.

737
00:36:35,130 --> 00:36:38,510
અને તે જોવા માટે થોડો ક્લીનર હોઈ શકે
અહીં ટર્મિનલ પર છે, તેથી હું છું

738
00:36:38,510 --> 00:36:40,980
એક કરી રહ્યું -

739
00:36:40,980 --> 00:36:43,540
અહીં શું દો -

740
00:36:43,540 --> 00:36:48,370
ચાલો તેને આંકડાના કર્લ કરવા દો
ફરી 1337 સાથે.

741
00:36:48,370 --> 00:36:50,820
અને હું માત્ર પ્રકારની બેસી છે
અહીં પાંચ સેકન્ડ માટે.

742
00:36:50,820 --> 00:36:53,760
નોટિસ પણ છે કે સર્વર
નવા જવાબો સ્વીકારી શકો છો.

743
00:36:53,760 --> 00:36:54,940
તેથી તે હે છાપે છે.

744
00:36:54,940 --> 00:36:58,720
>> અને સામાન્ય રીતે, આ ડેમો માટે શું
હું આ અન્ય ટેબ માં કરી શકો છો -

745
00:36:58,720 --> 00:37:02,640
તેથી આપણે હું અન્ય ટેબમાં આવું કહેવું,
હું curl અને તે જ કરવા જાઉં છું

746
00:37:02,640 --> 00:37:03,780
વાત ફરી.

747
00:37:03,780 --> 00:37:06,600
અને હું આ લાત પ્રયાસ જાઉં છું
તે જ સમયે ગાય્ઝ નહીં.

748
00:37:06,600 --> 00:37:08,260
તેથી હું આ કરવા જાઉં છું, અને હું છું
અહીં પર રેસ માટે જવું અને હું છું

749
00:37:08,260 --> 00:37:09,650
તેને ફરીથી કરવા માટે જઈ રહી છે.

750
00:37:09,650 --> 00:37:14,030
>> અને આપણે તેના સમાધાન કરવું કે જેથી તમે
બંને જોઈ શકો છો.

751
00:37:14,030 --> 00:37:20,250
અરે મુદ્રિત કે એક અને એક કે
મુદ્રિત અરે બધી રીતે પર -

752
00:37:20,250 --> 00:37:22,550
માતાનો ફરીથી કે પ્રયોગ કરવા દો.

753
00:37:22,550 --> 00:37:25,100
ખરેખર, આપણે આ ઉપયોગ કરવા દેવા
તે બરાબર છે, તો યુક્તિ.

754
00:37:25,100 --> 00:37:30,520
>> તેથી હું શેલ વસ્તુ વાપરવા માટે જાઉં છું કે
મને મૂળભૂત રીતે બે નકલો ચલાવવા માટે પરવાનગી આપે છે

755
00:37:30,520 --> 00:37:32,630
સમાંતર રીતે આ કાર્યક્રમ છે.

756
00:37:32,630 --> 00:37:36,070
તેથી તે પ્રથમ કાર્યક્રમ ચલાવો અને પડશે
સમાંતર માં બીજા કાર્યક્રમ.

757
00:37:36,070 --> 00:37:39,060
હું Enter દબાવો તો તેથી હવે, તે ચાલી રહ્યું છે
કે ખૂબ ખૂબ વિનંતી કરી

758
00:37:39,060 --> 00:37:40,570
તત્કાલ એક જ સમયે.

759
00:37:40,570 --> 00:37:42,620
તેથી આપણે આ શોટ આપી દો.

760
00:37:42,620 --> 00:37:44,950
>> તેથી હવે તે બે પ્રક્રિયાઓ કહે નોંધ લો.

761
00:37:44,950 --> 00:37:50,630
અને તમે વિચિત્ર છો, કે જે 27,000
નંબર મૂળભૂત પ્રક્રિયા ID છે.

762
00:37:50,630 --> 00:37:52,940
અને પછી તેઓ પ્રિન્ટેડ, નોટિસ
અરે એક જ સમયે.

763
00:37:52,940 --> 00:37:56,820
તે અમે પાંચ રાહ જોવી પડી હતી જેવી ન હતી
તે પછી એક અને પછી માટે સેકન્ડ,

764
00:37:56,820 --> 00:37:59,640
પાંચ સેકન્ડો પછી બીજા વિશે.

765
00:37:59,640 --> 00:38:03,300
તેથી તે પ્રકારના છે, કેટલીક રીતે, તે છે
ખરેખર પુરાવા છે, પરંતુ તે નથી

766
00:38:03,300 --> 00:38:07,390
તે માત્ર નથી કે સાહજિક પુરાવા
પાંચ સેકન્ડો રાહ જોઈ અને અવરોધિત જેમ

767
00:38:07,390 --> 00:38:08,960
સમગ્ર થ્રેડ.

768
00:38:08,960 --> 00:38:10,720
ઠંડી બરાબર.

769
00:38:10,720 --> 00:38:17,850
>> તેથી આરોન અગાઉ એક પ્રશ્ન પૂછવામાં કે
હતી, સાથે સાથે આપણે કંઈક તો -

770
00:38:17,850 --> 00:38:18,735
હા?

771
00:38:18,735 --> 00:38:19,051
>> પ્રેક્ષક: રાહ જુઓ.

772
00:38:19,051 --> 00:38:21,585
કેવી રીતે છે કે અલગ
printf બફર છે, જોકે?

773
00:38:21,585 --> 00:38:23,010
તે આપોઆપ કે શું નથી?

774
00:38:23,010 --> 00:38:25,390
શા માટે અમે તે વિશે ચિંતા કરવાની જરૂર છે?

775
00:38:25,390 --> 00:38:26,555
>> કેપી સ્ચમિડ: ઓહ, તમે કરી શકે
એક કે વધુ સમય કહે છે?

776
00:38:26,555 --> 00:38:29,510
>> પ્રેક્ષક: printf બફર પસંદ નથી
ચોક્કસ જ વાત કરે છે?

777
00:38:29,510 --> 00:38:31,280
>> કેપી સ્ચમિડ: આ printf બફર?

778
00:38:31,280 --> 00:38:32,753
>> પ્રેક્ષક: યાહ.

779
00:38:32,753 --> 00:38:33,244
બરાબર.

780
00:38:33,244 --> 00:38:40,609
તેઓ હતા આ અંગેની ક્વિઝ એક ન હતી
તમે કેવી રીતે જો યોગ્ય printf વિશે વાત

781
00:38:40,609 --> 00:38:42,899
કંઈક અને પછી તે એક વિરામ છે
બીજું, અને પછી તમે તેને લૂપ દસ છે

782
00:38:42,899 --> 00:38:46,530
વખત, તે દસ સેકન્ડ રાહ જુઓ અને પડશે
પછી બધું મળીને printf?

783
00:38:46,530 --> 00:38:47,460
>> કેપી સ્ચમિડ: ઓહ, બરાબર.

784
00:38:47,460 --> 00:38:49,170
>> પ્રેક્ષક: તે એ જ કરી રહ્યા છે
વાત પછી આ કિસ્સામાં?

785
00:38:49,170 --> 00:38:52,630
>> કેપી સ્ચમિડ: તેથી પ્રશ્ન હતો
મૂળભૂત રીતે ભૂતપૂર્વ અંગેની ક્વિઝ એક

786
00:38:52,630 --> 00:38:57,200
અથવા કંઈક, એક પ્રશ્ન હતો કે
મૂળભૂત રીતે તમે પ્રિન્ટ એફ 10 કહે છે તો

787
00:38:57,200 --> 00:39:01,490
પછી એક સમયે વસ્તુઓ અને જેમ સુતી
તે પ્રિન્ટ કરવાની પ્રક્રિયા,

788
00:39:01,490 --> 00:39:04,850
કેટલાક કારણોસર અંતે, તે કરશે
માત્ર સ્ક્રીન પર ઓલઆઉટ તે રેડે છે.

789
00:39:04,850 --> 00:39:06,740
તેથી અલગ બે પ્રકારની છે
અહીં ખ્યાલ.

790
00:39:06,740 --> 00:39:10,400
>> તેથી હું એક વાત, એમાં માનું છે
કેસ, અમે અલગ બે સાથે કામ કરીએ છીએ

791
00:39:10,400 --> 00:39:13,510
પ્રકારના લોકો સર્વર પૂછવા
તે જ સમયે વસ્તુઓ માટે.

792
00:39:13,510 --> 00:39:17,455
અને તે છે printf પ્રકારની કારણ
જેમ રાહ જુએ છે અને તે બધા બહાર ડમ્પ

793
00:39:17,455 --> 00:39:21,760
એક જ સમયે વધુ સંબંધિત છે
કેવી રીતે printf પ્રકારની -

794
00:39:21,760 --> 00:39:25,100
જેથી માર્ગ printf ખરેખર છે
તે વાસ્તવમાં અમલમાં છે છે

795
00:39:25,100 --> 00:39:28,850
લખવા માટે ઓપરેટિંગ સિસ્ટમ સાથે વાત
કન્સોલ પર કે સામગ્રી.

796
00:39:28,850 --> 00:39:33,460
તેથી તે તમામ કરી ન હોય
તમે printf કહે છે ત્યારે તરત જ સામગ્રી

797
00:39:33,460 --> 00:39:36,260
કેટલાક શબ્દમાળા કે શકે છે
તે છે જો ખર્ચાળ વિચાર

798
00:39:36,260 --> 00:39:37,340
દર વખતે થાય છે.

799
00:39:37,340 --> 00:39:41,530
>> જો તમે કરો તો, હે તમારા કાર્યક્રમ printf
ખરેખર છે કે પ્રિન્ટ કરી શકશે નહીં

800
00:39:41,530 --> 00:39:43,040
તરત જ કન્સોલ પર.

801
00:39:43,040 --> 00:39:46,080
તે ઠીક છે, હું તે લખ્યું, કહી શકે છે.

802
00:39:46,080 --> 00:39:49,570
તમે આપી માટે અને પછી પ્રકારની રાહ
તે ખરેખર પહેલાં થોડી વધુ

803
00:39:49,570 --> 00:39:51,380
કન્સોલ પર તેને લખી.

804
00:39:51,380 --> 00:39:54,040
>> જેથી કેસ હતો કે કારણ -

805
00:39:54,040 --> 00:39:56,450
અને તે પ્રકારની બિનસંબંધિત છે
સ્લીપ માટે -

806
00:39:56,450 --> 00:40:00,060
સ્લીપ પ્રકારના માત્ર હોય છે
નિદર્શન ત્યાં ઇન્જેક્ટ

807
00:40:00,060 --> 00:40:02,480
તે લખી નથી કે હકીકત
તે થયેલ.

808
00:40:02,480 --> 00:40:06,210
પરંતુ તે માટે કારણ માત્ર છે
પ્રભાવ તમને નથી કરી શકે તે માટે

809
00:40:06,210 --> 00:40:08,920
કે ઘણા સંપર્કો બનાવે છે
આ ઓપરેટિંગ સિસ્ટમ.

810
00:40:08,920 --> 00:40:12,300
>> પરંતુ અહીં, અમે ખરેખર કરવા પ્રયાસ કરી રહ્યા છો
આ ઊંઘ વસ્તુ સાથે માત્ર શો છે

811
00:40:12,300 --> 00:40:17,730
કે અમે મુલાકાત બે લોકો હોય
આ વેબસાઇટ, મૂકી નથી ચાલી રહ્યું છે

812
00:40:17,730 --> 00:40:22,310
તેમને તે કહેવું રહ્યું છે એક લીટી માં
હું છું ત્યારે પછી તમે મદદ કરે છે અને છે

813
00:40:22,310 --> 00:40:25,350
તદ્દન આ પછી તમે મદદ સમાપ્ત
પાંચ સેકન્ડો, પછી હું જાઉં છું

814
00:40:25,350 --> 00:40:26,750
આગામી વ્યક્તિ પર ખસેડો.

815
00:40:26,750 --> 00:40:29,515
જેથી પ્રથમ વ્યક્તિ વિનંતી નથી
આ ઘટના લૂપ ગૂંચ

816
00:40:29,515 --> 00:40:31,610
જો તે અર્થમાં બનાવે.

817
00:40:31,610 --> 00:40:34,980
>> પરંતુ અહીં ખરેખર એક ઉદાહરણ છે
ગૂંચ કરશે કે કંઈક છે

818
00:40:34,980 --> 00:40:36,090
ઘટના લૂપ છે.

819
00:40:36,090 --> 00:40:39,130
અહીં એક ભયાનક કામ કરવા માટે છે
આ nth ફિબોનાકી ગણતરી.

820
00:40:39,130 --> 00:40:43,510
તે શાબ્દિક તમે કરી શકો છો ખરાબ રીત છે
આ nth ફિબોનાકી નંબર ગણતરી.

821
00:40:43,510 --> 00:40:48,480
અને આ માત્ર સ્વીકારો ખરેખર છે
આ ક્યાંથી આવ્યા

822
00:40:48,480 --> 00:40:49,330
ત્યાં ખરેખર -

823
00:40:49,330 --> 00:40:53,230
હું તેનો અર્થ, તમે જવા માટે તેને શોધી પ્રયાસ કરી શકો છો - પણ
ખૂબ જ લાંબી બ્લોગ જેવા છે

824
00:40:53,230 --> 00:40:54,130
કોઈકને લખ્યું કે પોસ્ટ કરો.

825
00:40:54,130 --> 00:40:55,660
તે તે Reddit વસ્તુઓ છે કે જેવું છે.

826
00:40:55,660 --> 00:40:59,650
પરંતુ કોઈકને Node.js ટીકા, અને
તેઓ એક ઉદાહરણ તરીકે આ ઉપયોગ થાય છે.

827
00:40:59,650 --> 00:41:03,700
તેથી હું પ્રકારની માત્ર તમે બે બતાવવા માગે છે
વિવિધ દ્રષ્ટિકોણથી માત્ર વિચાર

828
00:41:03,700 --> 00:41:07,320
ખ્યાલ છે એક સામાન્ય સમજ
આ બે વસ્તુઓ પાછળ.

829
00:41:07,320 --> 00:41:13,050
>> પરંતુ આ માત્ર એક ભયાનક તરીકે પસંદ કરવામાં આવે છે
બહુ બિનકાર્યક્ષમ કોમ્પ્યુટેશનલ

830
00:41:13,050 --> 00:41:15,940
આ ગણતરી સઘન રીતે
nth ફિબોનાકી નંબર.

831
00:41:15,940 --> 00:41:21,180
તેથી માત્ર એક બાજુ નોંધ તરીકે, શા માટે છે
તે ભયાનક એક રીતે ગમે છે?

832
00:41:21,180 --> 00:41:23,210
હા?

833
00:41:23,210 --> 00:41:25,130
>> પ્રેક્ષક: તમે શરૂ કહો
1000 સાથે.

834
00:41:25,130 --> 00:41:27,050
999 અને 998 માં 1,000 નાંખે.

835
00:41:27,050 --> 00:41:28,970
આ દરેક બે વસ્તુઓ માં નાંખે છે.

836
00:41:28,970 --> 00:41:30,890
આ દરેક બે વસ્તુઓ માં નાંખે છે.

837
00:41:30,890 --> 00:41:31,355
>> કેપી સ્ચમિડ: અધિકાર.

838
00:41:31,355 --> 00:41:32,400
>> પ્રેક્ષક: બધા માર્ગ.

839
00:41:32,400 --> 00:41:32,840
>> કેપી સ્ચમિડ: ચોક્કસ.

840
00:41:32,840 --> 00:41:37,330
તેથી જો માત્ર કેમેરા માટે પુનરાવર્તન હું
1,000 અથવા કંઈક જેવી પર ગપ મારવી કૉલ

841
00:41:37,330 --> 00:41:41,810
જેમ, તે દેખીતી રીતે કરતાં ઓછી નથી
અથવા એક સમાન તેથી હું જાઉં છું

842
00:41:41,810 --> 00:41:46,040
આ બીજા કિસ્સામાં પર જાઓ, અને પછી હું જાઉં છું
999 ગપ મારવી વત્તા 998 ગપ મારવી કૉલ.

843
00:41:46,040 --> 00:41:50,290
અને પછી ખૂબ ખૂબ તે બધા ની
999 કરે ગપ મારવી કે કાર્ય છે

844
00:41:50,290 --> 00:41:52,950
પ્રકારની આ સ્તરે.

845
00:41:52,950 --> 00:41:55,620
તમે જાઓ, તે હજુ પણ વધુ બિનજરૂરી છે
કરતાં, પરંતુ જો તમે માત્ર

846
00:41:55,620 --> 00:42:01,390
ગણતરી ગપ મારવી 998 નહીં લાગે
અમને ખૂબ નજીક 999 ગપ મારવી છે.

847
00:42:01,390 --> 00:42:05,860
તેથી અમે ખરેખર થોડી વધુ પ્રયત્ન કરીશું
અમે પ્રકારની ફરી ઉપયોગ કેવી રીતે હોંશિયાર

848
00:42:05,860 --> 00:42:07,580
આ છે, પરંતુ અમે વારંવાર ઉપયોગ કરી રહ્યાં છો
બધા આ વસ્તુઓ.

849
00:42:07,580 --> 00:42:11,860
તેથી જો તમે આ કદાવર કલ્પના કરી શકો છો
માત્ર ભયાનક છે કે કદાવર વૃક્ષ.

850
00:42:11,860 --> 00:42:12,940
>> પરંતુ ગમે તે રીતે, બરાબર.

851
00:42:12,940 --> 00:42:14,040
જેથી ગપ મારવી હતી.

852
00:42:14,040 --> 00:42:15,530
તે માત્ર ચલાવવા માટે જ્યારે લે છે.

853
00:42:15,530 --> 00:42:16,510
હા?

854
00:42:16,510 --> 00:42:17,760
>> પ્રેક્ષક: [અશ્રાવ્ય].

855
00:42:17,760 --> 00:42:20,430

856
00:42:20,430 --> 00:42:22,481
>> કેપી સ્ચમિડ: ઓહ, તમે કરી શકે
પ્રશ્ન પુનરાવર્તન?

857
00:42:22,481 --> 00:42:23,731
>> પ્રેક્ષક: [અશ્રાવ્ય].

858
00:42:23,731 --> 00:42:30,840

859
00:42:30,840 --> 00:42:33,990
>> કેપી સ્ચમિડ: ઓહ તેથી આ માત્ર કોડ છે
કે પ્રકારની પર જ હશે

860
00:42:33,990 --> 00:42:34,850
સર્વર બાજુ.

861
00:42:34,850 --> 00:42:38,100
તેથી આ મળી નથી જઈ રહ્યા છે
બ્રાઉઝર અથવા કંઈપણ માં.

862
00:42:38,100 --> 00:42:42,160
તે અમે શું છે મૂળભૂત છે કે જ્યારે
અહીં વપરાશકર્તા ખૂબ ખૂબ બનાવે છે

863
00:42:42,160 --> 00:42:45,300
ફરીથી તેમના વિનંતી, જ્યારે અમે પ્રકારના
વિનંતી કરવા, અમે કહી રહ્યા છીએ

864
00:42:45,300 --> 00:42:47,040
સર્વર બાજુએ જ આ કાર્ય.

865
00:42:47,040 --> 00:42:50,480
અને પછી અમે પરિણામ પાછા મળશે
કે કાર્ય ફોન છે.

866
00:42:50,480 --> 00:42:52,460
અને પછી અમે માત્ર છાપો પડશે
વપરાશકર્તા માટે તે.

867
00:42:52,460 --> 00:42:54,580
તેથી વપરાશકર્તા ખરેખર કામ કરી શકતું નથી
ખૂબ જ આ કાર્ય સાથે.

868
00:42:54,580 --> 00:42:57,270
>> પ્રશ્ન એ હતો કે?

869
00:42:57,270 --> 00:42:58,470
કે અર્થમાં છે?

870
00:42:58,470 --> 00:42:58,810
બરાબર.

871
00:42:58,810 --> 00:43:00,930
કૂલ.

872
00:43:00,930 --> 00:43:04,240
>> તેથી ફરીથી, અમે આ સમગ્ર res.writeHead કરી
અમે છાપે છે વાત

873
00:43:04,240 --> 00:43:05,150
હેડર.

874
00:43:05,150 --> 00:43:09,730
અને પછી હું કરવાથી પ્રતિભાવ અંત
જાદુ નંબર ગપ મારવી 45 છે.

875
00:43:09,730 --> 00:43:12,100
તેથી આપણે માત્ર આ સર્વર ચલાવો.

876
00:43:12,100 --> 00:43:15,190
તેથી હું નોડ fib.js. કરવા જાઉં છું

877
00:43:15,190 --> 00:43:17,340
તેથી હવે મારી ગપ મારવી સર્વર ચાલી રહ્યું છે.

878
00:43:17,340 --> 00:43:21,790
>> અને પછી અહીં, હું જાઉં છું
એક આ કરવા માટે.

879
00:43:21,790 --> 00:43:22,200
બરાબર?

880
00:43:22,200 --> 00:43:24,960
તેથી હું ફક્ત, કર્લ કહેવા જાઉં છું.

881
00:43:24,960 --> 00:43:32,226
તેથી તે થોડો સમય લાગી રહ્યું છે પરંતુ
આસ્થાપૂર્વક જલ્દી સમાપ્ત કરશે

882
00:43:32,226 --> 00:43:35,660
તે 45 મી છાપશે
નંબર ફિબોનાકી.

883
00:43:35,660 --> 00:43:36,910
>> પ્રેક્ષક: [અશ્રાવ્ય].

884
00:43:36,910 --> 00:43:40,720

885
00:43:40,720 --> 00:43:42,050
>> કેપી સ્ચમિડ: તે જોઈએ
ખૂબ જલદી થાય છે.

886
00:43:42,050 --> 00:43:43,780
તેથી તે પાંચ થી છ સેકન્ડ લેવી જોઈએ.

887
00:43:43,780 --> 00:43:48,570
હું માત્ર વી 8 છે સુપર છે ખબર નથી
ઝડપી, પરંતુ કોઈ પણ કિસ્સામાં, આ એક છે

888
00:43:48,570 --> 00:43:52,700
હેતુપૂર્વક ખૂબ જ ટૂંકા ઉદાહરણ અને
એક નગણ્ય લાલિત્ય

889
00:43:52,700 --> 00:43:54,200
ગણતરી.

890
00:43:54,200 --> 00:43:56,700
તેથી થોડા સમય પછી, તે આ વિચાર કરતું નથી.

891
00:43:56,700 --> 00:44:02,130
>> પરંતુ હવે, હું શું કરી જો તે જ પ્રકારની
હું બનાવવા જ્યાં પહેલાં પ્રયોગ

892
00:44:02,130 --> 00:44:04,010
તે જ સમયે બે અરજીઓ?

893
00:44:04,010 --> 00:44:06,990
તેથી અહીં હું એ curl જાઉં છું
તે સરનામું, અને હું જાઉં છું

894
00:44:06,990 --> 00:44:08,260
અન્ય કર્લ કરવું.

895
00:44:08,260 --> 00:44:12,070
અને અમે માટે આ કર્યું છે, યાદ રાખો
અમે મૂળભૂત રીતે તે હતી ત્યારે, સર્વર ઊંઘ

896
00:44:12,070 --> 00:44:15,320
પાંચ સેકન્ડો પછી, તેઓ ખૂબ
ખૂબ બંને અધિકાર પાછા આવ્યા

897
00:44:15,320 --> 00:44:16,380
એ જ સમય આસપાસ.

898
00:44:16,380 --> 00:44:18,650
તેથી તે ખાસ કરીને બાંધી ન હતી.

899
00:44:18,650 --> 00:44:20,290
>> પરંતુ હવે તેને કરવાનો પ્રયાસ કરો.

900
00:44:20,290 --> 00:44:22,370
ઠીક છે, તેથી અમે અમારી બે પ્રક્રિયાઓ થઈ જાય છે.

901
00:44:22,370 --> 00:44:24,210
તે પ્રક્રિયા ID ને છે યાદ રાખો.

902
00:44:24,210 --> 00:44:25,900
આ થોડો પ્રયત્ન રહ્યું છે
અમે સ્ટોલ જ્યારે અનાડી.

903
00:44:25,900 --> 00:44:31,340

904
00:44:31,340 --> 00:44:35,360
તેથી આપણે માત્ર અહીં રહેવા દો અને રાહ જુઓ.

905
00:44:35,360 --> 00:44:37,090
>> તેથી તેમાંથી એક આવવું જોઈએ
પાછા જેમ પછી -

906
00:44:37,090 --> 00:44:39,190
ઠીક છે, તેથી એક પાછા આવ્યા.

907
00:44:39,190 --> 00:44:43,570
પરંતુ તે પછી શા માટે બીજા ન હતી
એક હજુ સુધી પાછા આવો?

908
00:44:43,570 --> 00:44:44,389
હા?

909
00:44:44,389 --> 00:44:49,280
>> પ્રેક્ષક: સર્વરે કંઈપણ કરી શકે છે
તે મોટા નંબર ગણતરી છે છે.

910
00:44:49,280 --> 00:44:51,620
>> કેપી સ્ચમિડ: અધિકાર.

911
00:44:51,620 --> 00:44:55,395
તેથી જવાબ હતો કે જે હમણાં જ સર્વર
ખરેખર કંઈપણ કરી શકે છે, જ્યારે

912
00:44:55,395 --> 00:44:57,460
તે ફિબોનાકી નંબર ગણતરી છે.

913
00:44:57,460 --> 00:44:59,360
તેથી હવે હું માત્ર મારી બે વસ્તુઓ મળી.

914
00:44:59,360 --> 00:45:03,210
પરંતુ હું ફક્ત કોડ વિશે વિચારો ધારી
થોડી વધુ, તે કેવી રીતે કામ કરી રહ્યા છે

915
00:45:03,210 --> 00:45:05,030
અને બધું.

916
00:45:05,030 --> 00:45:11,750
>> તેથી અહીં આ કાર્ય પાંચ કોડ કે
હું જ્યારે ચલાવવા માટે આ સર્વર કહ્યું છે

917
00:45:11,750 --> 00:45:14,100
નવી આવતી અરજીઓને મેળવે છે.

918
00:45:14,100 --> 00:45:17,940
તેથી તે માત્ર આ સ્કોર બનશે
સમગ્ર કોડ છે, અને પછી તે જાઓ બનશે

919
00:45:17,940 --> 00:45:21,120
ઘટના લૂપ પાછળ અને પછી ચાલુ
નવી ઘટનાઓ માટે ચકાસણી.

920
00:45:21,120 --> 00:45:23,670
જેથી મૂળભૂત અમે શું થઈ રહ્યું છે તે
સર્વર છે

921
00:45:23,670 --> 00:45:25,080
નવી વસ્તુઓ માટે સાંભળી.

922
00:45:25,080 --> 00:45:28,070
પ્રથમ વ્યક્તિ 45 છે તે માટે પૂછે છે.

923
00:45:28,070 --> 00:45:30,490
અમે તે ગણતરી કરવા માટે આ કોડ ચલાવો.

924
00:45:30,490 --> 00:45:33,420
આ કોડ લે આશરે પાંચ
ચલાવવા માટે છ સેકન્ડ.

925
00:45:33,420 --> 00:45:36,990
તો પછી અમે આ ઘટના લૂપ પર જાઓ
અને નવા અરજીઓ માટે ચકાસો.

926
00:45:36,990 --> 00:45:42,700
>> તેથી આ તમને, તો કેવી રીતે એક ઉદાહરણ છે
કહેવાતા ગણતરી વસ્તુઓ છે કે જે છે

927
00:45:42,700 --> 00:45:48,140
બંધાયેલ, અથવા કોમ્પ્યુટેશનલ ઘણો ઉપયોગ,
નથી શક્તિ, પરંતુ જેવા છે

928
00:45:48,140 --> 00:45:50,260
સઘન કોમ્પ્યુટેશનલ -

929
00:45:50,260 --> 00:45:54,080
હું આ વિશે કહેવા માટે એક વસ્તુ છે ધારી
આ કાર્ય, તદ્દન કરી છે કે

930
00:45:54,080 --> 00:45:56,310
સૌથી મોટા ભાગ માટે, ખૂબ
ઉપયોગી કામ અધિકાર.

931
00:45:56,310 --> 00:45:59,970
સમગ્ર સમય કે જે કૉલબૅક
કાર્ય ચાલી રહ્યું હતું, તે સારુ હતું

932
00:45:59,970 --> 00:46:03,670
ખૂબ તેના મોટા ભાગના વખતે ખર્ચ માત્ર
કમ્પ્યુટિંગ કે nth ફિબોનાકી નંબર.

933
00:46:03,670 --> 00:46:05,930
>> પરંતુ અમે માત્ર એક થ્રેડ હતી
સાથે કામ કરવા માટે.

934
00:46:05,930 --> 00:46:10,270
અપાચે મોડેલ માં, જ્યારે બે લોકો
, 45 ગપ મારવી મેળવવા માટે વિનંતી કરી અમે

935
00:46:10,270 --> 00:46:11,610
બે અલગ અલગ થ્રેડો હતા.

936
00:46:11,610 --> 00:46:15,060
અને પછી ઓપરેટિંગ સિસ્ટમ કામ
વપરાશકર્તા સ્તર છે, અથવા હોત

937
00:46:15,060 --> 00:46:18,660
સૂત્રો સંચાલન કરે કોડ છે, કર્યું હોત
આ પર હાથીઓને માટે કરવામાં આવી

938
00:46:18,660 --> 00:46:23,060
સીપીયુ, અથવા તમે ઘણા સીપીયુ હતી તો પણ,
પાંચ સીપીયુ સમગ્ર સમાનરૂપે તેમને વિતરણ

939
00:46:23,060 --> 00:46:26,130
તેઓ સમાપ્ત હતા, જેથી
લગભગ આ જ સમયે.

940
00:46:26,130 --> 00:46:31,120
>> તેથી માત્ર અમે સૉર્ટ કરી શકો છો તમે કેવી રીતે દર્શાવે છે -
અને આ એક કુલ સંપૂર્ણ નથી

941
00:46:31,120 --> 00:46:34,280
ઉકેલ છે, પરંતુ જેવું આપણે કઈ રીતે કરી શકો છો
કરી એક પાછા અહીં આવે છે અને કરી

942
00:46:34,280 --> 00:46:35,880
થોડો વધુ સારી.

943
00:46:35,880 --> 00:46:41,540
તેથી શું હું અહીં છે નામના પ્રોગ્રામ છે
ગપ મારવી સી અને આ મૂળભૂત વાપરે

944
00:46:41,540 --> 00:46:45,690
કહેવાય નોડ મોડ્યુલો બીજા એક
આ બાળ પ્રક્રિયા મોડ્યુલ.

945
00:46:45,690 --> 00:46:49,210
તેથી હું સમાવેશ કર્યા છે કે ટોચ પ્રકારની પર
સમાવેશ થાય છે હું પાઉન્ડ કરશો કરવા માંગો

946
00:46:49,210 --> 00:46:51,230
બાળક process.h અથવા કંઈક.

947
00:46:51,230 --> 00:46:56,210
હવે હું આ સી.પી. ચલ વપરાશ હોય છે
જે મારા બધા વિધેય છે.

948
00:46:56,210 --> 00:47:01,810
>> તેથી હવે હું આ જવાબમાં શું કરી રહ્યો છું
સંભાળનાર હું આ કાર્યક્રમ ચાલી રહ્યો છું છે

949
00:47:01,810 --> 00:47:04,100
કોઈ ગપ મારવી 45 સ્લેશ.

950
00:47:04,100 --> 00:47:06,820
તેથી શું હું કર્યું છે - અને હું માત્ર જાઉં છું
એક માટે આ કાર્યક્રમ બહાર પગલું

951
00:47:06,820 --> 00:47:07,620
થોડો -

952
00:47:07,620 --> 00:47:11,060
હું એક સી કાર્યક્રમ તેવા પરચૂરણ ખર્ચ કર્યો છે કે
મૂળભૂત રીતે ગણતરી કરે

953
00:47:11,060 --> 00:47:12,630
nth ફિબોનાકી નંબર.

954
00:47:12,630 --> 00:47:15,960
તેથી અહીં હું તેવા પરચૂરણ ખર્ચ કર્યો માત્ર એક કાર્યક્રમ છે
સી કે આ ગણતરી કરે છે.

955
00:47:15,960 --> 00:47:19,040
હું તેને કમ્પાઇલ કરી શકો છો, અને હું ચાલી શકે છે
તે આદેશ વાક્ય પર.

956
00:47:19,040 --> 00:47:22,150
અને તે ગણતરી બનશે પાંચ
45 મી ફિબોનાકી નંબર.

957
00:47:22,150 --> 00:47:24,510
>> તેથી તે માત્ર લે નોટિસ
સુધી ખૂબ ખૂબ.

958
00:47:24,510 --> 00:47:28,240
હું કદાચ આડંબર 03 માટે ઉપયોગ કરી શકે છે
તે અથવા તે કંઈક ઑપ્ટિમાઇઝ,

959
00:47:28,240 --> 00:47:31,050
પણ મને તો ફક્ત નિયમિત જેવી હતી
કમ્પાઇલર સુયોજનો.

960
00:47:31,050 --> 00:47:33,260
અને તે તેને છાપે.

961
00:47:33,260 --> 00:47:36,830
>> પરંતુ હવે, હું પ્રકારની શું કરી રહ્યો છું?

962
00:47:36,830 --> 00:47:39,800
માફ કરશો ઓહ, ખોટું ફાઇલ.

963
00:47:39,800 --> 00:47:42,800
તેથી હું સાથે જ સામગ્રી કરવા
પહેલાની જેમ હેડર.

964
00:47:42,800 --> 00:47:45,780
પછી હું આ cp.exec નથી.

965
00:47:45,780 --> 00:47:49,460
તેથી શું કરી રહ્યા છે તે છે છે
આ કાર્યક્રમ ચલાવવા માટે જઈ રહી છે.

966
00:47:49,460 --> 00:47:51,960
પરંતુ આ જે રીતે કામ કરે છે
તે માટે રાહ નથી ચાલી રહ્યું છે

967
00:47:51,960 --> 00:47:53,400
સમાપ્ત કરવા માટે કે કાર્યક્રમ.

968
00:47:53,400 --> 00:47:56,000
તે માત્ર મૂળભૂત રીતે કહે છે
આ કાર્યક્રમ ચલાવો.

969
00:47:56,000 --> 00:47:58,700
તેથી મૂળભૂત રીતે આ લખો
વ રત પ્રકારની આદેશ.

970
00:47:58,700 --> 00:48:02,350
>> અને પછી, તમે પૂર્ણ કરી લીધું છે
તે આ કાર્ય ચાલે છે.

971
00:48:02,350 --> 00:48:04,800
તેથી હવે અમે પ્રકારની આ વિચાર
સમગ્ર ફરીથી વસ્તુ

972
00:48:04,800 --> 00:48:06,750
જેમ અમે રાહ જોઈ રહ્યાં છો.

973
00:48:06,750 --> 00:48:08,530
તે પ્રકારના અર્થમાં છે?

974
00:48:08,530 --> 00:48:08,990
હા?

975
00:48:08,990 --> 00:48:11,060
>> પ્રેક્ષક: [અશ્રાવ્ય]?

976
00:48:11,060 --> 00:48:13,610
>> કેપી સ્ચમિડ: તેથી તેનાથી ખરેખર
તે કરવા નવી પ્રક્રિયા ખોલો.

977
00:48:13,610 --> 00:48:19,310
તેથી આ કેટલીક રીતે, ખરેખર છે,
દુષ્ટ સુપર દુષ્ટ નથી, પરંતુ તે છે

978
00:48:19,310 --> 00:48:22,990
મહત્વનું આ પ્રકારની છે કહે છે કે
એક તરફ, પાછા જઈ, અપાચે

979
00:48:22,990 --> 00:48:26,450
અમે સૂત્રો અને પ્રક્રિયાઓ શું છે તે મોડેલ
દરેક વિનંતી અથવા માટે

980
00:48:26,450 --> 00:48:29,280
દરેક વિનંતી માટે પ્રક્રિયા.

981
00:48:29,280 --> 00:48:32,090
તેથી આ સમાન પ્રકારની છે
અપાચે શું કરે છે.

982
00:48:32,090 --> 00:48:35,110
કેટલાક કિસ્સાઓમાં, તે માત્ર એક નવી ઉપયોગ કરશે
થોડી વધુ પ્રકાશ છે જે થ્રેડ,

983
00:48:35,110 --> 00:48:39,040
પ્રક્રિયા કરતાં વજન, પરંતુ અપાચે શકે
નવી પ્રક્રિયા forking અંત

984
00:48:39,040 --> 00:48:43,370
અમે અહીં શું પ્રકારની છે કે જે
સર્વથા કોઈ સ્લેશ ગપ મારવી 45 કરવાથી.

985
00:48:43,370 --> 00:48:48,690
>> અને પછી તે કિસ્સામાં, અમે પ્રકારની નોતરવું
પ્રક્રિયાઓ એ જ ખર્ચ.

986
00:48:48,690 --> 00:48:50,710
તેથી આ તમે કરી શકો છો ફક્ત એક વસ્તુ છે.

987
00:48:50,710 --> 00:48:52,600
પરંતુ માત્ર ચાલી આ પ્રકારની બતાવવા માટે.

988
00:48:52,600 --> 00:48:57,120
અને આ ચર્ચા માત્ર ખરેખર ઊભી કરવાનો છે
એક જેવા કાર્યક્રમો આ પ્રકારની પ્રસ્તુત

989
00:48:57,120 --> 00:49:00,710
વિવિધ દ્રષ્ટિકોણથી પર બતાવવા માટે માર્ગ
કેવી રીતે તે જેવી સર્વરો ડિઝાઇન.

990
00:49:00,710 --> 00:49:08,300
હું તેથી જો હવે પછી ચલાવી રહ્યા હોય, અને
આ ફરીથી, હું બે પ્રક્રિયા ID ને મળ્યો હતો.

991
00:49:08,300 --> 00:49:10,320
>> આપણે માત્ર વિશે વાત કરો
વસ્તુઓ માટે નિર્દેશ કરે છે.

992
00:49:10,320 --> 00:49:11,980
તેથી તેઓ વધતી જતી છો નોટિસ.

993
00:49:11,980 --> 00:49:12,700
તે ઠંડી છે.

994
00:49:12,700 --> 00:49:15,140
તે પહેલાં 27.122 હતું.

995
00:49:15,140 --> 00:49:18,580
પરંતુ નોટિસ હવે, તેઓ પાછા આવ્યા
પર લગભગ આ જ સમયે.

996
00:49:18,580 --> 00:49:23,960
>> અને હવે, આ બોલ પર કોઈ પ્રશ્ન વિશે પૂછો
શા માટે તે હોય, જેનું કામ છે કે હતી

997
00:49:23,960 --> 00:49:27,590
તે પ્રકારના આ વસ્તુઓ બનાવવા માટે હવે હતી
પ્રકારની દરેક સાથે વાજબી રમવા

998
00:49:27,590 --> 00:49:31,350
અન્ય, આ બે આવૃત્તિઓમાંથી
હું ચાલી હતી કે કોઈ સ્લેશ ગપ મારવી 45

999
00:49:31,350 --> 00:49:32,880
અથવા તે નોડ ચાલી હતી?

1000
00:49:32,880 --> 00:49:36,940
જેવું તે વાજબી છે કે જે બનાવે તેઓ બંને
પ્રકારની રન સમય સંતુલિત વિચાર?

1001
00:49:36,940 --> 00:49:42,900

1002
00:49:42,900 --> 00:49:44,220
>> પ્રેક્ષક: [અશ્રાવ્ય].

1003
00:49:44,220 --> 00:49:44,620
>> કેપી સ્ચમિડ: અરે વાહ.

1004
00:49:44,620 --> 00:49:49,740
તેથી સામાન્ય રીતે, હું કોઈ સ્લેશ ગપ મારવી કરી ત્યારે
45 અથવા તે કંઈક છે, હવે તે છે

1005
00:49:49,740 --> 00:49:53,750
પ્રકારની કરવા માટે ઓપરેટિંગ સિસ્ટમ પર છે
તે કાર્યક્રમોની રનટાઈમ હાથ ધરે છે.

1006
00:49:53,750 --> 00:49:56,920
અને હવે તે તેમને સુનિશ્ચિત કરી શકો છો
વિવિધ સીપીયુ અથવા તેના પર

1007
00:49:56,920 --> 00:49:58,330
તેમને સુનિશ્ચિત કરી શકો છો.

1008
00:49:58,330 --> 00:50:01,870
તે એક છે કે જે સમય હાથીઓને કરી શકો છો
સીપીયુ તેઓ વિચાર કે તે નહીં અથવા

1009
00:50:01,870 --> 00:50:03,330
એક CPU પર ચલાવવા માટે.

1010
00:50:03,330 --> 00:50:05,620
જેથી કે પાછળ વિચાર છે.

1011
00:50:05,620 --> 00:50:07,220
કે દરેકને અર્થમાં છે?

1012
00:50:07,220 --> 00:50:10,950
તેથી હવે નોડ ખરેખર એક રમી નથી
આ ક્રિયાઓ સુધી વિભાજન ભાગ.

1013
00:50:10,950 --> 00:50:12,200
બરાબર.

1014
00:50:12,200 --> 00:50:14,050

1015
00:50:14,050 --> 00:50:17,840
>> જેથી લગભગ તે ઉદાહરણ માટે છે.

1016
00:50:17,840 --> 00:50:23,370
હું માત્ર એક વધુ વસ્તુ બતાવવા માગે છે
આ એક ઘણો અત્યાર સુધી કરવામાં આવ્યો છે કારણ કે

1017
00:50:23,370 --> 00:50:27,350
તદ્દન સુપર વ્યવહારુ નથી
કેટલાક કિસ્સાઓમાં.

1018
00:50:27,350 --> 00:50:30,970
હું આ પછી ઘરે આવતા કલ્પના કરી શકો છો
વાત અને કંઈક અને જેમ કહ્યું,

1019
00:50:30,970 --> 00:50:35,710
સાથે સાથે હું પ્રકારની છે કે ચર્ચા બહાર મળ્યું કે
હું માટે ફિબોનાકી સર્વર કરી શકો છો

1020
00:50:35,710 --> 00:50:37,360
મારા અંતિમ પ્રોજેક્ટ છે.

1021
00:50:37,360 --> 00:50:40,770
તેથી અહીં માત્ર સૉર્ટ વધુ એક ઉદાહરણ છે
કે આસ્થાપૂર્વક હશે -

1022
00:50:40,770 --> 00:50:44,620
કદાચ નથી, પરંતુ કદાચ - થોડી વધુ
જેવું અંતિમ પ્રોજેક્ટ સાથે સંબંધિત અને

1023
00:50:44,620 --> 00:50:46,440
તે જેવી વસ્તુઓ માટે આગળ વિચારી.

1024
00:50:46,440 --> 00:50:48,870
>> તેથી આ chat.js. છે

1025
00:50:48,870 --> 00:50:52,290
તેથી આ પ્રકારની કેટલીક ઉદાહરણ ગમે છે
તમે ઉપયોગ કરી શકે છે તે સર્વર બાજુ કોડ

1026
00:50:52,290 --> 00:50:55,700
નાના ચેટ સર્વર જેવા સેટ
તમે પર જોઇ શકે છે

1027
00:50:55,700 --> 00:50:56,630
ફેસબુક ચેટ કરો અથવા જે.

1028
00:50:56,630 --> 00:50:59,990
તેથી હું આ ફેસબુક જેવી છે કહી રહ્યો છું
ચેટ કરો, પરંતુ આ પ્રકારની છે

1029
00:50:59,990 --> 00:51:06,230
કદાચ કદાચ સારી નથી, પરંતુ - એક સારા જેવી
સારા - ચેટ માટે શરૂ બિંદુ

1030
00:51:06,230 --> 00:51:08,560
તમારી વેબસાઇટ માટે સર્વર
અંતિમ પ્રોજેક્ટ માટે.

1031
00:51:08,560 --> 00:51:11,040
તેથી આપણે તે શું કરી રહ્યો છે જુઓ.

1032
00:51:11,040 --> 00:51:15,500
>> તેથી અમે આ ખાસ વસ્તુ મળી રહ્યાં
ટોચ પર, આ એસઆઇઓ var

1033
00:51:15,500 --> 00:51:17,050
Socket.IO જરૂર સમકક્ષ હોય છે.

1034
00:51:17,050 --> 00:51:20,280
તેથી આ તેમ ન હોય કે અન્ય વસ્તુ છે
ખરેખર સાથે બનીને આવે છે

1035
00:51:20,280 --> 00:51:22,300
નોડ પરંતુ તમે તેને સ્થાપિત કરી શકો છો.

1036
00:51:22,300 --> 00:51:23,480
તે નોડ મોડ્યુલ છે.

1037
00:51:23,480 --> 00:51:25,670
તેથી તે માત્ર કેટલાક જેવું છે
નોડ માટે એક્સટેન્શન.

1038
00:51:25,670 --> 00:51:29,220
>> SocketIO ખરેખર ખરેખર છે
ઠંડી કાઇન્ડ.

1039
00:51:29,220 --> 00:51:32,550
તે મૂળભૂત રીતે શું કલ્પનાના છે
તે છે તે માટે પરવાનગી આપે છે છે

1040
00:51:32,550 --> 00:51:35,770
સંચાર આ પ્રવાહ છે
વેબ વચ્ચે

1041
00:51:35,770 --> 00:51:39,430
બ્રાઉઝર અને વેબ સર્વર.

1042
00:51:39,430 --> 00:51:45,250
તેથી અત્યાર સુધી સૌથી ભાગ માટે, અમે કર્યું છે
આ ખૂબ જ ઝડપી એક બીજા કે બે

1043
00:51:45,250 --> 00:51:48,790
વેબ વચ્ચે બીજા સંચાર
બ્રાઉઝર અને વેબ સર્વર.

1044
00:51:48,790 --> 00:51:53,310
તેથી તે વાસ્તવમાં google.com, વિચાર પર જાઓ છે
સામગ્રી, પછી તે પાછી મોકલી છે, અને

1045
00:51:53,310 --> 00:51:53,770
અમે પૂર્ણ કરી લીધું.

1046
00:51:53,770 --> 00:51:56,560
અમે ત્યાં સુધી ફરીથી વાત ક્યારેય રહ્યાં છો તે
વપરાશકર્તા પ્રકારો બીજું કંઈક.

1047
00:51:56,560 --> 00:52:01,090
>> પરંતુ Socket.IO અને સમાન પ્રકારની
વસ્તુઓ - અને SocketIO ખરેખર છે

1048
00:52:01,090 --> 00:52:03,940
પ્રમાણે બાંધવામાં આવે છે કે જે વસ્તુઓ
WebSocket જે પ્રકારના ઉપલબ્ધ છે

1049
00:52:03,940 --> 00:52:06,440
HTML5 ભાગ તરીકે -

1050
00:52:06,440 --> 00:52:09,620
કે તમે આ માટે પરવાનગી આપે છે
ચાલુ સંવાદ.

1051
00:52:09,620 --> 00:52:13,990
અને આ ચેટ સર્વર માં ખૂબ જ ઉપયોગી છે
વસ્તુ પ્રકારની છે કારણ કે

1052
00:52:13,990 --> 00:52:17,390
પ્રકારની માં ચાલુ સંવાદ જેવી
કેટલીક રીતે કારણ કે તમે ચેટિંગ કરી રહ્યાં છો

1053
00:52:17,390 --> 00:52:21,540
કોઈકને સાથે, તમે હવે માત્ર એક મોકલી શકો છો
પછી પાઇપ નીચે સંદેશ, અને

1054
00:52:21,540 --> 00:52:23,940
સર્વર ડાઉન સંદેશ મોકલી શકો છો
તમે અન્ય વ્યક્તિને પાઇપ

1055
00:52:23,940 --> 00:52:24,520
સાથે ચેટિંગ.

1056
00:52:24,520 --> 00:52:26,903
અને પછી તમે આ કરી શકો છો
જેમ બદલે છે.

1057
00:52:26,903 --> 00:52:30,590

1058
00:52:30,590 --> 00:52:32,850
>> જેથી શું પ્રકારની છે
SocketIO માટે સારો છે.

1059
00:52:32,850 --> 00:52:38,400
SocketIO WebSockets ઉપયોગ કરે છે કારણ
એક વસ્તુ છે કે માં

1060
00:52:38,400 --> 00:52:43,980
માત્ર સાદા જૂના WebSockets ઉપરાંત,
તે મૂળભૂત રીતે કેટલાક યુક્તિઓ કરે

1061
00:52:43,980 --> 00:52:45,610
તે બ્રાઉઝર સુસંગત બનાવે છે.

1062
00:52:45,610 --> 00:52:50,040
ઈન્ટરનેટ એક્સપ્લોરર જેવા તેથી બ્રાઉઝર્સ
કમનસીબે WebSockets આધાર આપતા નથી

1063
00:52:50,040 --> 00:52:50,810
જમણી બોક્સની બહાર.

1064
00:52:50,810 --> 00:52:55,290
તેથી તે ઠંડી સુઘડ કેટલાક અન્ય પ્રકારની વાપરે
પરવાનગી આપવા માટે એડોબ ફ્લેશ સાથે વસ્તુઓ

1065
00:52:55,290 --> 00:52:57,170
તમે ક્રોસ બ્રાઉઝર ટેકો છે.

1066
00:52:57,170 --> 00:52:58,800
તેથી તે ખરેખર ઉપયોગી છે.

1067
00:52:58,800 --> 00:53:02,440
>> અને ખરેખર, હું હું પ્રકારની છું ખબર
અહીં સમય પર ચાલી રહ્યું છે, પરંતુ CS50

1068
00:53:02,440 --> 00:53:08,490
ચર્ચા, તમે ક્યારેય કંઈક જોઈ હોય
જેમ, મને ખબર નથી, ખાલી જેથી અને તેથી છે

1069
00:53:08,490 --> 00:53:11,030
આ પોસ્ટ કે કંઈક જવાબ આપવાનો
જેમ કે, લક્ષણ?

1070
00:53:11,030 --> 00:53:12,250
કે SocketIO છે.

1071
00:53:12,250 --> 00:53:15,580
તેથી કોઈકને ટાઇપ શરૂ થાય છે જ્યારે
એક જવાબ કે બનાવવા માટે બોક્સ ચર્ચા

1072
00:53:15,580 --> 00:53:20,040
કંઈક, તમારા બ્રાઉઝર શું છે
SocketIO બોલાવવામાં અમુક પ્રકારની બહાર કાઢે છે

1073
00:53:20,040 --> 00:53:22,660
કોઈકને છે કહે છે કે ઘટના
આ પોસ્ટ સાથે જવાબ આપો.

1074
00:53:22,660 --> 00:53:26,110
>> પછી સર્વર, બરાબર કહે છે
હું શું કરવા છે?

1075
00:53:26,110 --> 00:53:29,270
વેલ હવે હું તે અન્ય ગાય્ઝ કહેવું છે
જે CS50 પર છે જોઈ ચર્ચા

1076
00:53:29,270 --> 00:53:31,170
આ પોસ્ટ પર કોઈકને જવાબ આપવાનો છે.

1077
00:53:31,170 --> 00:53:34,190
જેથી SocketIO શું પ્રકારની છે
સતત પ્રકારની માટે સારી

1078
00:53:34,190 --> 00:53:35,930
સંવાદ સ્ટ્રીમ.

1079
00:53:35,930 --> 00:53:37,250
બરાબર.

1080
00:53:37,250 --> 00:53:40,060
>> તેથી હું અહીં શું છે - અને આપણે માત્ર છો
જોડાણો એરે અવગણો જાઉં

1081
00:53:40,060 --> 00:53:41,390
થોડો માટે -

1082
00:53:41,390 --> 00:53:43,080
હું શું હું અન્ય સાંભળવા માટે નથી છે.

1083
00:53:43,080 --> 00:53:46,880
જેથી માત્ર Socket.IO જે રીતે છે
ચાલો આ પોર્ટ પર સાંભળવા દો કહેતા.

1084
00:53:46,880 --> 00:53:50,060
અને પછી હું જોડાણ પર આવું.

1085
00:53:50,060 --> 00:53:53,360
જેથી માત્ર મૂળભૂત સોકેટ IO માતાનો છે
અમે પ્રાપ્ત છે, કહેતા રીતે

1086
00:53:53,360 --> 00:53:55,840
કનેક્શન, હું તમે કરવા માંગો છો
આ કોડ ચલાવો.

1087
00:53:55,840 --> 00:53:59,870
>> અને તેની જગ્યાએ REC કર્યા નોંધ્યું છે કે
અને ત્યાં પસાર અનામત બાદ કરતા હું સોકેટ છે.

1088
00:53:59,870 --> 00:54:03,260
અને આ સોકેટ વિચાર મૂળભૂત રીતે આ છે
તમે લખી અને વાંચી શકે છે તે વસ્તુ

1089
00:54:03,260 --> 00:54:05,750
તે વપરાશકર્તાની છે
કદાચ સંદેશાઓ.

1090
00:54:05,750 --> 00:54:10,700
અને તમે મોકલી શકે છે કે સંદેશાઓ
કે સોકેટ દ્વારા જઈ શકે છે.

1091
00:54:10,700 --> 00:54:12,140
કે અર્થમાં છે?

1092
00:54:12,140 --> 00:54:14,490
તેથી તે સતત વાત છે.

1093
00:54:14,490 --> 00:54:17,820
>> તેથી હું શું હું Socket.emit કહી છે.

1094
00:54:17,820 --> 00:54:20,330
અને પ્રદાન ખૂબ લે
ખૂબ બે દલીલો.

1095
00:54:20,330 --> 00:54:24,100
પ્રથમ દલીલ શબ્દમાળા છે
માત્ર પ્રકારની રજૂ

1096
00:54:24,100 --> 00:54:25,270
તમે સ્ત્રાવ રહ્યાં છો વસ્તુ.

1097
00:54:25,270 --> 00:54:28,120
તેથી આ કિસ્સામાં, હું ઉપયોગ કર્યો છે
આ શબ્દમાળા નવો સંદેશ.

1098
00:54:28,120 --> 00:54:32,670
અને તે માત્ર મૂળભૂત રીતે કહે છે કે
હું છું શું આ વસ્તુ પ્રકાર,

1099
00:54:32,670 --> 00:54:34,750
મોકલવા, નવી સંદેશ છે.

1100
00:54:34,750 --> 00:54:38,460
તેથી જો તમે ચોક્કસ પ્રકારો માટે સાંભળવા કરી શકો છો
નવો સંદેશ અથવા જે જેમ

1101
00:54:38,460 --> 00:54:39,960
કોઈ પર ઉપયોગ કરીને.

1102
00:54:39,960 --> 00:54:44,570
>> તેથી જોડાણ અને વપરાશકર્તા હોય, ત્યાં મોકલવામાં
તમે, અમે કોઈ પર ફોન કરો જ્યાં જુઓ

1103
00:54:44,570 --> 00:54:48,150
તે દર્શાવે છે અન્ય શબ્દમાળાઓ છે
વપરાશકર્તા સંદેશા પ્રકાર.

1104
00:54:48,150 --> 00:54:52,060
આવા પ્રદાન કરી શકે છે મૂળભૂત છે
આ સંદેશ પ્રકારો છે, અને

1105
00:54:52,060 --> 00:54:55,520
પછી જવાબમાં કંઈક
આ સંદેશ પ્રકારના એક

1106
00:54:55,520 --> 00:54:57,640
>> તેથી હું આ નવો સંદેશ સ્ત્રાવ છું.

1107
00:54:57,640 --> 00:55:00,540
અમે connections.push અવગણો રહ્યા છીએ
એક બીજા માટે.

1108
00:55:00,540 --> 00:55:03,360
પરંતુ તે પછી હું Socket.on વપરાશકર્તા મોકલવામાં, કહે છે.

1109
00:55:03,360 --> 00:55:07,540
તેથી હવે તે આ એવો કિસ્સો છે, જ્યારે
વપરાશકર્તા મને એક સંદેશ મોકલે છે, હું માંગો છો

1110
00:55:07,540 --> 00:55:09,240
તમે આ કોડ ચલાવો.

1111
00:55:09,240 --> 00:55:12,080
નોટિસ અને કે કે અનામી કાર્ય
આ ચલ માં લઈ રહ્યું છે

1112
00:55:12,080 --> 00:55:16,300
મૂળભૂત રીતે ચાલે છે જે માહિતી તરીકે ઓળખાય
વપરાશકર્તા સંદેશો હોય.

1113
00:55:16,300 --> 00:55:20,700
>> વિશે ચર્ચા તેથી હવે આપણે દો પ્રકારની
જોડાણો પણ દર્શાવે છે.

1114
00:55:20,700 --> 00:55:24,590
તેથી આ ચેટ ક્લાઈન્ટ માટે રચાયેલ છે
મૂળભૂત રીતે બધાને પ્રકારની છે જ્યાં

1115
00:55:24,590 --> 00:55:25,950
એ જ ચેટ રૂમ.

1116
00:55:25,950 --> 00:55:29,640
તેથી સામાન્ય રીતે, અમે શું રાખવા જરૂર
આસપાસનો એરે કે મૂળભૂત રીતે

1117
00:55:29,640 --> 00:55:33,170
માં ગપસપ બધા લોકો રજૂ
કેટલીક રીતે, જો તે અર્થમાં બનાવે.

1118
00:55:33,170 --> 00:55:33,340
અધિકાર?

1119
00:55:33,340 --> 00:55:37,190
અમે તે ગાય્સ જે જાણવાની જરૂર છે કારણ કે
તેથી અમે તેમને સંદેશાઓ મોકલી શકો છો છે

1120
00:55:37,190 --> 00:55:39,140
કે અન્ય લોકો અમને મોકલો.

1121
00:55:39,140 --> 00:55:44,440
>> તેથી શું આ કોડ કરે જ્યારે વપરાશકર્તા છે
સંદેશ મોકલે છે - પ્રકાર કે છે

1122
00:55:44,440 --> 00:55:45,300
આ ઘટના -

1123
00:55:45,300 --> 00:55:47,120
અમે આ કોડ સ્કોર રહ્યા છીએ.

1124
00:55:47,120 --> 00:55:51,240
અને અમે શું છે અમે આ દ્વારા ચલાવવામાં આવે છે
અમે જોડાણો કહે છે કે દર્શાવે છે.

1125
00:55:51,240 --> 00:55:54,390
અને દરેક જોડાણ માટે ખૂબ ખૂબ
અવર્સ છે કે જે એક સિવાય કે

1126
00:55:54,390 --> 00:55:59,520
આ કોડ શું કહે છે, અમે એક નવી મોકલો
કે જોડાયેલ સંદેશ સંદેશ

1127
00:55:59,520 --> 00:56:01,210
જાણકારી.

1128
00:56:01,210 --> 00:56:04,880
>> તમે અહીં નોટિસ તેથી જો, હું શું કર્યું જ્યારે
વપરાશકર્તા ખરેખર નવી આવેલ

1129
00:56:04,880 --> 00:56:08,560
જોડાણ હું સાથે ઉમેર્યા છે છે
JavaScript.push પદ્ધતિ, આ છે

1130
00:56:08,560 --> 00:56:12,100
મૂળભૂત રીતે જેમ ઉમેરો કહેતા
એક કિંમત તરીકે કે સોકેટ

1131
00:56:12,100 --> 00:56:13,900
અમારા જોડાણો પણ દર્શાવે છે.

1132
00:56:13,900 --> 00:56:20,560
આ કોડ ચલાવે છે ત્યારે હવે, તે કરશે
તે ચોક્કસ વસ્તુઓ મોકલી

1133
00:56:20,560 --> 00:56:22,020
જોડાણો.

1134
00:56:22,020 --> 00:56:26,980
તેથી આ એક સારી શરૂ બિંદુ હોઇ શકે
ચેટ સર્વર બનાવવા માટે

1135
00:56:26,980 --> 00:56:28,250
અથવા કંઈક આવું.

1136
00:56:28,250 --> 00:56:33,315
>> અને ઠંડી વસ્તુ પ્રકાર છે કે
તમે જેવા માટે અહીં જુઓ અને તે કોડ

1137
00:56:33,315 --> 00:56:36,390
સ્રાવ બહાર કાઢે છે અને તે જેવી સામગ્રી જ છે
JavaScript કોડ કાઇન્ડ કે તમે છો

1138
00:56:36,390 --> 00:56:39,260
વાર્તાલાપ બ્રાઉઝરમાં લખો
સર્વર સાથે.

1139
00:56:39,260 --> 00:56:42,480
SocketIO પ્રકારની છે તેથી કે શા માટે
સુઘડ અને તે રીતે ઉપયોગી છે.

1140
00:56:42,480 --> 00:56:45,680

1141
00:56:45,680 --> 00:56:49,250
>> ઓહ અને માત્ર એક વધુ બાબત વાસ્તવિક ઝડપી.

1142
00:56:49,250 --> 00:56:55,970
એક CS50 અંતિમ પ્રોજેક્ટ ગયા વર્ષે આવી હતી
તે મૂળભૂત રીતે ચેટ અમલ

1143
00:56:55,970 --> 00:56:57,840
Node.js. માં સર્વર

1144
00:56:57,840 --> 00:57:01,350
હું તેને લાગે છે Harvardchats.org
પરંતુ હું નથી -

1145
00:57:01,350 --> 00:57:02,940
બરાબર.

1146
00:57:02,940 --> 00:57:06,190
હું URL છે શું ખાતરી નથી, પરંતુ
હું પછીથી કે મોકલી શકો છો.

1147
00:57:06,190 --> 00:57:09,260
પરંતુ તે પ્રકારની ઠંડી છે તે
તમે Node.js. સાથે કરી શકો છો

1148
00:57:09,260 --> 00:57:14,680
>> તેથી હું સામાન્ય રીતે, તમે ગાય્ઝ છે, આશા છે કે એક
Node.js ઉપયોગી છે શું સૂઝ

1149
00:57:14,680 --> 00:57:17,870
માટે અને તમે કેવી રીતે અરજી કરી શકે છે કદાચ
તમારી અંતિમ પ્રોજેક્ટ છે.

1150
00:57:17,870 --> 00:57:21,050
હું કેટલાક વધુ મોકલવા આવશે
આ સાથે સ્રોતો.

1151
00:57:21,050 --> 00:57:23,170
અને આગામી માટે આભાર.

1152
00:57:23,170 --> 00:57:23,610
આભાર.

1153
00:57:23,610 --> 00:57:27,168
>> [વધાવી]