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

2
00:00:05,900 --> 00:00:07,170
>> סם גרין: היי, כולם.

3
00:00:07,170 --> 00:00:08,640
ברוכים הבאים לסמינר שלנו.

4
00:00:08,640 --> 00:00:10,009
שמי סאם.

5
00:00:10,009 --> 00:00:11,050
יו זאבריסקי: אני יו.

6
00:00:11,050 --> 00:00:17,420
סם גרין: ואנחנו הולכים לדבר היום
על JavaScript ו- API האינטרנט אודיו.

7
00:00:17,420 --> 00:00:21,180
רק כדי לצאת לדרך, זה מתאר
סדר היום שלנו לסמינר.

8
00:00:21,180 --> 00:00:25,350
אנחנו הולכים להתחיל על ידי מדברים על
למה אתה צריך להיות מעוניין באינטרנט

9
00:00:25,350 --> 00:00:30,130
API אודיו, מדוע הוא JavaScript
השפה שאתה צריך בשביל זה,

10
00:00:30,130 --> 00:00:32,619
ולאחר מכן לדבר על JavaScript
essentials-- כך כמו,

11
00:00:32,619 --> 00:00:34,800
לך ללכת דרך חלק
יסודות של השפה,

12
00:00:34,800 --> 00:00:37,290
ולאחר מכן לדבר על
API שמע ברמה גבוהה.

13
00:00:37,290 --> 00:00:41,140
אז, יו ידבר על כמה
של שלבי ייצור אודיו

14
00:00:41,140 --> 00:00:45,509
ולאחר מכן הדגמה ברצף זה מדהים
פרויקט שבנה ולהראות לך את הקוד.

15
00:00:45,509 --> 00:00:48,050
ולאחר מכן, יהיה לנו זמן ל
שאלות בסוף לאנשים

16
00:00:48,050 --> 00:00:49,593
שנמצאים כאן גרים.

17
00:00:49,593 --> 00:00:50,540
>> יו זאבריסקי: מגניב.

18
00:00:50,540 --> 00:00:50,990
>> סם גרין: מגניב.

19
00:00:50,990 --> 00:00:51,383
>> יו זאבריסקי: מגניב.

20
00:00:51,383 --> 00:00:52,170
אני לגבות.

21
00:00:52,170 --> 00:00:54,960
>> סם גרין: אז, דברים הראשונים הראשון.

22
00:00:54,960 --> 00:00:57,840
אז אחד הדברים הגדולים
על אודי API האינטרנט

23
00:00:57,840 --> 00:01:00,480
הוא שאין להגדיר הנדרש.

24
00:01:00,480 --> 00:01:04,230
הוא מגיע מובנה ל
רוב הדפדפנים מודרניים,

25
00:01:04,230 --> 00:01:08,630
כולל כרום, אדג ', כל
חבורה של נוספות-- כל אלה

26
00:01:08,630 --> 00:01:12,650
חלקים גדולים של ש
אנשים משתמשים היום.

27
00:01:12,650 --> 00:01:14,807
אז אין הוא הקים,
מלבד פשוט מקבל

28
00:01:14,807 --> 00:01:16,890
שרת אינטרנט הולך, ל
לך להתחיל לעבוד

29
00:01:16,890 --> 00:01:18,420
בפרויקט שלך, וזה נהדר.

30
00:01:18,420 --> 00:01:21,500

31
00:01:21,500 --> 00:01:24,190
>> אנו ממליצים די
בכבדות שאתה מחשיב

32
00:01:24,190 --> 00:01:26,530
באמצעות Chrome ל
התפתחות האינטרנט JavaScript,

33
00:01:26,530 --> 00:01:30,260
רק בגלל שהמפתחים שלה
כלים הם באמת חזקים.

34
00:01:30,260 --> 00:01:33,220
כדוגמא רק את מה שאנחנו אומר
באומרו לפתוח את JavaScript שלך

35
00:01:33,220 --> 00:01:38,600
console-- אם אתה הולך ל- Chrome
ואתה מסתכל על כל דף אינטרנט,

36
00:01:38,600 --> 00:01:43,897
ואתה עזב לחץ
בדוק אלמנט, ולאחר מכן

37
00:01:43,897 --> 00:01:46,730
אתה הולך לנפתח הקטן הזה
ממש כאן ואתה לוחץ על קונסולה,

38
00:01:46,730 --> 00:01:50,660
תראה מה פותח מסתכל למעלה
הרבה כמו הפקודה ש

39
00:01:50,660 --> 00:01:53,720
ייתכן שיראה ב- Mac שלך, או בזיהוי.

40
00:01:53,720 --> 00:01:59,260
וסתם ככה, אנחנו יכולים
סוג פקודות כאן, כמו נקה,

41
00:01:59,260 --> 00:02:01,350
ופקודות אחרות כמו ש.

42
00:02:01,350 --> 00:02:04,267
אנחנו יכולים ליצור משתנים, כ
שנראה בהמשך ב- JavaScript.

43
00:02:04,267 --> 00:02:07,100
וכך כל דבר שאנחנו יכולים לעשות ב
JavaScript, אנחנו יכולים לעשות עם הקונסולה,

44
00:02:07,100 --> 00:02:11,430
וזה דרך סופר שימושי ל
להתחיל לשחק עם APIs

45
00:02:11,430 --> 00:02:15,760
ומקבל בנוח עם
JavaScript מייד את הבת.

46
00:02:15,760 --> 00:02:18,290
להגדיר לא נדרש,
וזה באמת נחמד.

47
00:02:18,290 --> 00:02:18,790
מגניב.

48
00:02:18,790 --> 00:02:22,064

49
00:02:22,064 --> 00:02:22,880
מדהים.

50
00:02:22,880 --> 00:02:24,780
>> אז רק עוד דבר אחד להוסיף.

51
00:02:24,780 --> 00:02:27,780
אם יש לך questions-- יש
רבים מכם שאינם כאן גרים,

52
00:02:27,780 --> 00:02:31,232
אל תהסס שלח us-- אלה
כתובות הדואר האלקטרוני שלנו.

53
00:02:31,232 --> 00:02:33,190
אם יש לך שאלות
אתה לא רוצה לשאול אותנו,

54
00:02:33,190 --> 00:02:36,160
כמו, אוי לי באג
בקוד שלי, או משהו

55
00:02:36,160 --> 00:02:39,270
זה קצת יותר ספציפי,
אולי גוגל זה ראשון.

56
00:02:39,270 --> 00:02:42,340
יש הרבה משאבים גדולים
על האינטרנט האודים API בחוץ.

57
00:02:42,340 --> 00:02:44,089
זה ממש טוב
מתועד וזה להיות

58
00:02:44,089 --> 00:02:47,194
בשימוש על ידי המון אנשים ב
תעשייה, ואנשים שהם פשוט

59
00:02:47,194 --> 00:02:48,610
בניית דברים כיפיים לעצמם.

60
00:02:48,610 --> 00:02:51,306
אז לא צריך להיות הרבה
משאבים בחוץ.

61
00:02:51,306 --> 00:02:53,040
מדהים.

62
00:02:53,040 --> 00:02:56,100
>> מגניב, אז למה אודי API האינטרנט?

63
00:02:56,100 --> 00:02:59,840
תרשים זה הוא קצת
של אבולוציה של הדרך

64
00:02:59,840 --> 00:03:04,100
קול באינטרנט גדל לאורך זמן.

65
00:03:04,100 --> 00:03:13,080
Bgsound היה כמו תג HTML המקורי
ש- Internet Explorer משמש לתמיכה.

66
00:03:13,080 --> 00:03:16,790
זה רק אפשר לצלילים די בסיסיים,
פונקציונלי לא היה חזק מאוד,

67
00:03:16,790 --> 00:03:19,380
ואתה לא יכול לעשות
רצף מסובך,

68
00:03:19,380 --> 00:03:21,890
או לשלוט כאשר הצליל התחיל
והפסיק מאוד וחסונה.

69
00:03:21,890 --> 00:03:23,930
אז, זה לא היה במיוחד
מפותח.

70
00:03:23,930 --> 00:03:27,470
ואז אחרי ש, פלאש
הגיע along-- ש,

71
00:03:27,470 --> 00:03:31,712
אני בטוח שאתם מכירים את כולם
עם Flash-- אולי לא איך זה עובד,

72
00:03:31,712 --> 00:03:32,920
אבל אתה כבר בוודאי ראית את זה.

73
00:03:32,920 --> 00:03:35,586
אתה חייב לעדכן את הפלאש שלך
Plug-in, כל סוג של חומר,

74
00:03:35,586 --> 00:03:40,110
וזה בהחלט הרחיב את הטווח
פונקציונליים שהיה זמין.

75
00:03:40,110 --> 00:03:45,370
אבל מה שהופך את המשתמש להתקין
התוספת היא בהחלט

76
00:03:45,370 --> 00:03:48,480
חסרון ל- Flash כולל
ביישום שלך, נכון?

77
00:03:48,480 --> 00:03:52,410
כי אז אתה תלוי ב
משתמשים הולכים ומציאת זו התוספת,

78
00:03:52,410 --> 00:03:54,660
וכנראה שהפך
את צעד הנוסף הזה

79
00:03:54,660 --> 00:03:56,640
הם צריכים לקחת להשתמש האפליקציה שלך.

80
00:03:56,640 --> 00:04:01,270
ואז יכול להיות שעדכון
שישבור כל הבקשה שלך,

81
00:04:01,270 --> 00:04:03,880
וזה בסופו להיות סיוט
עבור היזם, מדי.

82
00:04:03,880 --> 00:04:06,230
אז זה היה מתרס.

83
00:04:06,230 --> 00:04:10,480
>> ואז לאחר שהגיע יחד,
תג אודיו HTML, ש

84
00:04:10,480 --> 00:04:16,579
היא תכונה של HTML-- המודרני יותר ש
בהחלט מותר להרבה יותר דברים,

85
00:04:16,579 --> 00:04:20,050
אבל גם את הדברים שאתה יכול לעשות
שם היו קצת מוגבל רק

86
00:04:20,050 --> 00:04:22,730
כתוצאה מהדברים
HTML שהיה מסוגל.

87
00:04:22,730 --> 00:04:26,060
לכן, כאשר JavaScript
API, אודי API האינטרנט,

88
00:04:26,060 --> 00:04:29,290
הפכתי לסטנדרטי
להתאמן על פני דפדפנים,

89
00:04:29,290 --> 00:04:32,490
כי באמת הרחיב את הסט
הזדמנויות למפתחים

90
00:04:32,490 --> 00:04:36,590
באמת להיכנס לבניין
דברים מגניבים באינטרנט.

91
00:04:36,590 --> 00:04:39,220
במשך זמן רב יש לי
כלים ממש חזקים היה

92
00:04:39,220 --> 00:04:44,360
לילידי יישומי אודיו,
like-- כולם יודע GarageBand,

93
00:04:44,360 --> 00:04:48,360
ואז ברור שיש יותר
מקצועי יישומי אודיו ערבוב,

94
00:04:48,360 --> 00:04:49,640
וסוג כזה של דברים.

95
00:04:49,640 --> 00:04:52,690
אבל לא היה
Cloud-- ממש טוב לא

96
00:04:52,690 --> 00:04:55,811
ענן, כן, אני מניח ש
פלטפורמה מבוססת אינטרנט Cloud--

97
00:04:55,811 --> 00:04:58,310
שתאפשר למפתחים
לבנות יישומים עבור אנשים

98
00:04:58,310 --> 00:05:00,570
לעשות ערבוב אודיו.

99
00:05:00,570 --> 00:05:03,960
וכמו שהוא ייראה לך
מאוחר יותר, אודי API האינטרנט

100
00:05:03,960 --> 00:05:07,470
מאפשר לממש חזק
דברים לקרות באמת פשוט,

101
00:05:07,470 --> 00:05:09,597
וזה די מגניב.

102
00:05:09,597 --> 00:05:12,680
אז זה ההוראה למה אתה
צריך לראות את שאר הסמינר,

103
00:05:12,680 --> 00:05:14,350
באופן בסיסי.

104
00:05:14,350 --> 00:05:17,880
>> ועכשיו, אני הולך לדבר על
כמה אלמנטים בסיסיים רק JavaScript--

105
00:05:17,880 --> 00:05:20,240
של השפה, כך ש
אנחנו יכולים להיות באותו הדף

106
00:05:20,240 --> 00:05:22,470
כאשר אנו מדברים על
API קצת מאוחר יותר.

107
00:05:22,470 --> 00:05:23,260
מגניב.

108
00:05:23,260 --> 00:05:26,192
>> אז, זה סיכום.

109
00:05:26,192 --> 00:05:27,150
שכחתי שזה היה כאן.

110
00:05:27,150 --> 00:05:27,510
כֵּן.

111
00:05:27,510 --> 00:05:27,870
>> יו זאבריסקי: יש שתי שקופיות כאן.

112
00:05:27,870 --> 00:05:30,245
>> סם גרין: זה הסיכום
חלק מהמגבלות

113
00:05:30,245 --> 00:05:35,220
של שיטות מחייבות, ישנות האחרות.

114
00:05:35,220 --> 00:05:37,828
ואז עכשיו, יש לנו את הדברים האלה.

115
00:05:37,828 --> 00:05:40,011
מגניב.

116
00:05:40,011 --> 00:05:40,510
מדהים.

117
00:05:40,510 --> 00:05:43,200
>> אז, יסודות JavaScript.

118
00:05:43,200 --> 00:05:47,230
הדבר ראשון, יש
הבדל די משמעותי

119
00:05:47,230 --> 00:05:49,940
ב- JavaScript לעומת ב
שפה כמו C, בדרך

120
00:05:49,940 --> 00:05:52,050
שמשתנים נוצרים.

121
00:05:52,050 --> 00:05:55,634
אז ב- C, אנחנו רגילים לכך ש
להקליד המשתנים שלנו, נכון?

122
00:05:55,634 --> 00:05:57,800
ואני לא מתכוון סוג כמו
הקלד בהם, אני מתכוון סוג

123
00:05:57,800 --> 00:06:01,900
כמו להקצות להם משמעות type--
כמו, int, float, char.

124
00:06:01,900 --> 00:06:05,210
ב- C, שהיינו באמת משמש ל
צורך ליצור משתנים

125
00:06:05,210 --> 00:06:09,690
ואז להיצמד לסוג של
כל הזמן שאנו משתמשים בי משתנים ש.

126
00:06:09,690 --> 00:06:13,990
וזה לא בהכרח גרוע,
אבל זה כנראה יותר לשימוש.

127
00:06:13,990 --> 00:06:16,190
אחת התכונות מגניבים
של JavaScript הוא

128
00:06:16,190 --> 00:06:19,740
שמשתנים הם מה שנקרא
"מוקלד באופן דינמי", ש

129
00:06:19,740 --> 00:06:22,500
משמעות הדבר היא שאני יכול ליצור
משתנה עם תחביר ש,

130
00:06:22,500 --> 00:06:25,800
varX שווה 5, למשל.

131
00:06:25,800 --> 00:06:27,790
זה יוצר במקור
שלם variable--

132
00:06:27,790 --> 00:06:29,870
ממש מתחת ל
מכסה המנוע somewhere-- אבל אני

133
00:06:29,870 --> 00:06:33,040
יכול לשנות משתנה ש
כדי להתייחס למחרוזת

134
00:06:33,040 --> 00:06:35,820
בלי לעשות שום דבר כמו
יצירת משתנה חדש.

135
00:06:35,820 --> 00:06:37,880
אני לא צריך לדאוג
על שינוי הסוג.

136
00:06:37,880 --> 00:06:45,440
JavaScript יודע שהסוג של
השתנה, וזה קורה באופן דינמי.

137
00:06:45,440 --> 00:06:48,510
>> אז, יש יתרונות
וחסרונות ש,

138
00:06:48,510 --> 00:06:51,250
כמו כל מי שעבד ב
JavaScript לזמן אולי יודע.

139
00:06:51,250 --> 00:06:53,600
יש רגעים שבי
בטעות אתה עלול

140
00:06:53,600 --> 00:06:57,720
לשנות את הסוג של משתנה ו
לא להתמודד עם זה שינוי הסוג,

141
00:06:57,720 --> 00:07:01,120
ולאחר מכן JavaScript שלך
יכול crash-- או יוצא מן הכלל

142
00:07:01,120 --> 00:07:06,070
להיזרק, כי יהיה לך
סוג הלא נכון כאשר אתה מצפה מסוג אחד.

143
00:07:06,070 --> 00:07:07,040
מגניב.

144
00:07:07,040 --> 00:07:11,470
>> אז, scoping-- שזה כמו, אם
זוכר את השבועות הראשונים בקורס,

145
00:07:11,470 --> 00:07:15,420
מתייחס לאופן גלוי משתנה
הוא ומה בשטח של הקוד.

146
00:07:15,420 --> 00:07:18,400
כל זה נראה דומה מאוד
לאופן שבו נראה בג

147
00:07:18,400 --> 00:07:24,755
אז משתני scoped בדרך
בתוך סוגריים מסולסלים בתוך פונקציה,

148
00:07:24,755 --> 00:07:27,005
ואז יש גם
משתנים גלובליים-scoped ש

149
00:07:27,005 --> 00:07:29,171
הן-- אם אתה כותב משתנה
מחוץ לפונקציה,

150
00:07:29,171 --> 00:07:31,790
זה יהיה גלוי בטקסט כולו.

151
00:07:31,790 --> 00:07:35,840
>> הבדל אחד בין
JavaScript ו- C בפרט,

152
00:07:35,840 --> 00:07:40,280
הוא שאם אתה מצהיר עולמי
בכל מקום משתנה בקובץ טקסט

153
00:07:40,280 --> 00:07:43,324
זה נראה לעין בכל תפקיד
בתוך שקובץ הטקסט.

154
00:07:43,324 --> 00:07:44,240
זה נכון, נכון?

155
00:07:44,240 --> 00:07:46,330
>> יו זאבריסקי: כן.

156
00:07:46,330 --> 00:07:49,120
>> סם גרין: אז זה גם קצת
קצת פאנקי בהשוואה ל- C,

157
00:07:49,120 --> 00:07:52,660
שבו אנו תמיד היו צריכים להיות שלנו
הגדרות משתנים מעל המקומות

158
00:07:52,660 --> 00:07:53,770
הם היו בשימוש.

159
00:07:53,770 --> 00:07:57,957
זה לא שלטון זה נאכף
יותר, כך, קצת שונה.

160
00:07:57,957 --> 00:08:00,540
ושוב רק כדי להדגיש,
הגלובלי לעומת variables-- המקומי

161
00:08:00,540 --> 00:08:03,457
יש לך דומה מאוד לג יכול
שני משתנים בעלי אותו שם,

162
00:08:03,457 --> 00:08:06,540
ויש לי אחד מהשמות שלהם להיות מוצל
על ידי משתנה מקומי אם אחד מהם

163
00:08:06,540 --> 00:08:07,546
היה גלובלי.

164
00:08:07,546 --> 00:08:09,420
סוג אז, דומה של
בעיות שחלק מכם

165
00:08:09,420 --> 00:08:11,920
ייתכן שנתקל בכמה
הבעיה שלך קובע עד כה.

166
00:08:11,920 --> 00:08:14,450
מגניב, אז זה משתנה.

167
00:08:14,450 --> 00:08:20,310
>> בקרת זרימה, כלומר כמו,
אם-else-- stuff-- ולולאות הגיוניים.

168
00:08:20,310 --> 00:08:24,510
אז כדי להתחיל עם, זה מה אם-אחר
הצהרות נראות כמו ב- JavaScript.

169
00:08:24,510 --> 00:08:29,750
המיקום של הדברים השונים
על הקווים הוא לא חשוב.

170
00:08:29,750 --> 00:08:34,409
זהו רק אחד מהמוסכמות
לקוד מבנה שהדרך.

171
00:08:34,409 --> 00:08:38,634
בדיוק כמו ב- C, יש לנו
"אם," הצהרת סוגריים.

172
00:08:38,634 --> 00:08:40,840

173
00:08:40,840 --> 00:08:42,090
זה לא מה שהתכוונתי לעשות.

174
00:08:42,090 --> 00:08:44,860

175
00:08:44,860 --> 00:08:45,550
אני עשיתי את זה שוב.

176
00:08:45,550 --> 00:08:46,841
>> יו זאבריסקי: מנסה לצאת?

177
00:08:46,841 --> 00:08:49,770
סם גרין: לא, אני
רק מנסה להתקרב.

178
00:08:49,770 --> 00:08:50,660
זה לא משנה.

179
00:08:50,660 --> 00:08:54,730

180
00:08:54,730 --> 00:08:59,370
>> אז, יש לנו הצהרה "אם" ו
יש לנו מצב הפנימי שלו

181
00:08:59,370 --> 00:09:03,130
שמעריך לאמת או שקר,
ושקובע אם לא

182
00:09:03,130 --> 00:09:04,510
אנחנו נכנסים בלוק של קוד.

183
00:09:04,510 --> 00:09:09,860
וכן, יש לנו עוד-אם, ו
אחר, בדיוק כמו שאנחנו רגילים בג

184
00:09:09,860 --> 00:09:14,010
>> אתה גם צריך להיות די נוח
מייד את הבת עם לולאות,

185
00:09:14,010 --> 00:09:16,440
כי הם גם נראים
הרבה כמו C נראה.

186
00:09:16,440 --> 00:09:19,600
אבל תשימו לב שוב ש
יש לי, במקום int אתחולים,

187
00:09:19,600 --> 00:09:22,570
יש לנו אתחולי var.

188
00:09:22,570 --> 00:09:24,650
ואני מניח שיש לך
להיות זהיר לעשות

189
00:09:24,650 --> 00:09:28,460
בטוח שאתה לא לשנות את הערך
שלי מint למחרוזת,

190
00:09:28,460 --> 00:09:31,780
לדוגמא, כי זה הולך
לגרום להתנהגות מוזרה לא אולי

191
00:09:31,780 --> 00:09:32,280
לְצַפּוֹת.

192
00:09:32,280 --> 00:09:35,750
אבל זה צריך להיראות
די מוכר, כמו גם.

193
00:09:35,750 --> 00:09:39,460
>> אז זה המקום שבו דברים מתחילים
לקבל קצת משוגע בJavaScript

194
00:09:39,460 --> 00:09:44,920
למי שהולך מ
רקע של ג ישנן פונקציות

195
00:09:44,920 --> 00:09:48,070
ב- JavaScript, ויש דרך אחת
להכריז פונקציה שנראית

196
00:09:48,070 --> 00:09:50,361
סוג של דומה ל- C, ו
אז יש עוד אחד ש

197
00:09:50,361 --> 00:09:52,450
נראה סוג אחר של.

198
00:09:52,450 --> 00:09:54,930
>> הגרסה הראשונה,
שבו אנו יכולים לראות כאן,

199
00:09:54,930 --> 00:09:59,260
הוא סוג של C-כמו, בי
אנחנו אומרים, זה הוא פונקציה,

200
00:09:59,260 --> 00:10:01,490
לתת לו שם, לתת
מספר הטיעונים,

201
00:10:01,490 --> 00:10:05,150
ולאחר מכן את התוכן של הפונקציה
ללכת בתוך סוגריים מסולסלים אלה.

202
00:10:05,150 --> 00:10:08,850
אנחנו תראו דוגמא ל
טענות רק שני.

203
00:10:08,850 --> 00:10:13,420
>> ואילו בשורה הבאה, אנו רואים, אה,
הנה משתנה בשם "myFunction,"

204
00:10:13,420 --> 00:10:17,546
ואנחנו שווים את זה לזו
function-- thing-- הכללי ש

205
00:10:17,546 --> 00:10:19,170
לא נראה שיש משהו קורה.

206
00:10:19,170 --> 00:10:22,780

207
00:10:22,780 --> 00:10:26,080
הסיבה שזה שונה
מ C היא כי JavaScript

208
00:10:26,080 --> 00:10:30,040
הוא מה שנקרא בשפה פונקציונלית,
או שיש אלמנטים פונקציונליים, מה שאומר ש

209
00:10:30,040 --> 00:10:33,510
שפונקציות הן למעשה ערכים.

210
00:10:33,510 --> 00:10:39,520
וזה אומר שאנחנו יכולים להגדיר
משתנה שווה פונקציה

211
00:10:39,520 --> 00:10:43,210
ולאחר מכן להעביר את הפונקציה ש
מסביב, להעביר אותו כטיעון,

212
00:10:43,210 --> 00:10:46,550
לעשות כל מיני דברים
כמו שעם פונקציות.

213
00:10:46,550 --> 00:10:49,682
>> דבר אחד לnote--
פונקציות נכתבות

214
00:10:49,682 --> 00:10:51,140
עם מספר מסוים של טיעונים.

215
00:10:51,140 --> 00:10:54,056
אנחנו תראו דוגמא לפונקציה
עם טיעון בשקופית הבאה.

216
00:10:54,056 --> 00:10:56,720
אבל JavaScript לא יהיה
צועק עליך אם תנסה

217
00:10:56,720 --> 00:10:59,330
להשתמש בפונקציה עם
מספר הלא נכון של טיעונים.

218
00:10:59,330 --> 00:11:05,310
זה פשוט יעשה כמיטב יכולתה כדי להפוך את
לעשות, כלומר, אם אתה עובר,

219
00:11:05,310 --> 00:11:09,410
אתה קורא לפונקציה שמצפה
ויכוח עם טענה לא, כל מה ש

220
00:11:09,410 --> 00:11:13,990
יקרה שזה יעשה כמיטב יכולתה
כדי לנסות ולבצע קוד ש,

221
00:11:13,990 --> 00:11:16,541
ואם זה סופו של דבר פועל
לחריג או שגיאה,

222
00:11:16,541 --> 00:11:19,790
זה יהיה לזרוק חריג ושרק לשמור
going-- שהוא רק אחת הדרכים

223
00:11:19,790 --> 00:11:21,070
כי JavaScript עובד.

224
00:11:21,070 --> 00:11:21,781
כֵּן.

225
00:11:21,781 --> 00:11:24,207
>> קהל: מה קורה אם
יש טענות רבות מדי?

226
00:11:24,207 --> 00:11:26,040
סם גרין: אז
השאלה הייתה, מה שקורה

227
00:11:26,040 --> 00:11:27,380
אם יש ויכוחים רבים מדי?

228
00:11:27,380 --> 00:11:29,171
והתשובה היא ש
רק JavaScript יהיה

229
00:11:29,171 --> 00:11:32,120
להתעלם מאלה ש
אחרי אלה היא מצפה.

230
00:11:32,120 --> 00:11:36,420
זה ינסה לבצע את הפונקציה
קורא כאילו זה היה רק ​​שני הראשונים.

231
00:11:36,420 --> 00:11:37,075
יָמִינָה?

232
00:11:37,075 --> 00:11:37,700
>> יו זאבריסקי: נכון, כן.

233
00:11:37,700 --> 00:11:39,449
באופן דומה, אם יש
מעט מדי ויכוחים,

234
00:11:39,449 --> 00:11:42,640
זה פשוט סוג של נותן null לכל
טענות שאין לה כל ערכים

235
00:11:42,640 --> 00:11:43,660
בשביל ש.

236
00:11:43,660 --> 00:11:45,810
>> סם גרין: אשר יכול
למעשה להיות שימושי, אם אתה

237
00:11:45,810 --> 00:11:49,060
רוצה לכתוב פונקציה ש
לוקח טיעוני מספר משתנים.

238
00:11:49,060 --> 00:11:55,830
באפשרותך להגדיר ערכי ברירת מחדל ב
ההגדרה של הפונקציה,

239
00:11:55,830 --> 00:11:59,060
וזה יכול להתעלם מהעובדה
שהקלט לא שם.

240
00:11:59,060 --> 00:12:01,584

241
00:12:01,584 --> 00:12:04,000
אז אני רוצה לדבר קצת
עוד על הכדור האחרון זה

242
00:12:04,000 --> 00:12:05,541
נקודה, שהוא פונקציות הן ערכים.

243
00:12:05,541 --> 00:12:07,930

244
00:12:07,930 --> 00:12:11,010
זוהי דוגמה שהיא
פיצוצים קצת

245
00:12:11,010 --> 00:12:14,880
אם אתה רק לקרוא אותו, ולא חושב ש
על מה שקורה לשנייה.

246
00:12:14,880 --> 00:12:17,910
אז, בואו נסתכל רק ב
הקו הראשון כאן.

247
00:12:17,910 --> 00:12:24,360
יש לנו משתנה, F1 זה, שאנחנו אומרים
היא פונקציה שעושה את הדבר הזה.

248
00:12:24,360 --> 00:12:28,535
ואת התוכן של הפונקציה
הם console.log ('שלום').

249
00:12:28,535 --> 00:12:32,220
אתה יכול לחשוב על console.log כ
שווה ערך JavaScript של printf.

250
00:12:32,220 --> 00:12:35,510
אז מה שיקרה הוא, אם
להפעיל קוד זה בדפדפן שלנו,

251
00:12:35,510 --> 00:12:37,530
זה יהיה להדפיס את מחרוזת.

252
00:12:37,530 --> 00:12:39,342
אני יכול להוכיח את זה.

253
00:12:39,342 --> 00:12:42,300
קהל: ביומן, אם כי, עושה את זה
אומר שזה שנרשם איפשהו?

254
00:12:42,300 --> 00:12:42,550
סם גרין: כן.

255
00:12:42,550 --> 00:12:44,216
אז אני אראה לך מה הולך לקרות.

256
00:12:44,216 --> 00:12:48,085
אז השאלה הייתה, מה יומן מתכוון?

257
00:12:48,085 --> 00:12:51,262
>> יו זאבריסקי: אז console.log
כמו printf לג

258
00:12:51,262 --> 00:12:52,970
סם גרין: אז console.log
כמו printf,

259
00:12:52,970 --> 00:12:59,240
כך שאם יש לי console.log זה ('שלום'),
ואני קורא לזה, את המחרוזת "שלום"

260
00:12:59,240 --> 00:13:00,730
מקבל הדפיס לקונסולה.

261
00:13:00,730 --> 00:13:03,340
זה הקונסולה.

262
00:13:03,340 --> 00:13:05,930
זה בדיוק כמו printf, בי
היא מדפיסה להחוצה סטנדרטית.

263
00:13:05,930 --> 00:13:09,050

264
00:13:09,050 --> 00:13:11,230
ואנו רואים בדקה,
אבל זה בעצם

265
00:13:11,230 --> 00:13:16,529
בהתייחסו לאובייקט הקונסולה,
וקורא שיטה על אובייקט ש.

266
00:13:16,529 --> 00:13:18,320
זה יהיה הגיוני יותר
בדקה כשאנחנו

267
00:13:18,320 --> 00:13:20,660
להגיע למדברים על
אובייקטים ב- JavaScript,

268
00:13:20,660 --> 00:13:22,509
אבל חשבתי שמזכיר בדיוק את זה.

269
00:13:22,509 --> 00:13:24,300
יו זאבריסקי: אנחנו
נהגתי בC, right--

270
00:13:24,300 --> 00:13:27,580
אנחנו בדרך כלל לכתוב תכנית גדולה
בעיקרי לעשות שום דבר.

271
00:13:27,580 --> 00:13:30,700
אבל מה זה מגניב ב- JavaScript הוא
יש לי של מתורגמן סוג זה ש

272
00:13:30,700 --> 00:13:33,620
ריצות בזמן אמת, כך ש
לוקח רק שורה אחרת שורה,

273
00:13:33,620 --> 00:13:35,320
זה רק יכול לפרש שעל המקום.

274
00:13:35,320 --> 00:13:37,403
וזה עוקב אחר
דברים שיש להפעיל לפני,

275
00:13:37,403 --> 00:13:41,620
כך שזה כלי די שימושי ל
להשתמש console.log, או הקונסולה,

276
00:13:41,620 --> 00:13:46,870
בדרך כלל, רק משחק
סביב עם JavaScript.

277
00:13:46,870 --> 00:13:51,420
>> סם גרין: אז לחזור לזה
example-- הקו השני של קוד

278
00:13:51,420 --> 00:13:55,320
כאן הוא מזעזע את הנפש די לי בראש.

279
00:13:55,320 --> 00:13:59,790
בפעם הראשונה שקראתי את זה,
זה היה כמו, מה קורה?

280
00:13:59,790 --> 00:14:04,580
אז מה שקורה הוא, זה
הצהרת פונקציה אומרת,

281
00:14:04,580 --> 00:14:10,170
יש לי F2 פונקציה שנקראת
שמצפה טיעון אחד, ו,

282
00:14:10,170 --> 00:14:12,990
ואז זה קורא ש
פונקציה, F, ש

283
00:14:12,990 --> 00:14:17,652
עבר אליו כטיעון
ללא ויכוחים עצמו.

284
00:14:17,652 --> 00:14:19,110
אז, שאולי היה מבלבל.

285
00:14:19,110 --> 00:14:21,890

286
00:14:21,890 --> 00:14:28,400
אם אנחנו מבינים את זה כf2 לוקח F1
כטיעון, ולאחר מכן בתוך F2,

287
00:14:28,400 --> 00:14:31,190
ו מקבל נקרא-- שאמצעים
כי הקו הזה של קוד,

288
00:14:31,190 --> 00:14:34,192
אחרי שתי שורות של אלה
קוד, תוצאות ב" שלום "

289
00:14:34,192 --> 00:14:35,400
מודפס לקונסולה.

290
00:14:35,400 --> 00:14:41,660

291
00:14:41,660 --> 00:14:44,910
>> העובדה שאנחנו יכולים לעבור
פונקציות סביב ערכים

292
00:14:44,910 --> 00:14:47,870
בסופו להיות אחד מביותר
תכונות רבות עוצמה של JavaScript

293
00:14:47,870 --> 00:14:49,700
כשפת תכנות.

294
00:14:49,700 --> 00:14:52,782
מחוץ לכל
דברים מדהים שהוא יכול לעשות,

295
00:14:52,782 --> 00:14:54,990
רק כתכונה של
שפה במונחים של הדרך

296
00:14:54,990 --> 00:14:58,400
כי זה עושה את הדברים קלים
לתכנת ומאפשר

297
00:14:58,400 --> 00:15:01,060
לדברים שהם לא במיוחד
מתאים היטב לאינטרנט,

298
00:15:01,060 --> 00:15:04,500
תכנות ופונקציונלי תפקודיים
היבטי תכנות של JavaScript

299
00:15:04,500 --> 00:15:07,130
הוא אחד ביותר
מושגים רבי עוצמה ש

300
00:15:07,130 --> 00:15:11,030
קיים בJavaScript-- אם אתה שואל אותי.

301
00:15:11,030 --> 00:15:11,960
מגניב.

302
00:15:11,960 --> 00:15:13,534
>> אז, הדבר הבא.

303
00:15:13,534 --> 00:15:16,450
בנוסף להיות תפקודי,
יש גם אלמנטים של JavaScript

304
00:15:16,450 --> 00:15:20,510
שמונחים עצמים,
שהוא אחד מאוד

305
00:15:20,510 --> 00:15:23,800
מילים באז פופולריות במדעי מחשב.

306
00:15:23,800 --> 00:15:27,040
תכנות מונחה עצמים
זה דבר ממש פופולרי.

307
00:15:27,040 --> 00:15:34,210
יש JavaScript גרסה של ש,
שבו אני מאמין שכל ערך הוא גם

308
00:15:34,210 --> 00:15:41,475
אובייקט, מה שאומר שכל אובייקט
עוטף יחד כמה מספר הערכים.

309
00:15:41,475 --> 00:15:44,020

310
00:15:44,020 --> 00:15:49,750
אז לערכים שהם פשוטים, כמו
מספר שלם, כמו varX שווה 5,

311
00:15:49,750 --> 00:15:52,250
אובייקט שרק עוטף שערך אחד.

312
00:15:52,250 --> 00:15:54,760

313
00:15:54,760 --> 00:15:59,036
>> אבל אנחנו גם יכולים לדמיין מצב ש
where-- אנחנו יכולים לחשוב על מצבים בC

314
00:15:59,036 --> 00:16:00,910
שבו אנחנו רוצים לעשות
משהו עם structs,

315
00:16:00,910 --> 00:16:03,285
לדוגמא, שעוטף כמה
ערכים ביחד ועושה

316
00:16:03,285 --> 00:16:05,870
זה באמת קל לעבור דברים מסביב.

317
00:16:05,870 --> 00:16:09,270
זה היה רגע שאובייקט הוא ב- JavaScript.

318
00:16:09,270 --> 00:16:12,340
>> זה חשוב לזכור
כשאני אומר שאובייקטים עטופים

319
00:16:12,340 --> 00:16:15,330
כמה מספר הערכים יחד,
שפונקציות גם

320
00:16:15,330 --> 00:16:21,506
ערכים, מה שאומר שפונקציות יכולים
גם להיות בתוך אובייקט JavaScript.

321
00:16:21,506 --> 00:16:26,910
והסיבה שזה חשוב
הוא ש, ואילו אנו לעתים קרובות

322
00:16:26,910 --> 00:16:30,290
חושב לקרוא לשיטה
על אובייקט זה

323
00:16:30,290 --> 00:16:35,200
של טווח פופולרי מאחרים
שפות מונחה עצמים פופולריים,

324
00:16:35,200 --> 00:16:39,330
אחד ההבדלים הוא ש
כל ששיטה היא בJavaScript

325
00:16:39,330 --> 00:16:47,270
מאוחסן ערך הפנימי של אובייקט
שמבצע כמה action-- אולי

326
00:16:47,270 --> 00:16:51,850
באמצעות הערכים האחרים שנמצאים בתוך
של אובייקט ש, אך לא בהכרח.

327
00:16:51,850 --> 00:16:56,930
אז אתה יכול לדמיין מצב, אני
מניח בקצת דרך מטורפת,

328
00:16:56,930 --> 00:17:02,990
שבו אתה נקרא שיטה של ​​אחד
מתנגד על אובייקט אחר, לדוגמא.

329
00:17:02,990 --> 00:17:06,010
אז, זה קצת פאנקי בדרך זו.

330
00:17:06,010 --> 00:17:09,369
>> ואתה יכול גם לשנות את השיטות
הקשורים לאובייקט

331
00:17:09,369 --> 00:17:13,740
על ידי הקצאת ששיטה
פונקציה חדשה, שהוא גם

332
00:17:13,740 --> 00:17:18,250
די שונה מאחרים
שפות מונחה עצמים, שבו

333
00:17:18,250 --> 00:17:21,410
ברגע שאנו מכריזים על אובייקט
ומופע זה,

334
00:17:21,410 --> 00:17:25,839
אנחנו לא יכולים לשנות את השיטות ש
הקשורים לאובייקט זה יותר.

335
00:17:25,839 --> 00:17:28,680
אז זה די שונה.

336
00:17:28,680 --> 00:17:29,570
מגניב.

337
00:17:29,570 --> 00:17:34,010
>> אז הנה דוגמא, ראשון,
של אובייקט בפעולה.

338
00:17:34,010 --> 00:17:36,390
זה מה שנקרא
אובייקט גנרי, ש

339
00:17:36,390 --> 00:17:39,460
משמעות הדבר היא כי אין לו כל
שם מסוים, אין כיתה,

340
00:17:39,460 --> 00:17:42,190
זה רק חלק עטיפה של ערכים.

341
00:17:42,190 --> 00:17:49,790
והאופן שבו נראה הוא, שיש לנו
זוג החיצוני של מתולתל פלטה כאן

342
00:17:49,790 --> 00:17:57,950
שמצביעים לJavaScript
ואומרים, זה הוא אובייקט.

343
00:17:57,950 --> 00:18:02,130
הערכים הפנימיים שלו
הם כל ערכים בתוך

344
00:18:02,130 --> 00:18:04,590
של האובייקט שצריך
להיות עטוף יחד.

345
00:18:04,590 --> 00:18:09,180
ובתוך האובייקט ש,
אז יש לנו זוגות ערך מפתח,

346
00:18:09,180 --> 00:18:13,880
איפה המפתח מתייחס לשם
של הערך הפנימי של האובייקט,

347
00:18:13,880 --> 00:18:16,790
והאתרים-- האחר
מול כאן-- המעי הגס

348
00:18:16,790 --> 00:18:19,850
הוא הערך הממשי
שצריך להיות מאוחסן.

349
00:18:19,850 --> 00:18:26,210
>> אז אתה רואה שיש לנו כאן
מפתח בשם fn עם הערך סם,

350
00:18:26,210 --> 00:18:29,430
אחרי פסיק,
אומר על הכניסה הבאה.

351
00:18:29,430 --> 00:18:33,560
אז מפתח נקרא LN,
עם ערך של ירוק,

352
00:18:33,560 --> 00:18:35,840
אחרי פסיק,
ואחריו "הדפסה"

353
00:18:35,840 --> 00:18:43,209
שהוא הולך להיות ערך פונקציה
כי הוא הולך לעשות את הקו הזה של קוד.

354
00:18:43,209 --> 00:18:45,500
בואו ניקח צעד אחורה ו
לפרוק את מה שקורה כאן.

355
00:18:45,500 --> 00:18:47,280
אז זה קצת מסובך,
ואנחנו רואים משהו חדש

356
00:18:47,280 --> 00:18:48,071
בפעם הראשונה.

357
00:18:48,071 --> 00:18:51,190

358
00:18:51,190 --> 00:18:55,065
מילת המפתח "זה" הוא הדבר החדש
אנחנו רואים כאן, ומה זה עושה

359
00:18:55,065 --> 00:19:00,540
הוא, מתייחס לנוכחי
מתנגד בהיקף, נכון?

360
00:19:00,540 --> 00:19:03,990
לכן, כאשר אנחנו אומרים, זה
מציין את כל הדרך חזרה

361
00:19:03,990 --> 00:19:08,140
לכל object-- זה
כאשר אנו עושים this.fn,

362
00:19:08,140 --> 00:19:11,990
אנחנו הולכים ללכת את כל הדרך חזרה
לאובייקט, ללכת לערך fn

363
00:19:11,990 --> 00:19:16,471
ותקבל סם, למשוך אותו כל הדרך
בחזרה, לתקוע אותו כאן, ואז להמשיך הלאה.

364
00:19:16,471 --> 00:19:19,838
>> קהל: אז עם שליפה, הוא
שנעשה בגלל הפרמטר

365
00:19:19,838 --> 00:19:20,621
הַגדָרָה?

366
00:19:20,621 --> 00:19:23,870
סם גרין: אז השאלה הייתה, הוא
אחזור לעשות בגלל הפרמטר

367
00:19:23,870 --> 00:19:24,727
הַגדָרָה?

368
00:19:24,727 --> 00:19:25,435
כן, בהחלט.

369
00:19:25,435 --> 00:19:29,660

370
00:19:29,660 --> 00:19:32,470
מה הולך לקרות כאן הוא,
נקודה זו אומרת ל- JavaScript,

371
00:19:32,470 --> 00:19:39,990
אישור, אני מקבל ערך כלשהו
מאובייקט זה מעצמי.

372
00:19:39,990 --> 00:19:46,375
ואז זה יחפש כניסה
נקרא fn, ואם הוא מוצא אותו,

373
00:19:46,375 --> 00:19:48,470
זה יחזור שvalue-- כך, זה סם.

374
00:19:48,470 --> 00:19:51,540
אבל אני יכול גם הקלדתי
משהו שלא הוגדר כאן,

375
00:19:51,540 --> 00:19:54,090
ואז זה פשוט היית
לחזור undefined-- ש

376
00:19:54,090 --> 00:19:58,250
זה דבר שיכול JavaScript
לעשות, אשר יכולה להיות יתרונות,

377
00:19:58,250 --> 00:20:03,190
אבל זה גם-- אם אתה עושה טעות דפוס,
זה יכול לגרום לשגיאות מוזרות.

378
00:20:03,190 --> 00:20:05,617
אז זה פשוט לנסות למצוא
כל מה שאתה אומר את זה כדי למצוא

379
00:20:05,617 --> 00:20:07,700
וזה לא הולך ל
להתלונן אם אינו מוצא אותו.

380
00:20:07,700 --> 00:20:11,390
זה רק אומר, אני לא
למצוא אותו, ואז להמשיך הלאה.

381
00:20:11,390 --> 00:20:17,581
אז זה יהיה לא מוגדר,
בתוספת ריקה, בתוספת שם משפחה.

382
00:20:17,581 --> 00:20:18,080
כֵּן.

383
00:20:18,080 --> 00:20:21,070
ואז אנחנו יכולים לראות שאם
אז יכול לרדת וaccess--

384
00:20:21,070 --> 00:20:25,450
ואנחנו קוראים tf.print () עם סוגריים.

385
00:20:25,450 --> 00:20:30,000
זה הולך לקרוא הדפסה ש
פונקציה ללא ויכוחים, נכון?

386
00:20:30,000 --> 00:20:34,490
אבל אם אנחנו רק אמרתי tf.print ()
פסיק, בלי הסוגריים,

387
00:20:34,490 --> 00:20:37,480
כל מה שהיה עושה הוא למשוך
את הפונקציה מהערך,

388
00:20:37,480 --> 00:20:40,609
אבל לא באמת קראתי לזה.

389
00:20:40,609 --> 00:20:41,162
מגניב.

390
00:20:41,162 --> 00:20:42,870
יו זאבריסקי: צריך
אנחנו עושים אובייקט?

391
00:20:42,870 --> 00:20:44,161
סם גרין: בטח, בוא לעשות את זה.

392
00:20:44,161 --> 00:20:48,750
אז אני יכול להזיז את זה
דוגמא לקונסולה.

393
00:20:48,750 --> 00:20:51,380

394
00:20:51,380 --> 00:20:55,466
אנו יכולים לדמיין שיש לי אובייקט.

395
00:20:55,466 --> 00:21:03,026

396
00:21:03,026 --> 00:21:04,150
אז זה אובייקט פשוט.

397
00:21:04,150 --> 00:21:06,910

398
00:21:06,910 --> 00:21:11,050
זהו אובייקט שמכיל שני
ערכים עם שני מפתחות, שני ערך מפתח

399
00:21:11,050 --> 00:21:12,710
זוגות.

400
00:21:12,710 --> 00:21:21,850
אז אני יכול לגשת לערך המאוחסן
בתוך אובייקט זה על ידי עושה x.x1,

401
00:21:21,850 --> 00:21:23,400
לדוגמא, ואני מקבל בחזרה 1.

402
00:21:23,400 --> 00:21:29,590
כמו כן, x.x2, יקבל ערך שיחזור.

403
00:21:29,590 --> 00:21:33,330
>> ועכשיו הדבר ממש מגניב הוא, שאני יכול
למעשה להוסיף משהו לאובייקט

404
00:21:33,330 --> 00:21:34,316
אחרי שיצרתי אותו.

405
00:21:34,316 --> 00:21:36,315
אז אתה יכול לדמיין, בוא
אומר שיש לי תפקיד.

406
00:21:36,315 --> 00:21:44,430

407
00:21:44,430 --> 00:21:46,352
>> יו זאבריסקי: אתה
צריך לעשות Shift-Enter.

408
00:21:46,352 --> 00:21:47,643
>> סם גרין: אה, זה מעצבן.

409
00:21:47,643 --> 00:22:02,460

410
00:22:02,460 --> 00:22:04,324
מה זה לא רוצה?

411
00:22:04,324 --> 00:22:04,824
אה.

412
00:22:04,824 --> 00:22:07,532

413
00:22:07,532 --> 00:22:08,691
הנה אנחנו יוצאים.

414
00:22:08,691 --> 00:22:09,190
מגניב.

415
00:22:09,190 --> 00:22:12,840
>> אז פשוט יצרתי
פונקציה, F, זה ש

416
00:22:12,840 --> 00:22:17,590
הוא הולך לנוכחי
אובייקט וthis.x1 הדפסה.

417
00:22:17,590 --> 00:22:20,330
אז אם רק אני קורא F על ידי
עצמו, שום דבר לא קורה

418
00:22:20,330 --> 00:22:26,970
לקרות, נכון, כי אין x1
שדה באובייקט זה מתייחס ל.

419
00:22:26,970 --> 00:22:39,710
אבל, אם אני אומר, x.f = F, ואז אני
קורא x.f (), אני הולך לחזור 1.

420
00:22:39,710 --> 00:22:42,990

421
00:22:42,990 --> 00:22:46,530
כי פונקצית f היא עכשיו
הקשורים לאובייקט X,

422
00:22:46,530 --> 00:22:51,800
שבו יש x1 מפתח נקרא
הקשורים לערך 1,

423
00:22:51,800 --> 00:22:54,570
ולכן כאשר אנו קוראים this.x1, זה
הולך למצוא את מה שהוא מחפש

424
00:22:54,570 --> 00:22:56,450
ותוכל להדפיס את ערך.

425
00:22:56,450 --> 00:22:58,700
אז זה רק דוגמא אחת
מסוג הדברים המטורפים

426
00:22:58,700 --> 00:23:01,190
אתה יכול לעשות עם אובייקטים ב- JavaScript.

427
00:23:01,190 --> 00:23:03,870

428
00:23:03,870 --> 00:23:07,560
>> אז הגרסה שהייתה
גרסה הגנרית, משמעות

429
00:23:07,560 --> 00:23:13,780
שיצרנו אובייקט באמצעות זה
סוגר סימון סד notation--,

430
00:23:13,780 --> 00:23:16,880
rather-- וזה
שימושי אם אנחנו רק רוצים

431
00:23:16,880 --> 00:23:21,440
מופע של אובייקט מסוים אחד, אבל
מה אם אנחנו רוצים להיות יותר מאחד

432
00:23:21,440 --> 00:23:22,210
מאותו הסוג?

433
00:23:22,210 --> 00:23:24,440
והתשובה לכך
שאלה היא, יש דברים

434
00:23:24,440 --> 00:23:26,760
נקרא כיתות בJavaScript, כמו גם.

435
00:23:26,760 --> 00:23:31,470

436
00:23:31,470 --> 00:23:36,420
אנחנו יכולים ליצור פונקציה ש
עושה איזשהו אתחול

437
00:23:36,420 --> 00:23:41,690
לאובייקט זר,
והיינו אומרים, כמו,

438
00:23:41,690 --> 00:23:44,550
class-- כל כך שם
של object-- לשימוש חוזר

439
00:23:44,550 --> 00:23:47,100
שווה פונקציה שמגדירה אותו.

440
00:23:47,100 --> 00:23:52,280
אז מה זה יהיה שווה ערך
ליוצר אובייקט ש

441
00:23:52,280 --> 00:23:55,930
יהיה בדיוק כמו,
סד מתולתל, str, מעי גס,

442
00:23:55,930 --> 00:23:59,630
זה הוא מחרוזת,
פסיק, סד מתולתל.

443
00:23:59,630 --> 00:24:01,880
זה יהיה גנרי
אובייקט שלאתחל,

444
00:24:01,880 --> 00:24:06,380
עם ההבדל אחד להיות ב
השורות הבאות אנו יוצרים אב טיפוס, ש

445
00:24:06,380 --> 00:24:11,190
אומר שזה מפתח ברירת מחדל ש
נוסיף לאובייקט שלנו ש

446
00:24:11,190 --> 00:24:13,970
יש הערך הרשום כאן.

447
00:24:13,970 --> 00:24:20,570
כלומר, כאשר אני יוצר חדש
מופע של אובייקט MyClass זה,

448
00:24:20,570 --> 00:24:27,440
זה הולך להיות מראש נבנה בתוך
זה נקרא ערך str וערך אחר

449
00:24:27,440 --> 00:24:32,418
myPrint נקרא, שהוא
הולך להיות פונקציה.

450
00:24:32,418 --> 00:24:32,918
מדהים.

451
00:24:32,918 --> 00:24:37,410

452
00:24:37,410 --> 00:24:37,990
>> גדול.

453
00:24:37,990 --> 00:24:40,710
אז הדבר האחרון ש
אומר על JavaScript

454
00:24:40,710 --> 00:24:46,430
הוא שזה באמת שימושי עבור מה
נקראים פעולות אסינכרוני.

455
00:24:46,430 --> 00:24:52,500
אמצעי אסינכרוני הוא שאנחנו
יכול לחכות כמה פעולה

456
00:24:52,500 --> 00:24:57,870
כדי להשלים לפני שנעבור
ב, אבל לעבור על זמן שאנחנו מחכים

457
00:24:57,870 --> 00:24:59,690
ואז יש לי משהו יקרה בהמשך.

458
00:24:59,690 --> 00:25:03,480
ומה שאני מתכוון בזה הוא, ש
יכול לדמיין מצב שבו

459
00:25:03,480 --> 00:25:06,850
אתה שולח בקשה ל
כמה שרת אינטרנט איפשהו,

460
00:25:06,850 --> 00:25:09,670
וזה הולך לשלוח אותך בחזרה
כמה נתח גדול של נתונים, נכון?

461
00:25:09,670 --> 00:25:13,320
והמשתמש שלך יכול לחכות ב
בינתיים כדי שזה יקרה,

462
00:25:13,320 --> 00:25:15,200
ושום דבר לא יכול להיות
קורה באותו הזמן.

463
00:25:15,200 --> 00:25:18,110
אבל זה לא עיצוב נהדר, נכון?

464
00:25:18,110 --> 00:25:20,214
אתה לא רוצה את דף האינטרנט להקפיא.

465
00:25:20,214 --> 00:25:22,380
מה אם המשתמש רוצה
לחץ על תפריט נפתחת?

466
00:25:22,380 --> 00:25:24,870
זה לא דפוס עיצוב נהדר.

467
00:25:24,870 --> 00:25:29,290
במקום זאת, בעצם מה ש
JavaScript עושה הוא אומר,

468
00:25:29,290 --> 00:25:31,870
אישור, לעשות את הפעולה באופן אסינכרוני.

469
00:25:31,870 --> 00:25:36,520
אז כמו, לחכות ברקע,
ולאחר מכן, כאשר הפעולה נעשית,

470
00:25:36,520 --> 00:25:39,420
קורא הקריאה החוזרת function--
קורא כמה פונקציה,

471
00:25:39,420 --> 00:25:43,800
אל כמה action-- לאותת ש
פעולה שאנחנו מחכים ללסיים

472
00:25:43,800 --> 00:25:45,520
זה נגמר.

473
00:25:45,520 --> 00:25:51,240
והסיבה לכך שהסופר חזק היא,
אנחנו יכולים לעשות משהו, לעבור טיעון,

474
00:25:51,240 --> 00:25:54,440
לעשות משהו, ואז לחכות
למשהו שיקרה.

475
00:25:54,440 --> 00:25:58,970
ואז, ברגע שמשהו ש
משלים, אנחנו יכולים לקרוא לחיוג חוזר.

476
00:25:58,970 --> 00:26:03,300
זה באמת שימושי, כי זה מאפשר לי
שלנו לעשות דברים עם האינטרנט אודיו API,

477
00:26:03,300 --> 00:26:07,490
לדוגמא, כמו עומס
קובץ אודיו משרת מרוחק

478
00:26:07,490 --> 00:26:11,660
מבלי לחכות ל
כל קובץ שמע להיות טעון,

479
00:26:11,660 --> 00:26:14,440
שיהיה באמת
רע חוויית משתמש.

480
00:26:14,440 --> 00:26:17,080
מגניב.

481
00:26:17,080 --> 00:26:19,460
>> הזוג אחרון מציין על
ניפוי, שכן זה

482
00:26:19,460 --> 00:26:23,682
זה דבר שאתה הולך צריך לעשות
כחלק מהפרויקט שלך, מובטח.

483
00:26:23,682 --> 00:26:25,140
הזכרתי את קונסולת JavaScript.

484
00:26:25,140 --> 00:26:27,550
זה תכונה סופר שימושית
של כל הדפדפנים המודרניים,

485
00:26:27,550 --> 00:26:30,300
ואנחנו באמת ממליצים לך לקבל
נוח באמצעות הקונסולה שלך,

486
00:26:30,300 --> 00:26:33,660
אם אתה רוצה לקבל טוב ב- JavaScript.

487
00:26:33,660 --> 00:26:36,320
זה סופר שימושי ל
ניפוי, אבל זה גם

488
00:26:36,320 --> 00:26:39,440
באמת שימושי לחישוב
איך להשתמש API.

489
00:26:39,440 --> 00:26:41,950
זה מאפשר באמת
ניסויים קלים

490
00:26:41,950 --> 00:26:45,910
מבלי להקליד כמה
קוד, ולאחר מכן לאסוף אותו.

491
00:26:45,910 --> 00:26:47,500
אתה לא צריך לעשות את כל הצעדים האלה.

492
00:26:47,500 --> 00:26:49,619
אתה יכול פשוט לכתוב
קוד לקו,

493
00:26:49,619 --> 00:26:52,410
ולאחר מכן לקבל משוב מיידי על
אם קו זה של קוד

494
00:26:52,410 --> 00:26:55,230
worked-- שימושי מאוד.

495
00:26:55,230 --> 00:26:59,760
>> וגם, רק note-- אחד טכני
קונסולת JavaScript היא דוגמא

496
00:26:59,760 --> 00:27:05,680
של REPL-- אז זה R-E-P-L, REPL,
אשר מייצגת קריאה, להעריך,

497
00:27:05,680 --> 00:27:06,180
הדפסת לולאה.

498
00:27:06,180 --> 00:27:09,100

499
00:27:09,100 --> 00:27:12,120
אתה הולך להקליד כמה דברים
ב, זה יהיה לקרוא את מה שהקלדת ב,

500
00:27:12,120 --> 00:27:17,280
זה יהיה להעריך את זה, וזה יהיה להדפיס
פלט, ואז זה יתחיל שוב.

501
00:27:17,280 --> 00:27:22,056
המאפשר לך ללכת במהירות ב
חוגי iterating, שהוא ממש מגניב.

502
00:27:22,056 --> 00:27:25,150

503
00:27:25,150 --> 00:27:28,930
>> אני מניח שעבר אמיתי note-- זה
הוא הפתק האחרון בפועל, כן.

504
00:27:28,930 --> 00:27:30,780
איך בעצם להשתמש ב- JavaScript?

505
00:27:30,780 --> 00:27:34,040
אז קודם כל, אנחנו יכולים לייבא
שלו באמצעות תג סקריפט

506
00:27:34,040 --> 00:27:39,500
בחלק העליון או התחתון של HTML file--
בכל מקום בתוך קובץ HTML,

507
00:27:39,500 --> 00:27:40,440
בֶּאֱמֶת.

508
00:27:40,440 --> 00:27:47,390
ובתוך תג סקריפט, יש
שתי תת-דרכים של יבוא JavaScript.

509
00:27:47,390 --> 00:27:51,370
הראשון הוא על ידי בעל
קובץ JavaScript נפרד

510
00:27:51,370 --> 00:27:58,010
שאנו מייבאים בשלמותו, או
על ידי בעל שטח של קוד כמו תסריט

511
00:27:58,010 --> 00:28:00,290
כדי להתחיל, ולאחר מכן
תסריט קו נטוי ועד הסוף.

512
00:28:00,290 --> 00:28:02,620
ואז אנחנו פשוט לכתוב
JavaScript בתוך קובץ HTML.

513
00:28:02,620 --> 00:28:03,790
אלה הם שתי דרכים.

514
00:28:03,790 --> 00:28:05,165
אתה לא יכול לקבל את זה בתוך ה- HTML.

515
00:28:05,165 --> 00:28:06,502

516
00:28:06,502 --> 00:28:08,126
קהל: האם אחד טוב יותר מאשר אחרים?

517
00:28:08,126 --> 00:28:10,542
סם גרין: השאלה הייתה,
הוא אחד טוב יותר מאשר אחרים.

518
00:28:10,542 --> 00:28:18,306
אז, כן, כפרקטיקת סגנון קידוד,
וגם זה כמו תרגול עיצוב.

519
00:28:18,306 --> 00:28:20,180
ישנן שתי סיבות
למה זה יכול להיות טוב יותר.

520
00:28:20,180 --> 00:28:23,934
הראשון הוא, זה עושה את הקוד שלך
קריא יותר הרבה אם כל ה- HTML שלך

521
00:28:23,934 --> 00:28:27,100
הוא במקום אחד, כל CSS שלך הוא ב
מקום אחר, כל JavaScript שלך

522
00:28:27,100 --> 00:28:28,420
במקום שלישי.

523
00:28:28,420 --> 00:28:28,920
יָמִינָה?

524
00:28:28,920 --> 00:28:32,370
אני חושב שאנחנו צריכים כבר דיברנו
על זה בsections-- כמו CSS-- מה

525
00:28:32,370 --> 00:28:35,220
שהוא-- וזה הולך
לעתים קרובות בקובץ אחר.

526
00:28:35,220 --> 00:28:37,090
אז, סוג דומה של מושג כאן.

527
00:28:37,090 --> 00:28:42,410
גם אתה יכול לדמיין כי JavaScript
יהיה לעשות שימוש חוזר על עצמו יותר מפעם אחת

528
00:28:42,410 --> 00:28:47,350
דף HTML, או אולי
דפי HTML רבים,

529
00:28:47,350 --> 00:28:49,340
ויש שJavaScript
refactored לאחד

530
00:28:49,340 --> 00:28:51,950
קובץ שניתן לייבא
ליותר ממקום אחד

531
00:28:51,950 --> 00:28:54,570
מאפשר את הקוד להיות
דרך לתחזוקה יותר.

532
00:28:54,570 --> 00:28:57,930
אתה יכול לדמיין מה שהופך את אחד
לשנות לJavaScript

533
00:28:57,930 --> 00:29:00,070
ויש לשנות אותה
100 קבצים שונים.

534
00:29:00,070 --> 00:29:04,070
ובמקום שאנחנו יכולים פשוט לשנות את זה
באחד, שהוא הרבה יותר חזק.

535
00:29:04,070 --> 00:29:05,420
האם אני עונה על השאלה שלך?

536
00:29:05,420 --> 00:29:07,950
מגניב.

537
00:29:07,950 --> 00:29:10,830
>> אנחנו גם יכולים להקליד במסוף,
כפי שאנו כבר הזכרנו קודם.

538
00:29:10,830 --> 00:29:15,070
ושוב, note-- האחרון
אינטרנט אודיו בנוי ב,

539
00:29:15,070 --> 00:29:16,978
אתה לא צריך לטעון שום דבר.

540
00:29:16,978 --> 00:29:17,478
מגניב.

541
00:29:17,478 --> 00:29:20,519
לעשות האם יש שאלות, יש לך
שאלות נוספות על JavaScript,

542
00:29:20,519 --> 00:29:21,930
לפני שאנחנו עוברים?

543
00:29:21,930 --> 00:29:24,286
>> קהל: [לא ברור]

544
00:29:24,286 --> 00:29:25,410
סם גרין: בסדר, מגניב.

545
00:29:25,410 --> 00:29:27,200
אז עכשיו הוא הולך לדבר על ה- API.

546
00:29:27,200 --> 00:29:28,490
>> יו זאבריסקי: מגניב.

547
00:29:28,490 --> 00:29:28,990
תודה, סם.

548
00:29:28,990 --> 00:29:30,184
>> GREEN SAM: בטח.

549
00:29:30,184 --> 00:29:32,600
יו זאבריסקי: מדהים, כל כך
אנחנו נעבור מJavaScript.

550
00:29:32,600 --> 00:29:35,350
אז דברנו על כמה מ
היסודות של JavaScript,

551
00:29:35,350 --> 00:29:41,105
ואלה משתנים, פונקציות,
אובייקטים, פונקציות כמשתנים,

552
00:29:41,105 --> 00:29:41,980
טעינת אסינכרוני.

553
00:29:41,980 --> 00:29:46,100
כל אלה הם הדברים שאתה
רואה שאתה משתמש באינטרנט אודיו.

554
00:29:46,100 --> 00:29:49,230
אז אנחנו פשוט הולכים לדבר
על זה ראשון ברמה גבוהה.

555
00:29:49,230 --> 00:29:52,120
>> זה API, אז זה משהו
שנבנה, כסם אמר,

556
00:29:52,120 --> 00:29:57,010
ישר לתוך JavaScript
כי אתה משתמש בקונסולה.

557
00:29:57,010 --> 00:30:01,020
וזה בעצם בדיוק כמו C ++ קוד
שנבנה ממש בקטע של Chrome

558
00:30:01,020 --> 00:30:04,470
ופיירפוקס, וכל דפדפנים אלו.

559
00:30:04,470 --> 00:30:07,060
אז הרעיון העיקרי עם אינטרנט
אודיו הוא שיש לך

560
00:30:07,060 --> 00:30:09,440
צינור של אודיו מסוג זה, נכון?

561
00:30:09,440 --> 00:30:13,670
אז נתוני השמע שלך
מגיע בצורה כלשהי.

562
00:30:13,670 --> 00:30:16,690
>> יש סוג של שלוש forms-- העיקרי
יש לך את מתנד, ש

563
00:30:16,690 --> 00:30:21,340
יוצר גל סינוס, גל קוסינוס,
אנחנו הולכים לראות איך זה עובד.

564
00:30:21,340 --> 00:30:23,890
עוד אחד נפוץ מאוד,
כמובן, הוא MP3.

565
00:30:23,890 --> 00:30:25,810
אז אולי אתה מתחיל עם
שיר, ואז אתה

566
00:30:25,810 --> 00:30:28,320
רוצה לעשות קצת סינון
ושלפלט

567
00:30:28,320 --> 00:30:30,605
לראות-- שיכול להיות מקור אפשרי.

568
00:30:30,605 --> 00:30:32,480
ואז ממש מגניב
אחד הוא המיקרופון.

569
00:30:32,480 --> 00:30:37,230
אז אתה יכול להשתמש בחלק מאוד
שיחות בסיסיות בJavaScript

570
00:30:37,230 --> 00:30:39,440
כדי לקבל גישה ל
מיקרופון, ולכן אם אתה

571
00:30:39,440 --> 00:30:42,870
רציתי לעשות אפליקציה
כמו גלאי המגרש,

572
00:30:42,870 --> 00:30:45,290
לדוגמא, שלוקח ב
קול ונתונים מתוכך

573
00:30:45,290 --> 00:30:47,740
הדרך קלה מאוד pitch-- לזה.

574
00:30:47,740 --> 00:30:50,730
רק סוג של אתה יכול לקרוא את זה
ב, להבין את התדירות,

575
00:30:50,730 --> 00:30:52,250
ואז פלט מספר.

576
00:30:52,250 --> 00:30:56,080
אז אנחנו תראו איך זה עובד, כמו גם.

577
00:30:56,080 --> 00:30:59,430
>> היעד הוא בעצם
שבו נתונים אודיו הוא פלט.

578
00:30:59,430 --> 00:31:02,890
אז בדרך כלל, זה כמו
הרמקולים הניידים שלך.

579
00:31:02,890 --> 00:31:05,610
אפשרויות אחרות הן כמו
ScriptProcessorNode--

580
00:31:05,610 --> 00:31:07,990
אנחנו נתחיל את צמתים ב
הדבר-- אבל בעצם,

581
00:31:07,990 --> 00:31:11,939
או שאתה מוציא קול
דרך המחשב שלך דרך רמקולים,

582
00:31:11,939 --> 00:31:14,730
או שאתה סוג של הקלטה זה, כך
אתה לאחסן אותו כנתוני אודיו.

583
00:31:14,730 --> 00:31:18,980
אז אולי אם מישהו יוצר
מוסיקה באפליקציה שלך ולאחר מכן

584
00:31:18,980 --> 00:31:22,410
אתה רוצה להקליט את זה ואולי כמו
לייצא אותו לסאונדקלאוד, לexample--

585
00:31:22,410 --> 00:31:25,281
זה יהיה דרך אחת לעשות את זה.

586
00:31:25,281 --> 00:31:27,030
כל הדברים כיפיים,
שנדברנו על,

587
00:31:27,030 --> 00:31:29,950
קורה בין שתי הנקודות הללו,
שבו אנו לטעון במוזיקה

588
00:31:29,950 --> 00:31:31,410
ואז פלט אותו.

589
00:31:31,410 --> 00:31:36,660
>> אז אני הולך לדבר על חמש
שלבי ייצור אודיו בשנייה.

590
00:31:36,660 --> 00:31:38,950
יש לנו את הדבר הזה שנקרא
AudioContext, ש

591
00:31:38,950 --> 00:31:41,580
הוא העטיפה הקטנה הזה שאנו רואים כאן.

592
00:31:41,580 --> 00:31:49,980
בעיקרון מה שAudioContext הוא-- אם
ללכת למסוף JavaScript עכשיו,

593
00:31:49,980 --> 00:31:52,740
אנחנו יכולים ליצור אחד עכשיו.

594
00:31:52,740 --> 00:31:54,040
רק דוגמא REPL, נכון?

595
00:31:54,040 --> 00:31:57,880
אנחנו קוראים,
הערכה, והיא מדפיסה.

596
00:31:57,880 --> 00:32:00,260
>> AudioContext היא מדינה גלובלית.

597
00:32:00,260 --> 00:32:05,500
זה struct, זה אובייקט
כאן, והוא שומר מידע

598
00:32:05,500 --> 00:32:09,960
על דברים שקורים
על המסך הקשורים לאודיו.

599
00:32:09,960 --> 00:32:15,220
דוגמא אחת היא הזמן הנוכחי.

600
00:32:15,220 --> 00:32:18,910
זה אומר לך את המספר
שניות, בדיוק רב,

601
00:32:18,910 --> 00:32:20,890
מאז דף האינטרנט נטען.

602
00:32:20,890 --> 00:32:24,110
אז זה באמת שימושי
נכס קטן שאתה יכול להשתמש.

603
00:32:24,110 --> 00:32:27,898
זה לקרוא only-- אני חושב שלמעשה
אתה יכול לנסות להגדיר אותו ערך.

604
00:32:27,898 --> 00:32:29,856
זה יגיד לך להגדיר אותו,
ולאחר מכן, אם תדפיס זה

605
00:32:29,856 --> 00:32:31,439
again-- זה לא ממש עובד די.

606
00:32:31,439 --> 00:32:34,472
אז יש לקריאה בלבד
נכסים ב- JavaScript.

607
00:32:34,472 --> 00:32:36,430
זה באמת שימושי אם
אתה סוג של סינכרון

608
00:32:36,430 --> 00:32:38,610
הרבה שונה
מידע, כשאתה

609
00:32:38,610 --> 00:32:41,280
סוג של השמעת צלילים שונים.

610
00:32:41,280 --> 00:32:43,630
>> אחר באמת שימושי אחד
הוא יעד ההקשר.

611
00:32:43,630 --> 00:32:46,587

612
00:32:46,587 --> 00:32:49,670
בהחלט, אם אתה מעוניין, להיות
מנסה את זה בקונסולה תקין שלך

613
00:32:49,670 --> 00:32:50,980
עַכשָׁיו.

614
00:32:50,980 --> 00:32:53,150
אז זה AudioDestinationNode.

615
00:32:53,150 --> 00:32:56,480
בעיקרון מה שזה אומר הוא,
שבו הפלט הולך?

616
00:32:56,480 --> 00:32:59,590
אז יש שתי אפשרויות אמיתיות כאן.

617
00:32:59,590 --> 00:33:01,940
בדרך כלל ברירת המחדל
רק הרמקולים שלך,

618
00:33:01,940 --> 00:33:05,150
כך AudioDestinationNode
בעצם רק אומר

619
00:33:05,150 --> 00:33:09,240
יש אפס יציאות לקול
מגיע ב, נשלח לרמקול.

620
00:33:09,240 --> 00:33:12,050
אז בדרך כלל, אתה לא
צריך לשחק עם זה.

621
00:33:12,050 --> 00:33:15,720
אם אתה מעוניין בשימוש בפועל
ScriptProcessorNode להקלטה,

622
00:33:15,720 --> 00:33:16,990
בהחלט לירות בי
דוא"ל מאוחר יותר כי זה

623
00:33:16,990 --> 00:33:18,330
קצת יותר מסובך.

624
00:33:18,330 --> 00:33:21,590
אבל בדרך כלל, אתה פשוט סוג
של פלט קול בצורה כלשהי.

625
00:33:21,590 --> 00:33:24,347
כל כך מגניב, שנקפוץ לכאן.

626
00:33:24,347 --> 00:33:25,180
קהל: אני מצטער.

627
00:33:25,180 --> 00:33:26,054
יו זאבריסקי: כן.

628
00:33:26,054 --> 00:33:28,770
קהל: אני יודע שאמרת לדבר
לך מאוחר יותר על הקלטה.

629
00:33:28,770 --> 00:33:31,550
האם אתה יכול ממשק שעם Pro כלים?

630
00:33:31,550 --> 00:33:33,120
>> יו זאבריסקי: עם Pro כלים?

631
00:33:33,120 --> 00:33:35,260
בוא נראה.

632
00:33:35,260 --> 00:33:37,220
לֹא נִראֶה לִי.

633
00:33:37,220 --> 00:33:41,670
אז הולך בין הלקוח,
שהוא JavaScript

634
00:33:41,670 --> 00:33:44,310
קונסולה, ובפועל שלך
מחשב, הוא בדרך כלל

635
00:33:44,310 --> 00:33:46,490
משהו שהוא סוג
של מחוץ לתחום, אם אתה

636
00:33:46,490 --> 00:33:52,320
יהיה, סוג של האופי של כל--
זה סוג של דבר עיצוב,

637
00:33:52,320 --> 00:33:57,770
אבל אתה מנסה לשמור על הדפדפן נפרד
מהמחשב בפועל של המשתמש.

638
00:33:57,770 --> 00:34:02,310
בדרך כלל, הדבר היחיד שאתה מסוגל
גישה היא המיקרופון או המצלמה.

639
00:34:02,310 --> 00:34:04,730
אתה לא מסוגל, אני
לא חושב, להשתמש Pro כלים.

640
00:34:04,730 --> 00:34:07,480
עם זאת, אם אתה יצרת
מסלול בPro כלים,

641
00:34:07,480 --> 00:34:12,710
יצוא זה, אתה יכול לטעון ש
כאן, לסנן אותו, למשל,

642
00:34:12,710 --> 00:34:16,820
תהליך זה, ולהקליט את זה ב
אודי Destination-- או, no-- כדור

643
00:34:16,820 --> 00:34:17,870
צומת מעבד.

644
00:34:17,870 --> 00:34:20,730
ואז משם, אתה יכול
יצוא שלסאונדקלאוד,

645
00:34:20,730 --> 00:34:25,320
יכול לשלוח אותו בדואר אלקטרוני, או
מה שאתה רוצה משם.

646
00:34:25,320 --> 00:34:31,159
>> אבל יש סוג של מכשול קל
בין מה שהופך את המוזיקה במחשב שלך

647
00:34:31,159 --> 00:34:33,050
ומה שהופך את המוזיקה מקוונת.

648
00:34:33,050 --> 00:34:37,940
>> סם גרין: וזה
אינו ייחודי לAPI זה.

649
00:34:37,940 --> 00:34:44,060
זה תכונת אבטחה של Chrome, ו
אני חושב שכל דפדפן מודרני אחר.

650
00:34:44,060 --> 00:34:45,860
הדפדפן הוא עצמאי.

651
00:34:45,860 --> 00:34:50,980
כך למשל, בדף אינטרנט לא יכול
להשתמש ב- JavaScript כדי להפוך את הצליל

652
00:34:50,980 --> 00:34:54,190
ברמקולים שלך, למשל.

653
00:34:54,190 --> 00:34:58,120
או שזה לא יכול להפוך את המחשב שלך כבוי.

654
00:34:58,120 --> 00:35:01,530
ואין טעם ביניים
בין שני הדברים האלה, נכון,

655
00:35:01,530 --> 00:35:05,960
כך גם יש לך
הפשטה מוחלטת,

656
00:35:05,960 --> 00:35:10,050
או שאתה פותח את
פגם אבטחה של לתת

657
00:35:10,050 --> 00:35:14,440
מתכנת עם כוונות רעות לעשות
מה שהם רוצים עם המחשב הנייד שלך.

658
00:35:14,440 --> 00:35:18,104
ולכן Chrome הוא עצמאי.

659
00:35:18,104 --> 00:35:19,310
>> יו זאבריסקי: כן.

660
00:35:19,310 --> 00:35:20,840
האם זה הגיוני?

661
00:35:20,840 --> 00:35:21,369
מגניב, מגניב.

662
00:35:21,369 --> 00:35:23,160
אני רק הולך ל
להראות דוגמא אחת.

663
00:35:23,160 --> 00:35:25,118
זה פחות או יותר כפי ש
ככל שאתה מקבל, במונחים

664
00:35:25,118 --> 00:35:26,950
לגישה למחשב של המשתמש.

665
00:35:26,950 --> 00:35:30,180
אם יש לך מקלדת USB לחשמל,
אתה יכול להשתמש במשהו שנקרא האינטרנט

666
00:35:30,180 --> 00:35:32,180
API MIDI, אנחנו לא ש
ממש מדבר עליו כאן,

667
00:35:32,180 --> 00:35:36,330
אבל זה API אחר זה
מובנה בתוך לפחות Chrome-- שוב,

668
00:35:36,330 --> 00:35:41,570
זו הסיבה שאנחנו אוהבים Chrome--
אני חושב שפיירפוקס או ספארי,

669
00:35:41,570 --> 00:35:44,300
זה דבר קל
יש דפדפנים שונים google--

670
00:35:44,300 --> 00:35:46,917
תמיכה שונה של
APIs הם יישמו.

671
00:35:46,917 --> 00:35:49,875
אבל אם אתה רוצה לחבר את מקלדת
ולעבוד עם מידע ש,

672
00:35:49,875 --> 00:35:52,850
סוג של לשלוח את המקלדת
מידע על למחשב

673
00:35:52,850 --> 00:35:57,620
ולאחר מכן להשתמש באינטרנט כי, API זה
המקום שבו אתה רוצה להיות עובד ש.

674
00:35:57,620 --> 00:35:58,150
>> מגניב.

675
00:35:58,150 --> 00:35:58,710
אוקיי.

676
00:35:58,710 --> 00:36:01,320
אז, נע במהירות כאן.

677
00:36:01,320 --> 00:36:03,310
איך אנחנו עושים בזמן?

678
00:36:03,310 --> 00:36:04,210
>> 1 מרצה: כ -15.

679
00:36:04,210 --> 00:36:05,543
>> יו זאבריסקי: 15 דקות לסיום?

680
00:36:05,543 --> 00:36:06,160
בסדר מגניב.

681
00:36:06,160 --> 00:36:08,170
אז אנחנו במירוץ קדימה כאן.

682
00:36:08,170 --> 00:36:13,500
>> אז בעצם, הנקודה העיקרית
חושב על זה כצינור

683
00:36:13,500 --> 00:36:16,430
הוא שכל צעד בצנרת
היא סדרה של בלוטות שמע.

684
00:36:16,430 --> 00:36:19,284

685
00:36:19,284 --> 00:36:20,950
המקור שלנו, נניח, הוא מתנד.

686
00:36:20,950 --> 00:36:23,380
אנחנו צריכים ליצור צומת מתנד.

687
00:36:23,380 --> 00:36:25,690
וזה רק סוג
של function-- הקטן

688
00:36:25,690 --> 00:36:30,460
והם כולם מבוססים מתוך
בהקשר האודים כאן.

689
00:36:30,460 --> 00:36:32,885
>> קהל: כאשר אמר
מתנד, זה אומר

690
00:36:32,885 --> 00:36:37,250
זה בעצם ממש הולך מ
שני קטבים שונים קדימה ואחורה?

691
00:36:37,250 --> 00:36:41,170
>> יו זאבריסקי: לא, זה כמו
ייצוג דיגיטלי.

692
00:36:41,170 --> 00:36:42,740
זה למעשה הוא מיושם ב- C ++.

693
00:36:42,740 --> 00:36:46,460
אני באמת לא יודע את המפרט
איך זה מיושם בפועל,

694
00:36:46,460 --> 00:36:48,500
אבל כל זה עובד כנתונים בינאריים.

695
00:36:48,500 --> 00:36:51,260

696
00:36:51,260 --> 00:36:52,370
למעשה, כן.

697
00:36:52,370 --> 00:36:53,950
שאומר, שאני יכול
למעשה, אם אתה מעוניין,

698
00:36:53,950 --> 00:36:56,533
אני יכול לשלוח לך קצת יותר
מידע על אופן גל

699
00:36:56,533 --> 00:37:00,181
נשמרים שפורמט דיגיטלי.

700
00:37:00,181 --> 00:37:00,680
בסדר מגניב.

701
00:37:00,680 --> 00:37:03,120
>> אז אנחנו מייצרים צליל כמו סינוס
גל או משהו כזה, אולי

702
00:37:03,120 --> 00:37:04,190
440 הרץ.

703
00:37:04,190 --> 00:37:05,830
אנו יוצרים מתנד.

704
00:37:05,830 --> 00:37:09,180
אם אנחנו רוצים להגדיר את עוצמת הקול, אנחנו
להתחבר לכל דבר GainNode,

705
00:37:09,180 --> 00:37:12,500
שאנחנו יכולים לעשות עם .creategain.

706
00:37:12,500 --> 00:37:14,250
שמגדיר הנפח שלך.

707
00:37:14,250 --> 00:37:17,820
אתה יכול להעביר את זה על כל
של אחר options-- גם,

708
00:37:17,820 --> 00:37:20,300
כך מקור חיץ שמע
צומת שבו אתה עלול

709
00:37:20,300 --> 00:37:23,660
לאחסן MP3, כי אתה כבר עמוס ב.

710
00:37:23,660 --> 00:37:27,670
>> מסנן biquad הוא לסינון אם
אתה רוצה לקחת את כל הבסיס החוצה

711
00:37:27,670 --> 00:37:29,630
של שיר, או משהו כזה.

712
00:37:29,630 --> 00:37:32,450
החס וחליל שאתה רוצה לקחת
הבסיס מתוך שיר.

713
00:37:32,450 --> 00:37:36,980
וצומת AudioDestination היא, שוב,
כמו שם השלמת שלנו היא.

714
00:37:36,980 --> 00:37:39,980
אם אתה אי פעם מעוניין לראות
כל האופציות אפשריות השונות,

715
00:37:39,980 --> 00:37:45,190
פשוט ללכת ללשונית ולתת
ההשלמה האוטומטית לבוא.

716
00:37:45,190 --> 00:37:48,690
ואם אתה יוצר, אתה תראה את כל
דברים שונים שאתה יכול ליצור.

717
00:37:48,690 --> 00:37:50,398
אתה יכול ליצור דינמי
מעבדי תסריט,

718
00:37:50,398 --> 00:37:52,940
אני אפילו לא יודע מה זה
הוא, לערבוב מיזוגים ערוץ

719
00:37:52,940 --> 00:37:55,930
ומפצלי ערוץ וכל זה.

720
00:37:55,930 --> 00:37:56,430
מגניב.

721
00:37:56,430 --> 00:37:59,560

722
00:37:59,560 --> 00:38:01,390
>> אז זה פשוט
דוגמא של צינור.

723
00:38:01,390 --> 00:38:03,580
אז יש לנו שלושה מקורות הקרובים ב.

724
00:38:03,580 --> 00:38:06,830
אולי אלה הם צורות גל,
אולי אלה הם קבצי MP3.

725
00:38:06,830 --> 00:38:08,740
אחד עובר
מסנן, עוד אחד של

726
00:38:08,740 --> 00:38:12,404
אחר מקבל מעוותת
צילום פנורמי של אחד משמאל ומימין.

727
00:38:12,404 --> 00:38:15,320
אתה יכול לעשות כל מיני דברים ו
כולם מתערבבים סביב יחד,

728
00:38:15,320 --> 00:38:18,880
ולאחר מכן את מגיע האודים
בסוף, כיעד.

729
00:38:18,880 --> 00:38:22,720
זוהי דוגמא של מה שיותר
קוד אודי אינטרנט מסובך נראה.

730
00:38:22,720 --> 00:38:26,720
אתה יוצר את כל אלה
אובייקטים שונים תקין כאן--

731
00:38:26,720 --> 00:38:27,706
אני לא בטוח בכך.

732
00:38:27,706 --> 00:38:29,120
לא, זה לא להתמקד ב.

733
00:38:29,120 --> 00:38:29,620
אוקיי.

734
00:38:29,620 --> 00:38:31,257
>> סם גרין: אתה עושה בקרה, מגילה-Up.

735
00:38:31,257 --> 00:38:32,590
יו זאבריסקי: בקרת Scroll--

736
00:38:32,590 --> 00:38:33,000
סם גרין: לא, לא.

737
00:38:33,000 --> 00:38:33,500
לִשְׁלוֹט--

738
00:38:33,500 --> 00:38:36,540

739
00:38:36,540 --> 00:38:38,140
>> יו זאבריסקי: אה, בקרה, גלול?

740
00:38:38,140 --> 00:38:38,780
אה, תפסתי אותך.

741
00:38:38,780 --> 00:38:41,480
כֵּן.

742
00:38:41,480 --> 00:38:42,240
וואו, לא, לא.

743
00:38:42,240 --> 00:38:42,740
אוקיי.

744
00:38:42,740 --> 00:38:46,090
אני לא אעשה את זה.

745
00:38:46,090 --> 00:38:48,300
>> אז כן, בזה ראשון
סעיף כאן, אתה רואה

746
00:38:48,300 --> 00:38:52,720
אנחנו יוצרים שונים כל אלה
צמתים מתוך ההקשר.

747
00:38:52,720 --> 00:38:54,980
אנחנו רק לצרף אותם
יחד בחלק השני

748
00:38:54,980 --> 00:38:56,980
על ידי פונקציה זו נקראת על התחבר.

749
00:38:56,980 --> 00:38:58,830
זה באמת מפתח
פונקציה באינטרנט אודיו.

750
00:38:58,830 --> 00:39:01,930
זה רק אומר ברגע שאתה עשית
משהו עם הצליל בצומת אחד,

751
00:39:01,930 --> 00:39:03,705
להעביר את זה הלאה לצומת הבאה.

752
00:39:03,705 --> 00:39:05,830
אז יש לנו את המקור, אותו
מתחבר למנתח,

753
00:39:05,830 --> 00:39:09,140
המנתח עושה עם זה משהו,
זה הולך לעיוות, וכן הלאה,

754
00:39:09,140 --> 00:39:12,725
וליעד
בתחתית ממש כאן.

755
00:39:12,725 --> 00:39:13,225
מגניב.

756
00:39:13,225 --> 00:39:14,640
אוקיי, אז אנחנו להמשיך לנוע על.

757
00:39:14,640 --> 00:39:17,180
>> Pipeline-- שוב, אלה
הם הצינורות הנפוצים ביותר,

758
00:39:17,180 --> 00:39:21,300
כך אנחנו מדברים על כל הדברים האלה כמו
עיוות, צילום פנורמי, את כל הדברים האלה.

759
00:39:21,300 --> 00:39:24,280
אם אתה באמת מעוניין
בשימוש בדברים Pro כלים,

760
00:39:24,280 --> 00:39:25,820
אלה כנראה לעניין אותך.

761
00:39:25,820 --> 00:39:27,740
אם לא, אולי אתה פשוט
רוצה לשחק הקול,

762
00:39:27,740 --> 00:39:29,990
או אולי אתה פשוט רוצה
להגדיר את עוצמת הקול בקול.

763
00:39:29,990 --> 00:39:35,270
אלה הם הסוג הנפוץ ביותר שני
צינורות בייצור אודיו.

764
00:39:35,270 --> 00:39:38,640
>> שוב, הדרכים שאתה יכול לקחת את זה
כבoscillator-- כך, בוא

765
00:39:38,640 --> 00:39:42,460
לעשות ההדגמה של שממש כאן.

766
00:39:42,460 --> 00:39:47,090

767
00:39:47,090 --> 00:39:52,225
אז אנחנו הולכים ליצור
פשוט הקשר אודים כאן,

768
00:39:52,225 --> 00:39:54,350
ושמאנחנו הולכים
כדי ליצור מתנד.

769
00:39:54,350 --> 00:39:58,620
אז זה, שוב, אנחנו רק
הולך לקרוא צור מתנד.

770
00:39:58,620 --> 00:40:07,030
אנחנו הולכים להגדיר תדירות ב
ש, 440 הרץ, האהוב על כולם.

771
00:40:07,030 --> 00:40:13,290
אז אנחנו מתחברים זה ליעד
point-- שהוא הדובר, כך

772
00:40:13,290 --> 00:40:15,750
יעד ההקשר.

773
00:40:15,750 --> 00:40:21,400
לבסוף, רק אנחנו אומרים, להתחיל אפס
שניות מעכשיו, ואל לנו להישמע?

774
00:40:21,400 --> 00:40:22,400
>> [צִלצוּל]

775
00:40:22,400 --> 00:40:24,980
>> יו זאבריסקי: אז הנה.

776
00:40:24,980 --> 00:40:25,940
זה רק גל סינוס.

777
00:40:25,940 --> 00:40:26,440
בסדר מגניב.

778
00:40:26,440 --> 00:40:28,274
ואז לעצור את זה.

779
00:40:28,274 --> 00:40:30,520
>> קהל: מאיפה
המשוב שמגיע מ?

780
00:40:30,520 --> 00:40:31,250
>> יו זאבריסקי: המשוב?

781
00:40:31,250 --> 00:40:32,458
אה, כנראה המיקרופונים שלנו.

782
00:40:32,458 --> 00:40:34,221

783
00:40:34,221 --> 00:40:35,470
אז כן, זה איך אתה עושה את זה.

784
00:40:35,470 --> 00:40:37,261
ובעצם, אם היה לי
שמרתי אותו בריצה,

785
00:40:37,261 --> 00:40:39,540
יכול להיות התדר
ערך כפי שהוא פועל,

786
00:40:39,540 --> 00:40:43,320
אז זה דבר כיף לשחק.

787
00:40:43,320 --> 00:40:44,930
מגניב.

788
00:40:44,930 --> 00:40:46,600
זה תמיד אחד יפה להציג.

789
00:40:46,600 --> 00:40:48,792
>> סם גרין: לא
נחשוב על זה, לא אנחנו?

790
00:40:48,792 --> 00:40:50,500
יו זאבריסקי: כן,
זה אחד מגעיל.

791
00:40:50,500 --> 00:40:53,249
אז, חיץ loading-- אני אראה
דוגמא לכך בסוף מאוד.

792
00:40:53,249 --> 00:40:55,090
זה טעינת MP3.

793
00:40:55,090 --> 00:40:58,880
ומיקרופון, אתה משתמש רק פונקציה
נקרא navigator.getUserMedia ()

794
00:40:58,880 --> 00:41:03,240
לבקש גישה למשתמש של
מיקרופון למידע זה.

795
00:41:03,240 --> 00:41:05,610
>> הנה סינון, אני
רק להמשיך לנוע מזה.

796
00:41:05,610 --> 00:41:08,600
זה די ברמה גבוהה,
אבל מסננים רק לאפשר לך

797
00:41:08,600 --> 00:41:16,154
>> [צפצוף]

798
00:41:16,154 --> 00:41:18,320
סינון גם מאפשר לך
כדי ליצור דברים כמו ורוד

799
00:41:18,320 --> 00:41:20,050
רעש, רעש חום, רעש לבן.

800
00:41:20,050 --> 00:41:24,330
אם אתה רוצה ליצור רעש טהור, ש
כמה אנשים אוהבים להתעסק עם,

801
00:41:24,330 --> 00:41:27,490
אתה יכול להשתמש באינטרנט אודיו
סינון לעשות את זה.

802
00:41:27,490 --> 00:41:30,039
>> אודי Panning-- כך לדמיין
אם אתה כותב משחק

803
00:41:30,039 --> 00:41:32,330
ואתה רוצה את הצליל ל
נשמע כמו זה מגיע, כמו,

804
00:41:32,330 --> 00:41:36,090
ירי על פני המסך, אתה
ניתן להשתמש בצילום פנורמי של אודיו

805
00:41:36,090 --> 00:41:39,770
ליצור של קונוס מסוג זה,
שlike-- זה די mathy,

806
00:41:39,770 --> 00:41:41,850
אבל זה ממש ממש
מגניב אם אתה מקבל את זה לעבוד,

807
00:41:41,850 --> 00:41:44,500
ויש כמה טוב
הדרכות על זה אני יכול לשלוח לך.

808
00:41:44,500 --> 00:41:46,400
בעיקרון, אתה יכול סוג
של יצירת הצליל

809
00:41:46,400 --> 00:41:50,480
משהו הולך על ידי בצורה 3D.

810
00:41:50,480 --> 00:41:57,350
ואם יש לך עניין DJ, אתה יכול
להתחיל ערבוב ולחצות שירי דהייה.

811
00:41:57,350 --> 00:42:01,260
>> זה רק חלק בסיסי מאוד
קוד, בעצם מה שעשיתי בעבר.

812
00:42:01,260 --> 00:42:06,140
זה קובע את היקף
מתנד, כך אנו יוצרים מתנד

813
00:42:06,140 --> 00:42:07,380
אשר יוצר את צורת הגל.

814
00:42:07,380 --> 00:42:09,940
אנו יוצרים GainNode,
להגדיר התדר שלנו,

815
00:42:09,940 --> 00:42:14,170
ולאחר מכן חבר את מתנד ל
GainNode, אשר לאחר מכן בעצם משנה

816
00:42:14,170 --> 00:42:16,760
כמה אות מותרת דרך.

817
00:42:16,760 --> 00:42:20,467
אבל באמת, זה דיגיטלי
דבר, כך שזה יותר פשוט-- כן.

818
00:42:20,467 --> 00:42:23,550
זה לא מה שבאמת קורה,
אבל זה מה שקורה בחיים אמיתיים

819
00:42:23,550 --> 00:42:24,393
עם רווח.

820
00:42:24,393 --> 00:42:27,258
>> קהל: --quantization
של פרמטר הנפח?

821
00:42:27,258 --> 00:42:28,174
יו זאבריסקי: מצטער?

822
00:42:28,174 --> 00:42:30,360
קהל: האם זה
פרמטר נפח בדיד?

823
00:42:30,360 --> 00:42:31,840
יו זאבריסקי: כן.

824
00:42:31,840 --> 00:42:34,620
וזה דבר אחד אני באמת
לקוי בידע שלי,

825
00:42:34,620 --> 00:42:38,010
איך רווח עובד ברמה דיגיטלית.

826
00:42:38,010 --> 00:42:40,140
אני יודע עם בפועל
אותות, זה בעצם

827
00:42:40,140 --> 00:42:45,120
שליטה כמה אתה
מגביר את האות.

828
00:42:45,120 --> 00:42:47,017
אז, כן.

829
00:42:47,017 --> 00:42:50,100
אני אשלח לך מידע נוסף על
כי, משום שאני סקרן למעשה

830
00:42:50,100 --> 00:42:51,099
לדעת יותר על זה.

831
00:42:51,099 --> 00:42:54,090
אבל בעצם הפרמטרים
הם, אחד הוא fold--

832
00:42:54,090 --> 00:42:59,690
signal-- ואפס בקול רם הוא לא
לאותת, או לא תשמע כל צליל.

833
00:42:59,690 --> 00:43:03,150
אנחנו לדלג זמן הדגמה לכי
זה בעצם מה שעשיתי בעבר.

834
00:43:03,150 --> 00:43:07,630
ושוב, Context.Destination
היא צומת יעד אודיו.

835
00:43:07,630 --> 00:43:08,360
מדהים, בסדר.

836
00:43:08,360 --> 00:43:10,470
>> אז אני הולך לעשות שתי הדגמות מהירות.

837
00:43:10,470 --> 00:43:11,760
איך אנחנו עושים בזמן?

838
00:43:11,760 --> 00:43:12,640
>> 1 מרצה: כ -10 דקות.

839
00:43:12,640 --> 00:43:13,130
>> יו זאבריסקי: 10 דקות?

840
00:43:13,130 --> 00:43:13,630
גדול!

841
00:43:13,630 --> 00:43:14,320
מדהים.

842
00:43:14,320 --> 00:43:19,010
>> אז את הראשון אני הולך
אין, זה נקרא השיר האהוב עליי.

843
00:43:19,010 --> 00:43:22,410
אז זה פשוט
JavaScript HTML הקטן.

844
00:43:22,410 --> 00:43:25,510
אנחנו הולכים יש שני כפתורים
בדף לנגן את השיר האהוב עליי

845
00:43:25,510 --> 00:43:29,192
ולהפסיק את השיר האהוב עליי.

846
00:43:29,192 --> 00:43:30,180
אני אשנה את זה.

847
00:43:30,180 --> 00:43:32,110
>> קהל: מכסה את המיקרופון שלך.

848
00:43:32,110 --> 00:43:33,430
>> יו זאבריסקי: כן.

849
00:43:33,430 --> 00:43:36,300
ואני כבר נטענו כאן
תסריט שbasically--

850
00:43:36,300 --> 00:43:38,520
וזה באמת שימושי
לטעינת MP3,

851
00:43:38,520 --> 00:43:41,820
אז זה רק גורם לי
טעינת קבצי MP3 דרך מהירה יותר.

852
00:43:41,820 --> 00:43:44,180
זה בעצם רק עטיפה.

853
00:43:44,180 --> 00:43:48,737
זה פשוט הופך את התהליך
טעינה בקבצי MP3 הרבה יותר מהר,

854
00:43:48,737 --> 00:43:51,570
אחרת אתה משתמש בקשת HTTP,
כמו סוג של מה שאנחנו עושים

855
00:43:51,570 --> 00:43:53,950
על פיסה להגדיר עם שרת הנוכחית.

856
00:43:53,950 --> 00:43:55,950
זה ממש מכוער, אתה
לא רוצה לעשות את זה.

857
00:43:55,950 --> 00:44:04,110
>> אז הבחור הזה, בוריס סינוס, כתב באמת
כלי קטן ושימושי הנקרא BufferLoader.

858
00:44:04,110 --> 00:44:08,780
כל שעליך לעשות הוא פשוט לעבור את זה
הקשר, אתה עובר את זה list--

859
00:44:08,780 --> 00:44:11,327
או, כן, זה ברשימה JavaScript?

860
00:44:11,327 --> 00:44:12,160
סם גרין: מערך.

861
00:44:12,160 --> 00:44:14,201
יו זאבריסקי: הו, זה
מערך, זה נכון.

862
00:44:14,201 --> 00:44:18,660
זה מערך של נתיבים
לקבצים שונים.

863
00:44:18,660 --> 00:44:21,990
ואז אתה עובר את זה פונקציה.

864
00:44:21,990 --> 00:44:25,530
זה callback שאנחנו מדברים
על עם טעינת אסינכרוני.

865
00:44:25,530 --> 00:44:28,720
שייקרא
פעם אחת את הקבצים שנטענו.

866
00:44:28,720 --> 00:44:33,780
ופונקציה שנקראת כאשר
הקובץ של טעון לוקח כהיקפי

867
00:44:33,780 --> 00:44:35,840
מערך של מאגרים טעונים.

868
00:44:35,840 --> 00:44:37,990
כדי שמתרחש כאן.

869
00:44:37,990 --> 00:44:41,180
בעיקרון, הוא BufferList
הולך להיות value-- אחד

870
00:44:41,180 --> 00:44:46,380
או שזה הולך להיות מערך של
אורך אחד, שיש בה במדד

871
00:44:46,380 --> 00:44:51,320
אפס הקובץ הטעון השלם של MP3.

872
00:44:51,320 --> 00:44:53,320
אז מה שאני עושה כשאני גומר
טעינה היא, אני פשוט

873
00:44:53,320 --> 00:44:57,430
ליצור מקור חיץ, ש
היא צומת מקור חיץ שמע.

874
00:44:57,430 --> 00:45:03,410
השלב הבא הוא שאני לטעון ב
source.buffer כחיץ טעון המלא

875
00:45:03,410 --> 00:45:06,740
מBufferList--
זה הרבה buffers--

876
00:45:06,740 --> 00:45:10,255
ואז אתה מחבר את האודים ש
חיץ ליעד.

877
00:45:10,255 --> 00:45:12,380
אז מה זה הולך לעשות
הוא פשוט לשים MP3

878
00:45:12,380 --> 00:45:15,260
ישר דרך לפלט,
ולהפעיל אותו באופן מיידי

879
00:45:15,260 --> 00:45:18,010
על מקבל שיחה זו.

880
00:45:18,010 --> 00:45:21,660
>> מגניב, אז בואו לראות
זה קרה בפעולה.

881
00:45:21,660 --> 00:45:24,490
[לא ברור] שלי כאן, בואו נראה.

882
00:45:24,490 --> 00:45:26,430
אז רק אני הולך
להתחיל שרת בסיסי.

883
00:45:26,430 --> 00:45:28,660
זה משהו ש
אתה צריך לעשות אם אתה

884
00:45:28,660 --> 00:45:32,490
מה שהופך את הבקשות לטעינת קבצים.

885
00:45:32,490 --> 00:45:34,140
אני הולך להתחיל שרת בסיסי.

886
00:45:34,140 --> 00:45:38,200
זה בעצם כולו שלך
PSET עכשיו בקו אחד,

887
00:45:38,200 --> 00:45:43,930
אבל זה רק מתחיל
שרת ביציאה 80/80.

888
00:45:43,930 --> 00:45:47,300
אז אנחנו הולכים לכאן, אנחנו
הולך לטעון 80/80,

889
00:45:47,300 --> 00:45:49,110
אנחנו הולכים ללכת לשיר האהוב עליי.

890
00:45:49,110 --> 00:45:51,660
אז אם אני מכה "מחזה שלי
השיר אהוב "עכשיו,

891
00:45:51,660 --> 00:45:53,964
זה הולך לטעון שלי
והשיר אהוב לשחק it--

892
00:45:53,964 --> 00:45:55,880
[MUSIC - הנשרים, "חיים בFAST
 נתיב"]

893
00:45:55,880 --> 00:46:00,490
--which קורה להיות "חיים ב
המסלול המהיר "על ידי הנשרים.

894
00:46:00,490 --> 00:46:06,346
עכשיו, אני יכול להכות "אפסיק
השיר האהוב "ולהפעיל אותו שוב.

895
00:46:06,346 --> 00:46:09,160
>> [MUSIC - הנשרים, "חיים בFAST
 נתיב"]

896
00:46:09,160 --> 00:46:18,340
>> ואם אני הולך על לנחם, כי
הייתי משתנה גלובלי כאן

897
00:46:18,340 --> 00:46:23,390
כדי לעקוב אחר ערך זה, זה באמת
עכשיו יהיה מוכר בקונסולה.

898
00:46:23,390 --> 00:46:25,160
אז זה אוטומטי יוצר-לי.

899
00:46:25,160 --> 00:46:29,991
אז זה מה שמשחק עכשיו,
ואני יכול פשוט לקרוא source.stop ()

900
00:46:29,991 --> 00:46:30,490
על ש.

901
00:46:30,490 --> 00:46:34,930

902
00:46:34,930 --> 00:46:35,860
ובכן, אתה יודע מה?

903
00:46:35,860 --> 00:46:39,760
רק כך אתם שמעתם את זה
song-- שאולי תזהה את השיר הזה.

904
00:46:39,760 --> 00:46:41,801
>> [MUSIC - ריק אסטלי, "אף פעם לא הולך לתת לי
 אותך "]

905
00:46:41,801 --> 00:46:42,299

906
00:46:42,299 --> 00:46:44,215
[MUSIC - הנשרים, "חיים בFAST
 נתיב"]

907
00:46:44,215 --> 00:46:46,195
אנחנו כבר עכשיו כולם Rickrolled.

908
00:46:46,195 --> 00:46:50,155
אישור, גדול, נע ב.

909
00:46:50,155 --> 00:46:51,160
מגניב.

910
00:46:51,160 --> 00:46:54,554
אז זה בעצם דוגמא ל
רק איך אתה יכול לטעון MP3 file--

911
00:46:54,554 --> 00:46:56,470
[MUSIC - הנשרים, "חיים בFAST
 נתיב"]

912
00:46:56,470 --> 00:46:59,590
--and לשחק אותה, ולהפסיק ולהפעיל אותו.

913
00:46:59,590 --> 00:47:03,008
הייתי יכול לעשות הרבה יותר [לא ברור]

914
00:47:03,008 --> 00:47:07,570
>> האחרון שאני אעשה הוא,
אני אראה לך [לא ברור].

915
00:47:07,570 --> 00:47:18,070
>> [השמעת מוסיקה]

916
00:47:18,070 --> 00:47:21,800
>> זה כמו, ogg.wave.mp3.

917
00:47:21,800 --> 00:47:26,450
אני חושב, אם אני זוכר נכון,
אני כבר נתקלתי בכמה בעיות עם .m4a,

918
00:47:26,450 --> 00:47:27,721
אבל אני לא בטוח בקשר לזה.

919
00:47:27,721 --> 00:47:28,470
אני חושב mp3.wave--

920
00:47:28,470 --> 00:47:28,930

921
00:47:28,930 --> 00:47:30,971
>> [MUSIC - ריק אסטלי, "אף פעם לא הולך לתת לי
 אותך "]

922
00:47:30,971 --> 00:47:35,930

923
00:47:35,930 --> 00:47:36,500
>> אוקי מצויין.

924
00:47:36,500 --> 00:47:37,625
אני לא היה צריך לומר את זה.

925
00:47:37,625 --> 00:47:40,570
בכל מקרה, שלום.

926
00:47:40,570 --> 00:47:43,430

927
00:47:43,430 --> 00:47:45,490
אז יש לנו את זה פתוח.

928
00:47:45,490 --> 00:47:52,320
אז עכשיו כל מה שאני עושה הוא, אני בעצם נוצר
תחביר בסיסי ליצירת מוסיקה.

929
00:47:52,320 --> 00:47:57,610
אז אם אני עושה משהו כמו, להוסיף G4
על 1 2, מה שזה אומר הוא ש,

930
00:47:57,610 --> 00:48:00,950
להוסיף הערת הפסנתר, G4,
אשר G הרביעי

931
00:48:00,950 --> 00:48:02,680
על הפסנתר מהתחתית.

932
00:48:02,680 --> 00:48:05,930
אז זה סוג של MIDI לדבר,
אז למי שאינם מבוססים מוסיקה,

933
00:48:05,930 --> 00:48:07,860
זה רק הערות MIDI.

934
00:48:07,860 --> 00:48:10,090
>> קהל: זה G
של התיכון C, נכון?

935
00:48:10,090 --> 00:48:11,840
>> יו זאבריסקי: זה G
מעל C התיכון, זה נכון.

936
00:48:11,840 --> 00:48:12,470
>> קהל: מעל התיכון ג

937
00:48:12,470 --> 00:48:13,345
>> יו זאבריסקי: כן.

938
00:48:13,345 --> 00:48:14,340
בעצם כן.

939
00:48:14,340 --> 00:48:16,131
אני חושב שאני באמת עשיתי
זה אחד [לא ברור],

940
00:48:16,131 --> 00:48:18,860
אז זה יכול להיות אוקטבה מעל זה.

941
00:48:18,860 --> 00:48:20,070
אז בואו לראות.

942
00:48:20,070 --> 00:48:21,152
אם אני מכה לנגן--

943
00:48:21,152 --> 00:48:22,110
[הערה PIANO חוזרת]

944
00:48:22,110 --> 00:48:23,200
--we're הולך לשמוע את זה.

945
00:48:23,200 --> 00:48:25,700
הרעיון הוא שזה פועל
בדיוק כמו שורת הפקודה היית,

946
00:48:25,700 --> 00:48:27,510
כך שאם אני עולה ויורד
על המקלדת שלי, לך

947
00:48:27,510 --> 00:48:31,550
יכול לחזור לקודם
פקודות, וזה די שימושי.

948
00:48:31,550 --> 00:48:35,136
ולהלן הוא הרשימה של שירים שלי,
כל שפועלים בלולאה.

949
00:48:35,136 --> 00:48:38,260
>> קהל: אתה היה בהנחה
מקלדת 88 מקשים על זה, נכון?

950
00:48:38,260 --> 00:48:41,051
>> יו זאבריסקי: השאלה הייתה,
אני מניח מקלדת 88 מקשים,

951
00:48:41,051 --> 00:48:41,990
וכן, אני.

952
00:48:41,990 --> 00:48:45,030
מה שעשיתי הוא אני
בעצם לקח 88 דגימות

953
00:48:45,030 --> 00:48:46,970
של הפסנתר, אחד לכל תו.

954
00:48:46,970 --> 00:48:49,180
וכך בכל פעם ש
לשמוע פתק מעתה והלאה,

955
00:48:49,180 --> 00:48:57,550
כי הוא בעצם לולאה שנראית
like-- זה הוא מקבל שיחק בלולאה,

956
00:48:57,550 --> 00:49:00,120
כך לכל הערה, זה פועל.

957
00:49:00,120 --> 00:49:02,860
מה שקורה הוא, ש
ליצור חיץ שוב,

958
00:49:02,860 --> 00:49:06,010
אני יוצר צומת רווח כדי להגדיר את עוצמת הקול.

959
00:49:06,010 --> 00:49:08,240
זה פשוט באמת
דרך מסובכת לומר אני

960
00:49:08,240 --> 00:49:10,550
לאחסן את החיץ בsource.buffer.

961
00:49:10,550 --> 00:49:13,160
אני נותן לו הרווח, אני
לחבר אותו לרווח,

962
00:49:13,160 --> 00:49:15,576
הרווח מחובר ל
פלט, ואז אני משחק אותה.

963
00:49:15,576 --> 00:49:20,735
אז זה סוג של התהליך
לקחת במקור חיץ.

964
00:49:20,735 --> 00:49:24,820
>> קהל: האם אתה באמת לקחת את זה
צליל ויבש לעשות את זה [לא ברור] רטוב?

965
00:49:24,820 --> 00:49:26,260
>> יו זאבריסקי: אתה יכול, כן.

966
00:49:26,260 --> 00:49:29,260
יש מחדש פועל, יש
עיכוב, עיוות.

967
00:49:29,260 --> 00:49:33,260
אתה בעצם יכול לשים כל דבר ב
בין ל-- גם בכריך ש,

968
00:49:33,260 --> 00:49:37,660
צינור הוא מטאפורה טובה יותר,
אבל אתה יכול להוסיף כל דבר שב.

969
00:49:37,660 --> 00:49:38,200
מגניב.

970
00:49:38,200 --> 00:49:40,280
>> אז אני אסיים ההדגמה
כאן כדי לתת לך תחושה

971
00:49:40,280 --> 00:49:46,390
רק המספר המוחלט של פעמים אתה
יכול לרוץ פונקציה שבבת אחת.

972
00:49:46,390 --> 00:49:49,280
אז אני הולך להסיר את זה.

973
00:49:49,280 --> 00:49:59,110
אני הולך ליצור גנרטור לראות--
בעצם מה does-- זה באמת

974
00:49:59,110 --> 00:50:04,220
סוג של syntax-- מסובך אבל זה
הולך ליצור הערות על לטוס,

975
00:50:04,220 --> 00:50:06,601
ופשוט להתחיל לשחק
שלהם כפי שהוא מעריך אותם.

976
00:50:06,601 --> 00:50:07,392
[PIANO חציצה]

977
00:50:07,392 --> 00:50:10,990

978
00:50:10,990 --> 00:50:12,817
>> אז אנחנו יכולים רק לעשות קצת מוסיקה כאן.

979
00:50:12,817 --> 00:50:13,608
[PIANO חציצה]

980
00:50:13,608 --> 00:50:39,570

981
00:50:39,570 --> 00:50:41,470
>> אז מה בפקודה זו
עושה, למשל, הוא

982
00:50:41,470 --> 00:50:46,910
זה לוקח שלוש הערות אלה ל
פסנתר ולאחר מכן מעביר אותם על B3.

983
00:50:46,910 --> 00:50:48,660
תחביר זה עלול לגרום
יותר הגיוני

984
00:50:48,660 --> 00:50:50,590
לאלה שיש להם
רקע מוסיקה כאן.

985
00:50:50,590 --> 00:50:55,180

986
00:50:55,180 --> 00:50:56,551
>> אני יכול להוסיף תוף בעיטה.

987
00:50:56,551 --> 00:50:57,050
אני יכול--

988
00:50:57,050 --> 00:50:58,048
>> [חציצת מכשירים]

989
00:50:58,048 --> 00:50:59,256
>> --just לשחק עם זה.

990
00:50:59,256 --> 00:51:12,519

991
00:51:12,519 --> 00:51:13,474
>> אז אתה יכול make--

992
00:51:13,474 --> 00:51:14,515
[חציצת מכשירים]

993
00:51:14,515 --> 00:51:15,513
אחד זה קצת מעצבן יותר.

994
00:51:15,513 --> 00:51:16,554
[חציצת מכשירים]

995
00:51:16,554 --> 00:51:26,491

996
00:51:26,491 --> 00:51:30,981
>> כך שאופן אקראי מוסיף מצלה יבשה
על כל פתק -16, עם 16%

997
00:51:30,981 --> 00:51:31,481
[לא ברור].

998
00:51:31,481 --> 00:51:32,522
>> [חציצת מכשירים]

999
00:51:32,522 --> 00:51:40,962

1000
00:51:40,962 --> 00:51:50,400
>> כן, ולכן הדרך זו
works-- זה תמיד ב -4: 4.

1001
00:51:50,400 --> 00:51:51,441
[חציצת מכשירים]

1002
00:51:51,441 --> 00:52:06,910

1003
00:52:06,910 --> 00:52:10,902
>> כן, אז הארבעה רבעונים, ו16 / 8.

1004
00:52:10,902 --> 00:52:14,851

1005
00:52:14,851 --> 00:52:15,892
[חציצת מכשירים]

1006
00:52:15,892 --> 00:52:27,970

1007
00:52:27,970 --> 00:52:33,780
>> אז בממוצע, אתה מקבל 60%
צפיות בהערות ה -16.

1008
00:52:33,780 --> 00:52:35,990
>> בכל אופן, זה היה רק
סוג של להשוויץ

1009
00:52:35,990 --> 00:52:39,780
חלק מהדברים שאתה יכול
לבנות עם אודי API האינטרנט.

1010
00:52:39,780 --> 00:52:43,840
זה ממש חזק, זה ממש מהר,
ואתה יכול לעשות הרבה דברים מגניבים

1011
00:52:43,840 --> 00:52:44,340
עם זה.

1012
00:52:44,340 --> 00:52:51,260
אז שוב, כל שאלות שיש לך,
הדוא"ל עצמי בתור Hugh-- או סם,

1013
00:52:51,260 --> 00:52:55,869
ובכנות, לגוגל יש
טון של משאבים טובים.

1014
00:52:55,869 --> 00:52:56,660
כל שאלות האחרונות?

1015
00:52:56,660 --> 00:52:57,970
כֵּן.

1016
00:52:57,970 --> 00:53:00,790
>> קהל: אז אתה יכול לגשת ל
המיקרופון המובנה.

1017
00:53:00,790 --> 00:53:03,089
מה אם אתה רוצה
להשתמש במיקרופון טוב יותר?

1018
00:53:03,089 --> 00:53:05,380
יו זאבריסקי: אם אתה רוצה
להשתמש במיקרופון טוב יותר?

1019
00:53:05,380 --> 00:53:11,320
אז שוב, זה חלק מ
הפשטה בין Chrome

1020
00:53:11,320 --> 00:53:12,950
ושאר המחשב שלך.

1021
00:53:12,950 --> 00:53:18,950
אלא אם כן זה זמין דרך
API, כמו API האינטרנט MIDI,

1022
00:53:18,950 --> 00:53:22,030
כנראה שאתה יכול למצוא כמה פריצות,
אבל בדרך כלל לא ריאלי כ.

1023
00:53:22,030 --> 00:53:25,300
>> סם גרין: אתה יכול גם--
כל Chrome יודע

1024
00:53:25,300 --> 00:53:28,820
זה מה שמיקרופון ברירת המחדל שלך
הוא, וזה שניגש.

1025
00:53:28,820 --> 00:53:33,410
אז אם היה לך מיקרופון אתה יכול
נקבע כברירת מחדל המיקרופון של המחשב,

1026
00:53:33,410 --> 00:53:35,990
אתה יכול לגשת אליו בדרך זו
וזה כנראה יעבוד.

1027
00:53:35,990 --> 00:53:37,490
יו זאבריסקי: זו נקודה טובה.

1028
00:53:37,490 --> 00:53:39,656
אף פעם לא ניסיתי את זה, אבל
אתה עלול להיות מסוגל סוג

1029
00:53:39,656 --> 00:53:45,700
ל-- אם להפנות את רמקול הקלט,
ייתכן שתוכל לעשות את זה, כן.

1030
00:53:45,700 --> 00:53:48,360
>> כל שאלות האחרונות?

1031
00:53:48,360 --> 00:53:49,340
מגניב.

1032
00:53:49,340 --> 00:53:51,680
ובכן תודה לכם
כל כך הרבה עבור צפייה.

1033
00:53:51,680 --> 00:53:52,199
אני יו.

1034
00:53:52,199 --> 00:53:52,990
סם גרין: אני סם.

1035
00:53:52,990 --> 00:53:55,410
יו זאבריסקי: וזה CS50.

1036
00:53:55,410 --> 00:53:56,767