>> SAM GREEN: Hi, ყველას.
მოგესალმებით ჩვენი სემინარი.
ჩემი სახელი არის სემ.
HUGH Zabriskie: მე Hugh.
SAM GREEN: ჩვენ ვაპირებთ, რომ გაიგო დღეს JavaScript და ვებ აუდიო API.
უბრალოდ დაიწყოს, ეს არის მონახაზი ჩვენს დღის წესრიგში სემინარზე.
ჩვენ ვაპირებთ, რომ დაიწყოს საუბარი რატომ უნდა იყოს დაინტერესებული ვებ
აუდიო API, რატომ არის JavaScript ენის გჭირდებათ ეს,
და მერე ვისაუბროთ JavaScript essentials-- ამიტომ მინდა,
ფეხით თქვენ მეშვეობით საფუძვლები ენა,
და შემდეგ ვისაუბროთ აუდიო API მაღალ დონეზე.
ამის შემდეგ, ჰიუ იქნება ვისაუბროთ ზოგიერთ ეტაპების აუდიო წარმოების
და შემდეგ დემო ამ გასაოცარია sequencer პროექტის მან ააშენა და გაჩვენებთ კოდი.
და მაშინ, ჩვენ გვაქვს დრო კითხვები დასასრულს ადამიანი
რომლებიც აქ ცხოვრობენ.
>> HUGH Zabriskie ზემოთ.
>> SAM GREEN ზემოთ.
>> HUGH Zabriskie ზემოთ.
მე უკან.
>> SAM GREEN: ასე რომ, პირველი რამ პირველი.
ასე რომ, ერთი დიდი რამ შესახებ Web აუდიო API
ის არის, რომ არ არის მითითებული up საჭირო.
ეს მოდის ჩაშენებული ყველაზე თანამედროვე ბრაუზერებში,
მათ შორის, Chrome, Edge, მთელი bunch of others-- ყველა პირობა
რომ დიდი ნაწილი ადამიანი იყენებს დღეს.
ასე რომ არ შეიქმნას, გარდა მხოლოდ მისაღებად
ვებ სერვერზე აპირებს, რადგან თქვენ უნდა დავიწყოთ მუშაობა
თქვენი პროექტი, რომელიც დიდი.
>> ჩვენ გირჩევთ საკმაოდ მძიმედ, რომ თქვენ განიხილოს
გამოყენებით Chrome for JavaScript ვებ განვითარება,
მხოლოდ იმიტომ, რომ მისი შემქმნელი ინსტრუმენტები მართლაც ძლიერი.
მაგალითად, თუ უბრალოდ, თუ რა იგულისხმება განაცხადა, გახსენით თქვენი JavaScript
console-- თუ წასვლას Chrome და თქვენ შეხედეთ ნებისმიერ ვებ გვერდზე,
და თქვენ დაუტოვებიათ click შეამოწმოს ელემენტის, და შემდეგ
თქვენ კი ეს პატარა ჩამოსაშლელი სწორედ აქ და ვაწვებით Console,
თქვენ ნახავთ, რა ხსნის გამოიყურება ბევრი მოსწონს command prompt, რომ თქვენ
შეიძლება ნახოთ თქვენს Mac, ან პირადობის მოწმობა.
და ისევე, როგორც, რომ, ჩვენ შეგვიძლია ტიპი ბრძანებები აქ, ისევე როგორც წმინდა,
და სხვა ბრძანებები, როგორიცაა, რომ.
ჩვენ შეგვიძლია შევქმნათ ცვლადები, როგორც ვნახავთ, მოგვიანებით JavaScript.
ასე რომ, არაფერი შეგვიძლია გავაკეთოთ JavaScript, ჩვენ შეგვიძლია გავაკეთოთ კონსოლი,
და ეს სუპერ მოსახერხებელი გზა დაუკარით გარშემო APIs
და მიღების კომფორტულად JavaScript უფლება off bat.
არარის შეიქმნა საჭირო, რომელიც მართლაც ლამაზი.
ზემოთ.
გასაოცარია.
>> ასე რომ, მხოლოდ ერთი რამ, რომ დაამატოთ.
თუ თქვენ გაქვთ რაიმე questions-- არსებობს ბევრი თქვენგანი, ვინც აქ არ ცხოვრობს,
მოგერიდებათ ელ us-- ეს არის ჩვენი ელექტრონული ფოსტის მისამართები.
თუ თქვენ გაქვთ შეკითხვები თქვენ არ მინდა ვთხოვო,
მოსწონს, რა მაქვს bug ჩემი კოდი, ან რამე
რომ ცოტა უფრო კონკრეტული, იქნებ Google იგი.
არსებობს ბევრი დიდი რესურსი შესახებ Web აუდიო API არსებობს.
ეს მართლაც კარგად დოკუმენტირებული და ის, რომ
გამოიყენება ტონა ხალხი მრეწველობა და ადამიანები, რომლებიც უბრალოდ
მშენებლობის fun stuff თავს.
ასე რომ, არ უნდა იყოს ბევრი რესურსი არსებობს.
გასაოცარია.
>> Cool, რატომ ვებ აუდიო API?
ეს სქემა არის ცოტა ევოლუციის გზა
ხმის ვებ გაიზარდა დროთა განმავლობაში.
Bgsound იყო, როგორც ორიგინალური HTML tag რომ Internet Explorer მხარდასაჭერად.
ეს მხოლოდ დაშვებული საკმაოდ ძირითადი კინო, ფუნქციონალური არ იყო ძალიან ძლიერი,
და თქვენ ვერ გააკეთებს რთული თანმიმდევრობის,
ან კონტროლი, როდესაც ხმის დაიწყო და შეწყვიტა ძალიან მტკიცედ.
ასე რომ, ეს არ იყო განსაკუთრებით კარგად განვითარებული.
შემდეგ რომ, Flash მოვიდა along--, რომელიც,
დარწმუნებული ვარ, რომ თქვენ ბიჭები არიან ყველა იცნობს ერთად Flash-- შესაძლოა, არა, როგორ მუშაობს,
მაგრამ თქვენ, რა თქმა უნდა უნახავს იგი.
თქვენ მოხვდით განაახლოთ თქვენი Flash Plug-in, რომ ყველა სახის ნივთები,
და, რა თქმა უნდა გაგრძელდეს სპექტრი ფუნქციონირება, რომელიც ხელმისაწვდომი იყო.
მაგრამ მიღების შესახებ ინსტალაცია დანამატი ნამდვილად
ნაკლი, მათ შორის Flash თქვენს განაცხადს, არა?
იმის გამო, რომ მაშინ თქვენ დამოკიდებული მომხმარებლის აპირებს და მოძიებაში ეს დანამატი,
და ალბათ მიმდინარეობს აღმოჩნდა off ამ ზედმეტი ნაბიჯი
მათ უნდა მიიღონ გამოიყენოთ თქვენი app.
და მაშინ არ შეიძლება იყოს განახლება რომ შესვენება თქვენი მთელი პროგრამა,
და ეს დამთავრდა კოშმარი დეველოპერი, ძალიან.
ასე რომ ბარიკადების.
>> და შემდეგ, რომ მოვიდა ერთად, HTML, აუდიო tag, რომელიც
არის თვისება თანამედროვე HTML-- რომელიც რა თქმა უნდა დაშვებულია ბევრი სხვა პერსონალი,
მაგრამ რამ, რაც შეიძლება გავაკეთოთ იქ ცოტა შემოიფარგლება მხოლოდ
შედეგად რამ რომ HTML შეეძლო.
ასე რომ, როდესაც JavaScript API, ვებ აუდიო API,
გახდა სტანდარტული პრაქტიკაში ბრაუზერებს შორის,
რომ ნამდვილად გაფართოვდა კომპლექტი შესაძლებლობები დეველოპერები
ნამდვილად მისაღებად შევიდა შენობა მაგარი რამეები ინტერნეტში.
დიდი ხნის განმავლობაში იქ მართლაც ძლიერი ინსტრუმენტები
მშობლიური აუდიო პროგრამები, მოსწონს ყველამ იცის, GarageBand,
და მაშინ აშკარად არსებობს უფრო პროფესიული აუდიო შერევით პროგრამები,
და რომ სახის ნივთები.
მაგრამ არ იყო ძალიან კარგი Cloud-- არა
Cloud, ჰო, ვფიქრობ, Cloud-- ვებ დაფუძნებული პლატფორმა
რომელიც საშუალებას მისცემს დეველოპერებს ავაშენოთ განაცხადების ადამიანები
უნდა გავაკეთოთ აუდიო შერევით.
და როგორც ის, თუ მოგვიანებით, ვებ აუდიო API
საშუალებას იძლევა ნამდვილად ძლიერი პერსონალის მოხდეს მართლაც, უბრალოდ,
რომელიც არის საკმაოდ გრილი.
ასე რომ, ინსტრუქციას, თუ რატომ უნდა უყუროთ დანარჩენი სემინარი,
ძირითადად.
>> და ახლა, მე ვაპირებ ვისაუბრო ზოგიერთი JavaScript-- მხოლოდ ძირითადი ელემენტები
ენა, ისე, რომ ჩვენ შეიძლება იმავე გვერდზე
როდესაც ვსაუბრობთ API ცოტა მოგვიანებით.
ზემოთ.
>> ასე რომ, ეს არის შემაჯამებელი.
დამავიწყდა, რომ ეს იყო აქ.
ჰო.
>> HUGH Zabriskie: არსებობს ორი სლაიდები აქ.
>> SAM GREEN: ეს არის მოკლე ზოგიერთი შეზღუდვები
სხვა სავალდებულო, ძველი მეთოდები.
და მაშინ ახლა, ჩვენ გვაქვს ეს ყველაფერი.
ზემოთ.
გასაოცარია.
>> ასე რომ, JavaScript საგნები.
პირველი ნივთები, პირველ, არსებობს საკმაოდ მნიშვნელოვანი განსხვავება
ამ JavaScript წინააღმდეგ in a ენის C, გზა
რომ ცვლადები იქმნება.
ასე რომ, C, ჩვენ მივეჩვიეთ, რომ აკრიფოთ ჩვენი ცვლადები, არა?
და მე არ ვგულისხმობ ტიპის მოსწონს აკრიფოთ, ვგულისხმობ ტიპი
ისევე როგორც მივანიჭოთ მათ type-- მნიშვნელობა როგორიცაა, int, float, char.
In C, ჩვენ მართლაც გამოიყენება რომელსაც შევქმნათ ცვლადი
და შემდეგ ჯოხი, რომ ტიპი, რომ მთელი დრო, რომ ჩვენ ვიყენებთ, რომ ცვლადი.
და რომ არ არის აუცილებელი, უარესი, მაგრამ ეს, ალბათ უფრო გამოიყენოს.
ერთი მაგარი ფუნქციები of JavaScript არის
რომ ცვლადები რასაც "დინამიურად აკრეფილი", რომელიც
იმას ნიშნავს, რომ ჩვენ შეგვიძლია შევქმნათ ცვლადი რომ სინტაქსი,
Varx შეადგენს 5, მაგალითად.
რომ თავდაპირველად ქმნის რიცხვი ცვლადი
მარჯვენა ქვეშ hood somewhere-- მაგრამ მე
შეიძლება შეიცვალოს, რომ ცვლადი ეხება სიმებიანი
გარეშე აკეთებს არაფერი მოსწონს შექმნა ახალი ცვლადი.
მე არ უნდა ფიქრი რა სახის იცვლება.
JavaScript იცის, რომ ტიპის ს შეიცვალა, და ეს ხდება დინამიურად ვითარდება.
>> ასე რომ, არსებობს სარგებელი და ნაკლი, რომ
როგორც ყველას, ვინც იმუშავა JavaScript ხნით შეიძლება იცოდეს.
არსებობს დრო, როცა თქვენ შემთხვევით
შეცვლა ტიპის ცვლადი და არა გაუმკლავდეს, რომ ტიპის იცვლება,
და შემდეგ თქვენი JavaScript შეგიძლიათ crash-- და გამონაკლისი
დააგდეს, რადგან თქვენ გაქვთ არასწორი ტიპის როდესაც თქვენ ველით ერთი ტიპის.
ზემოთ.
>> ასე რომ, scoping-- რომელიც ჰგავს, თუ ჩვენ მახსოვს ადრეულ კვირის, რა თქმა უნდა,
ეხება თუ როგორ ჩანს ცვლადი არის და რა ფართობი კოდი.
ყველა რომ გამოიყურება ძალიან ჰგავს რომ გზა ჩანს C.
ასე რომ ცვლადების scoped ზოგადად ფარგლებში Curly braces ფარგლებში ფუნქცია,
და მაშინ არსებობს გლობალურად Scoped ცვლადები,
are-- თუ წერთ ცვლადი გარეთ ფუნქცია,
ეს იქნება ჩანს მთელი ტექსტი.
>> ერთი განსხვავება JavaScript და C კერძოდ,
ის არის, რომ თუ თქვენ გამოაცხადოს გლობალური ცვლადი სადმე ტექსტური ფაილი
ეს ჩანს ნებისმიერ ფუნქცია შიგნით რომ ტექსტური ფაილი.
ეს არის სწორი, არა?
>> HUGH Zabriskie: Yep.
>> SAM GREEN: ასე რომ, ასევე პატარა ცოტა ხმაურიანი შედარებით C,
სადაც ჩვენ ყოველთვის ჰქონდა, რომ ჩვენი ცვლადი განმარტებები ზემოთ ადგილებში
ისინი გამოიყენება.
ეს არ არის წესი, რომელიც აღსრულდება აღარ, ასე რომ, ცოტა განსხვავებული.
ისევ და ისევ, უბრალოდ, ყურადღების გამახვილება, გლობალური წინააღმდეგ ადგილობრივი ცვლადები
ძალიან ჰგავს C. თქვენ შეიძლება ორი ცვლადის იგივე სახელი,
და ერთ-ერთი მათი სახელები უნდა პირქუში ადგილობრივი ცვლადი, თუ ერთ-ერთი მათგანი
იყო გლობალური.
ასე რომ, მსგავსი სახის პრობლემა, რომ ზოგიერთი
შეიძლება გადაეყარონ ზოგიერთი თქვენი პრობლემა ადგენს ჯერჯერობით.
Cool, ასე რომ ცვლადი.
>> კონტროლის ნაკადის, რაც იმას ნიშნავს, როგორიცაა, თუ-else-- ლოგიკური stuff-- და მარყუჟების.
ასე რომ, პირველ რიგში, ეს არის რა, თუ-სხვაგან განცხადებები გამოიყურებოდეს JavaScript.
განთავსება სხვადასხვა რამ, ხაზები არ არის მნიშვნელოვანი.
ეს არის მხოლოდ ერთი კონვენციების გზა ჩვენ სტრუქტურა კოდი.
ისევე, როგორც C, ჩვენ გვაქვს "თუ" ფრჩხილებში განცხადებაში.
ეს არ არის ის, რაც მე იმას ნიშნავდა, რომ გააკეთოს.
მე კიდევ ერთხელ.
>> HUGH Zabriskie: ცდილობს გასვლა?
SAM GREEN: არა, მე ვარ უბრალოდ ცდილობს, რომ მიუახლოვდით.
არ აქვს მნიშვნელობა,.
>> ასე რომ, ჩვენ გვაქვს "თუ" განცხადება და ჩვენ გვაქვს მდგომარეობა შიგნით
რომ აფასებს ჭეშმარიტი ან მცდარი, და, რომელიც განსაზღვრავს თუ არა
შევდივართ, რომ ბლოკი კოდი.
ანალოგიურად, ჩვენ სხვას თუ, და სხვაგან, ისევე, როგორც ჩვენ გამოიყენება in C.
>> თქვენ ასევე უნდა იყოს საკმაოდ კომფორტული უფლება off bat მარყუჟების,
იმიტომ, რომ ისინი ასევე გამოიყურება ბევრი მოსწონს C გამოიყურება.
მაგრამ თქვენ შეამჩნევთ ერთხელ, რომ ჩვენ აქვს, ნაცვლად int initializations,
ჩვენ var initializations.
და მე ვფიქრობ, თქვენ უნდა ფრთხილად უნდა მიიღოს
დარწმუნდით, რომ თქვენ არ შეცვლის ღირებულება მე ეხლა int სიმებიანი,
მაგალითად, იმის გამო, რომ აპირებს გამოიწვიოს უცნაური ქცევის თქვენ შეიძლება არ
ველით.
მაგრამ ეს უნდა გამოიყურებოდეს საკმაოდ ნაცნობი, ასევე.
>> ასე რომ, ეს არის სადაც რამ დაიწყება ცოტა გიჟები JavaScript
ვინმეს, ვინც აპირებს საწყისი ფონზე C. არსებობს ფუნქციების
JavaScript, და არსებობს ერთი გზა განაცხადოს ფუნქცია, რომელიც გამოიყურება
სახის მსგავსი C, და მაშინ არ არის ერთი, რომ
გამოიყურება სახის განსხვავებული.
>> პირველი ვერსია, სადაც ჩვენ ვხედავთ, აქ,
სახის C-, როგორიცაა, სადაც ჩვენ ვამბობთ, რომ ეს არის ფუნქცია,
მისცეს მას სახელი, მისცეს რაოდენობის არგუმენტები,
და შემდეგ შინაარსი ფუნქცია შიგნით იმ Curly braces.
ჩვენ დავინახავთ, მაგალითად, არგუმენტები მხოლოდ მეორე.
>> ვინაიდან შემდეგი ხაზი, ჩვენ ვხედავთ, oh, აქ არის ცვლადში "myFunction"
და ჩვენ გაუტოლდება, რომ ამ ზოგადი რამ ფუნქცია, რომელიც
როგორც ჩანს, არ აქვს არაფერი ხდება.
იმ მიზეზით, რომ სხვადასხვა ვიდრე C არის, რომ JavaScript
რასაც ფუნქციური ენა, ან ფუნქციური ელემენტების, რაც იმას ნიშნავს,
რომ ფუნქციები, რომლებიც, ფაქტობრივად, ღირებულებებს.
ეს იმას ნიშნავს, რომ ჩვენ შეგვიძლია მითითებული ცვლადი გაუტოლდება ფუნქცია
და მაშინ გადატანა, რომ ფუნქცია გარშემო, გაივლის მას, როგორც არგუმენტი,
ყველა სახის ნივთები მოსწონს, რომ ფუნქციონირებს.
>> ერთი რამ, რომ note-- ფუნქციები წერილობითი
გარკვეული რაოდენობის არგუმენტები.
ჩვენ დავინახავთ, მაგალითად ფუნქცია არგუმენტი მომდევნო slide.
მაგრამ JavaScript არ დაწეროთ თუ თქვენ ცდილობენ
გამოიყენოთ ფუნქცია ერთად არასწორი რიგი არგუმენტები.
ეს კიდე უბრალოდ გავაკეთოთ იმისთვის, რომ ამის გაკეთება, რაც იმას ნიშნავს, რომ თუ თქვენ გაიაროს,
რეკავთ ფუნქცია, რომელიც ელოდება არგუმენტი არსებობს არგუმენტი, რომ ყველა
მოხდება ის, რომ ყველაფერს გააკეთებს იმისათვის, ცდილობენ და შეასრულოს, რომ კოდი,
და თუ ეს საბოლოოდ გადის შევიდა გამონაკლისი ან შეცდომა,
ის ყველაფერს იმისათვის, რომ გამონაკლისი და უბრალოდ შეინახოს going-- რომელიც მხოლოდ ერთი გზა
რომ JavaScript მუშაობს.
ჰო.
>> აუდიტორია: რა მოხდება, თუ იქ ძალიან ბევრი არგუმენტები?
SAM GREEN: ასე რომ, კითხვა იყო, თუ რა ხდება,
იმ შემთხვევაში, თუ არსებობს ძალიან ბევრი არგუმენტები?
და პასუხი არის ის, რომ JavaScript იქნება მხოლოდ
იგნორირება პირობა, რომ შემდეგ კი მას ელოდება.
ეს შევეცდებით შეასრულოს ფუნქცია მოვუწოდებთ, თითქოს ეს იყო მხოლოდ პირველი ორი.
მარჯვენა?
>> HUGH Zabriskie: ეს უფლება, yeah.
ასევე, თუ არსებობს ძალიან ცოტა არგუმენტები,
ეს მხოლოდ სახის აძლევს null ყველა არგუმენტები მას არ აქვს რაიმე ღირებულებები
ამისთვის.
>> SAM GREEN: რომელი შეუძლია რეალურად იყოს მოსახერხებელი, თუ
გსურთ დაწეროთ ფუნქცია, რომელიც იღებს ცვლადი რაოდენობის არგუმენტები.
შეგიძლიათ დააყენოთ default ღირებულებების განმარტება ფუნქცია,
და ეს შეიძლება იგნორირება იმისა, რომ შეყვანის არ არსებობს.
ასე რომ, მინდა გაიგო ცოტა უფრო მეტი ამ ბოლო ტყვია
წერტილი, რომელიც არის ფუნქცია ღირებულებებს.
ეს არის მაგალითი, რომ არის ცოტა გონება-აფეთქებით
თუ უბრალოდ წავიკითხე, და არა მგონია, შესახებ, თუ რა ხდება მეორე.
ასე რომ, მოდით შევხედოთ მხოლოდ პირველი ხაზი აქ.
ჩვენ გვყავს ამ ცვლადი, f1, რომ ჩვენ ვამბობთ, არის ფუნქცია, რომელიც აქვს ამ რამ.
და შინაარსი ფუნქცია არიან console.log ("Hello").
შეგიძლიათ წარმოიდგინოთ, console.log როგორც JavaScript ექვივალენტი printf.
ასე რომ, რა მოხდება, თუ ჩვენ აწარმოებს ამ კოდი ჩვენი ბრაუზერის,
ეს კიდე ბეჭდვა სიმებიანი.
მე შეუძლია დაამტკიცოს, რომ.
აუდიტორია: By ჟურნალი, თუმცა, იმას, რომ ნიშნავს, რომ ის იწერება სადმე?
SAM GREEN: ჰო.
ასე რომ, მე გაჩვენებთ, თუ რა მოხდება.
ასე რომ კითხვა იყო, რას სისტემაში შესვლა ნიშნავს?
>> HUGH Zabriskie: ასე console.log ჰგავს printf, C.
SAM GREEN: ასე console.log ჰგავს printf,
ასე რომ, თუ მე ამ console.log ("Hello"), და მოვუწოდებ, რომ სტრიქონი "Hello"
იღებს ბეჭდვითი გარეთ კონსოლი.
ეს არის კონსოლი.
ეს, ისევე, printf, სადაც იგი ბეჭდავს სტანდარტული გარეთ.
ჩვენ დავინახავთ, წუთი, მაგრამ ეს არის რეალურად
გულისხმობდა console ობიექტი, და მოუწოდებს მეთოდი, რომ ობიექტი.
სწორედ ამას უფრო გრძნობა, ერთ წუთში, როდესაც ჩვენ
მისაღებად ვსაუბრობთ ობიექტების JavaScript,
მაგრამ ვფიქრობდი, რომ მხოლოდ აღვნიშნავ, რომ.
HUGH Zabriskie: ჩვენ გამოიყენება C, right--
როგორც წესი, ჩვენ წერენ დიდი პროგრამა მთავარ არაფერი.
მაგრამ რა არის მაგარი, JavaScript თქვენ ამ სახის თარჯიმნის
გადის რეალურ დროში, ასე რომ იღებს მხოლოდ ხაზს,
მას შეუძლია მხოლოდ ინტერპრეტაცია, რომ ადგილზე.
და იგი ინარჩუნებს სიმღერა რამ, რომ არ აწარმოებს ადრე,
ასე რომ, ეს არის საკმაოდ სასარგებლო ინსტრუმენტი გამოყენება console.log, ან კონსოლი,
ზოგადად, უბრალოდ სათამაშო გარშემო JavaScript.
>> SAM GREEN: ასე რომ ბრუნდება ამ მაგალითად მეორე ხაზი კოდი
აქ არის საკმაოდ გონება- boggling ჩემი უფროსი.
პირველად წავიკითხე ეს, ასე იყო, თუ რა ხდება?
ასე რომ, რა ხდება, ეს ფუნქცია დეკლარაციაში ნათქვამია,
მაქვს ფუნქცია მოუწოდა f2 რომ ელოდება ერთი არგუმენტი, f,
და მაშინ იგი მოუწოდებს, რომ ფუნქცია, ვ, რომელიც
მიღებულ იქნა, როგორც არგუმენტი არ არგუმენტები თავად.
ასე, რომ, შესაძლოა, უკვე გაუგებარია.
თუ ჩვენ გვესმის, რომ ეს f2 იღებს f1 როგორც არგუმენტი, და შემდეგ შიგნით f2,
ვ იღებს called-- რაც იმას ნიშნავს, რომ ეს ხაზი კოდი,
მას შემდეგ, რაც ამ ორი ხაზი კოდი, შედეგების "Hello"
იბეჭდება კონსოლი.
>> ის ფაქტი, რომ ჩვენ შეგვიძლია გაივლის ფუნქციები გარშემო, როგორც ღირებულებები
მთავრდება ერთ-ერთი ყველაზე ძლიერი თვისებები JavaScript
როგორც პროგრამირების ენა.
გარეთ ყველა რა რამ მას შეუძლია გააკეთოს,
ისევე, როგორც თვისება ენის თვალსაზრისით გზა
რომ ეს ქმნის რამ ადვილია პროგრამა და საშუალებას
რამ, რაც არ არის, განსაკუთრებით კარგად შეეფერება ვებგვერდი,
ფუნქციური პროგრამირების და ფუნქციური პროგრამირების ასპექტების JavaScript
არის ერთ-ერთი ყველაზე ძლიერი ცნებები,
არსებობს JavaScript-- თუ მკითხავთ.
ზემოთ.
>> ასე რომ, შემდეგი რამ.
გარდა იმისა, რომ ფუნქციური, არსებობს ასევე ელემენტები JavaScript
რომ ობიექტზე ორიენტირებული, რომელიც არის ერთ ერთი ძალიან
პოპულარული ხმაურს სიტყვა კომპიუტერულ მეცნიერებათა.
ობიექტზე ორიენტირებული პროგრამირების არის ძალიან პოპულარული რამ.
JavaScript აქვს მობილური, სადაც მე მჯერა, რომ ყველა ღირებულება არის ასევე
ობიექტი, რაც იმას ნიშნავს, რომ ყველა ობიექტი მართავს ერთად გარკვეული რაოდენობის ღირებულებებს.
ასე რომ, ღირებულებები, რომლებიც მარტივი, როგორიც რიცხვი, როგორც Varx შეადგენს 5,
რომ ობიექტი მხოლოდ დაასრულა, რომ ერთ-ერთი ღირებულება.
>> მაგრამ ჩვენ შეგვიძლია ასევე წარმოვიდგინოთ სიტუაცია, , სად შეგვიძლია ვიფიქროთ სიტუაციაში C
სადაც გვინდოდა ამის გაკეთება რაღაც structs,
მაგალითად, რომ დასრულდება რამდენიმე ღირებულებები ერთად და მარკა
ეს ნამდვილად ადვილად გაივლის რამ გარშემო.
ეს მაშინ, როდესაც ობიექტი JavaScript.
>> ეს მნიშვნელოვანია გვახსოვდეს, როცა ამბობენ, რომ ობიექტი შეფუთული
გარკვეული რაოდენობის ღირებულებებს ერთად, რომ ფუნქციები, ასევე
ღირებულებები, რაც იმას ნიშნავს, რომ ფუნქციები შეუძლია ასევე შეიძლება იყოს შიგნით JavaScript ობიექტი.
და იმის გამო, რომ მნიშვნელოვანია, ის არის, რომ, ჩვენ კი ხშირად
ვფიქრობ, მოუწოდებს მეთოდი ობიექტი, რომელიც არის
პოპულარული ტერმინი სხვა პოპულარული ობიექტის ორიენტირებული ენებზე,
ერთი განსხვავებები აქ ის არის, რომ ყველა რომ მეთოდის JavaScript
არის ღირებულება ინახება შიგნით ობიექტი რომელიც ახორციელებს ზოგიერთი action-- შესაძლოა
გამოყენებით სხვა ღირებულებები, რომლებიც ქვეყნის შიგნით რომ ობიექტი, მაგრამ არ არის აუცილებელი.
ასე რომ, თქვენ წარმოიდგინეთ სიტუაცია, მე ვხვდები ცოტა გიჟები გზა,
სადაც თქვენ მოუწოდა მეთოდი ერთ-ერთი ობიექტის კიდევ ერთი ობიექტი, მაგალითად.
ასე რომ, ეს ცოტა ხმაურიანი, რომ გზა.
>> თქვენ ასევე შეგიძლიათ შეცვალოთ მეთოდები , რომლებიც დაკავშირებულია ერთად ობიექტი
მინიჭებით, რომ მეთოდი ახალი ფუნქცია, რომელიც არის ასევე
საკმაოდ განსხვავდება სხვა ობიექტის ორიენტირებული ენებზე, სადაც
ერთხელ ვაცხადებთ, ობიექტი და instantiate ის,
ჩვენ ვერ შეცვლის მეთოდები, რომლებიც დაკავშირებული ობიექტი აღარ.
ასე რომ, საკმაოდ განსხვავებული.
ზემოთ.
>> ასე რომ, აქ არის მაგალითი, პირველ რიგში, ობიექტის მოქმედებაში.
ეს არის ის, რაც ე.წ. ზოგადი ობიექტი, რომელიც
იმას ნიშნავს, რომ მას არ აქვს არანაირი კერძოდ სახელი, ამჯამად არ აქვს კლასი,
ეს მხოლოდ რამდენიმე შესაფუთი ღირებულებებს.
და გზა, რომელიც გამოიყურება, ჩვენ უნდა ეს გარე წყვილი Curly braces აქ
რომ მიუთითოს JavaScript და აცხადებენ, რომ ეს არის ობიექტი.
ღირებულებები შიგნით თითოეული ღირებულებების შიგნით
ობიექტის, რომელიც უნდა იქნება გახვეული ერთად.
და შიგნით რომ ობიექტი, ჩვენ მაშინ უნდა გასაღები ღირებულება წყვილი,
სადაც მთავარ ეხება სახელი ღირებულება შიგნით ობიექტი,
და სხვა side-- საპირისპირო მსხვილი ნაწლავის აქ
არის ფაქტობრივი ღირებულება რომ უნდა იყოს შენახული.
>> ასე რომ, ხედავთ, რომ ჩვენ გვაქვს გასაღები მოუწოდა fn ღირებულების sam,
მოჰყვა მძიმე, განაცხადა, გადატანა მომდევნო შესვლის.
მაშინ გასაღები მოუწოდა შესახვევში, ღირებულება მწვანე,
მოჰყვა მძიმე, მოჰყვა "ბეჭდვა"
რომელიც აპირებს აქვს ფუნქცია მნიშვნელობა რომ აპირებს ამისათვის ხაზი კოდი.
ავიღოთ ნაბიჯი უკან და ჩააგდეთ რა ხდება აქ.
ასე რომ, ეს ცოტა რთული, და ჩვენ ვხედავთ, რაღაც ახალი
პირველად.
"ამ" სიტყვით არის ახალი რამ ჩვენ ვხედავთ აქ, და რა ეს იმას
არის, ეხება მიმდინარე ობიექტის ფარგლებში, უფლება?
ასე რომ, როდესაც ჩვენ ვამბობთ, რომ ეს მიუთითებს ყველა გზა უკან
მთელ ამ object-- როდესაც ჩვენ გავაკეთებთ this.fn,
ჩვენ ვაპირებთ, რომ წავიდეთ ყველა გზა უკან ეს ობიექტი, წასვლა fn მნიშვნელობა
და მიიღეთ sam, გაიყვანოს მას ყველა გზა უკან, გამყარებაში მას აქ, და შემდეგ გადაადგილება.
>> აუდიტორია: ასე რომ, კითხვის, არის რომ კეთდება იმიტომ პარამეტრი
განმარტება?
SAM GREEN: ასე რომ კითხვა იყო, არის კითხვის კეთდება იმიტომ პარამეტრი
განმარტება?
ჰო, აბსოლუტურად.
რა მოხდება, აქ არის, ამ dot ამბობს, რომ JavaScript,
OK, მე მისაღებად გარკვეული მნიშვნელობა ამ ობიექტის თავს.
და მაშინ ყველაფერს ვეძებოთ შესვლის მოუწოდა fn, და თუ ის თვლის,
ის ყველაფერს დაბრუნების რომ value-- ასე რომ, ეს sam.
მაგრამ მე ვერ აკრეფილი ის, რომ არ იყო განსაზღვრული აქ,
და მაშინ ის უბრალოდ დაბრუნდეს undefined-- რომელიც
არის, რაც JavaScript- ს შეუძლია ამის გაკეთება, რაც შეიძლება ჰქონდეს სარგებელი,
მაგრამ ეს also-- თუ თქვენ მიიღოს typo, ეს შეიძლება გამოიწვიოს უცნაური შეცდომები.
ასე რომ, ეს მხოლოდ ცდილობენ რასაც თქვენ გეტყვით, ის, რომ
და ის არ აპირებს შესახებ, თუ არ მიაგნეს.
ეს კიდე უბრალოდ ვთქვა, მე არ იპოვოს იგი, და მაშინ გადაადგილება.
ასე რომ, ეს იქნება განუსაზღვრელი, პლუს ცარიელი, პლუს გვარი.
ჰო.
და მაშინ ჩვენ ვხედავთ, რომ თუ ჩვენ შეიძლება მერე ქვემოთ და access--
და მოვუწოდებთ tf.print () ერთად ფრჩხილებში.
ეს ვაპირებ მოვუწოდო, რომ ბეჭდვითი ფუნქციის არგუმენტები არ, არა?
მაგრამ თუ ჩვენ უბრალოდ თქვა tf.print () მძიმით გარეშე ფრჩხილებში,
ყველა, რომ არ კეთდება დახევის ის ფუნქცია საწყისი ღირებულება,
მაგრამ არა რეალურად უწოდა.
ზემოთ.
HUGH Zabriskie: თუ ჩვენ ობიექტი?
SAM GREEN: რა თქმა უნდა, რომ გავაკეთოთ.
ასე რომ, მე შეიძლება გადავიდეს ეს მაგალითად კონსოლი.
შეგვიძლია წარმოვიდგინოთ, რომ მე მაქვს ობიექტი.
ასე რომ, ეს არის მარტივი ობიექტი.
ეს არის ობიექტი, რომელიც შეიცავს ორ ღირებულებები ორი გასაღებები, ორი ძირითადი მნიშვნელობა
წყვილი.
ასე რომ, მე შეიძლება მაშინ შედიხართ ღირებულება ინახება შიგნით ეს ობიექტი ამით x.x1,
მაგალითად, მე და 1 უკან.
გარდა ამისა, x.x2, მიიღოს, რომ მნიშვნელობა უკან.
>> და ახლა მართლაც მაგარი რამ არის, მე არ შემიძლია რეალურად დაამატოთ რაღაც, რომ ეს ობიექტი
მას შემდეგ, რაც მე შექმნა.
ასე რომ, თქვენ წარმოიდგინეთ, მოდით მე მაქვს ფუნქცია.
>> HUGH Zabriskie თქვენ უნდა გავაკეთოთ Shift-Enter.
>> SAM GREEN: ო, ეს არის შემაშფოთებელი.
რა არ მოგწონთ?
Oh.
აქ ჩვენ მივდივართ.
ზემოთ.
>> ასე რომ, მე მხოლოდ ის ეს ფუნქცია, ვ, რომ
აპირებს მისვლას მიმდინარე ობიექტი და ბეჭდვითი this.x1.
ასე რომ თუ მე მოვუწოდებ f მიერ თავისთავად, არაფერი ხდება
უნდა მოხდეს, უფლება, რადგან არ არსებობს x1 სფეროში ობიექტი ის გულისხმობდა.
მაგრამ, თუ მე ვიტყვი, x.f = f, და მერე დარეკეთ x.f (), მე ვაპირებ, რომ დავუბრუნდეთ 1.
ეს f ფუნქცია არის დაკავშირებული ობიექტი x,
რომელსაც აქვს გასაღები მოუწოდა x1 ასოცირებული ღირებულება 1,
ასე რომ, როდესაც ჩვენ მოვუწოდებთ this.x1, ეს აპირებს იპოვოს ის, რაც ის ეძებს
და შეძლებს ბეჭდვა მნიშვნელობა out.
ასე რომ, მხოლოდ ერთი მაგალითია სახის გიჟები რამ
შეგიძლიათ გააკეთოთ ობიექტების JavaScript.
>> ასე რომ, ვერსია იყო generic ვერსია, რაც იმას ნიშნავს,
რომელიც ჩვენ შევქმენით ობიექტი ამ ფრჩხილებში notation-- გაუწიოს notation,
rather-- და ეს მოსახერხებელი თუ ჩვენ უბრალოდ გვინდა
ერთი ინსტანციის კონკრეტული ობიექტი, მაგრამ თუ ჩვენ გვინდა, რომ უფრო მეტი, ვიდრე ერთი
იგივე?
და პასუხი, რომ კითხვა არის, არსებობს რამ,
მოუწოდა კატეგორიები JavaScript, ასევე.
ჩვენ შეგვიძლია შევქმნათ ფუნქცია, აკეთებს გარკვეული ინიციალიზაციისას
ერთი უცხო ობიექტი, და ჩვენ მინდა ვთქვა, მინდა,
ჩემი კლასის ისე სახელი საქართველოს მრავალჯერადი object--
უდრის ფუნქცია, რომელიც ადგენს ეს.
ასე რომ ეს იქნება ექვივალენტური რომ ქმნის ობიექტი, რომელიც
იქნება უბრალოდ მინდა, Curly გაუწიოს, ქუჩა, მსხვილი ნაწლავის,
ეს არის ტექსტი, მძიმით, Curly გაუწიოს.
ეს იქნება ზოგადი ობიექტის ჩვენ ინიციალიზაცია,
ერთად ერთი განსხვავება ყოფნის შემდეგი ხაზები შექმნა პროტოტიპი, რომელიც
იმას ნიშნავს, რომ დაუსწრებელი გასაღები, რომელიც ჩვენ დაამატოთ ჩვენი ობიექტი, რომელიც
აქვს მნიშვნელობა აქ ჩამოთვლილი.
რაც იმას ნიშნავს, რომ, როდესაც შევქმნა ახალი მაგალითად ამ MyClass ობიექტი,
ის აპირებს წინასწარ ააშენა შიგნით ეს მნიშვნელობა მოუწოდა ქ და სხვა ღირებულება
მოუწოდა myPrint, რომელიც იქნება ფუნქცია.
გასაოცარია.
>> შესანიშნავი.
ასე რომ, ბოლო რამ ვთქვათ, JavaScript
ის არის, რომ ეს მართლაც სასარგებლოა, რა უწოდებენ ასინქრონული ოპერაციების.
ასინქრონული საშუალება არის, რომ ჩვენ შეგიძლიათ დაველოდოთ რამდენიმე ოპერაცია
დასრულებას სანამ ჩვენ გადასვლა , მაგრამ გადაადგილება მანამ, სანამ
და მაშინ აქვს რაღაც მოხდება მოგვიანებით.
და რას ვგულისხმობ რომ არის, თქვენ შეგვიძლია წარმოვიდგინოთ სიტუაცია, სადაც
თქვენ თხოვნით, ზოგიერთ სერვერზე სადღაც,
და ის აპირებს, რომ გამოგიგზავნით თავში რამდენიმე დიდი ბლოკი მონაცემები, არა?
და თქვენი მომხმარებლის შეიძლება ლოდინი ამასობაში, რომ უნდა მოხდეს,
და არაფერი შეიძლება იყოს მიმდინარეობს იმ დროს.
მაგრამ ეს არ არის დიდი დიზაინი, უფლება?
თქვენ არ მინდა, რომ ვებ გვერდზე გაყინვას.
რა მოხდება, თუ მომხმარებელს სურს დააწკაპუნეთ ჩამოსაშლელი მენიუ?
ეს არ არის დიდი დიზაინი ნიმუში.
ამის ნაცვლად, ძირითადად, რა JavaScript არ არის ნათქვამი,
OK, გავაკეთოთ ეს ოპერაცია ასინქრონულად.
ასე რომ, დაველოდოთ იმ ფონზე, და მაშინ, როდესაც ოპერაცია კეთდება,
დარეკეთ უკუგამოძახება ფუნქცია მოვუწოდებ ზოგიერთი ფუნქცია,
რომ ზოგიერთი action-- სიგნალი, რომ ოპერაციის ველოდებოდით დასრულდება
დამთავრდა.
და იმის გამო, რომ სუპერ ძლიერი არის, ჩვენ შეგვიძლია გავაკეთოთ რაღაც, გაივლის არგუმენტი,
რაღაც, და მაშინ დაველოდოთ რაღაც უნდა მოხდეს.
მაშინ, როდესაც, რომ რაღაც ასრულებს, ჩვენ შეგვიძლია მოვუწოდებთ გადმორეკე.
ეს არის ძალიან მოსახერხებელი, რადგან იგი საშუალებას ჩვენს გავაკეთოთ რამ Web აუდიო API,
მაგალითად, როგორიცაა ჩატვირთვა აუდიო ფაილი სერვერზე
გარეშე უნდა ველოდოთ მთელი აუდიო ფაილი დატვირთული,
რომელიც იქნება ნამდვილად ცუდი მომხმარებლის, გამოცდილება.
ზემოთ.
>> ბოლო რამდენიმე აღნიშნავს გამართვის, რადგან ეს
არის ის, რაც თქვენ ვაპირებთ უნდა გავაკეთოთ როგორც ნაწილი თქვენი პროექტი, გარანტირებული.
მე ვთქვი, JavaScript კონსოლი.
ეს სუპერ სასარგებლო ფუნქცია ყველა თანამედროვე ბრაუზერებში,
ჩვენ ნამდვილად მოგიწოდებთ მიიღოთ კომფორტული გამოყენებით თქვენი კონსოლი,
თუ თქვენ გსურთ კარგად JavaScript.
ეს სუპერ მოსახერხებელი გამართვის, მაგრამ ეს ასევე არის
ნამდვილად სასარგებლო მჭიდროდაა თუ როგორ გამოიყენოთ API.
ეს საშუალებას იძლევა ნამდვილად მარტივი ექსპერიმენტი
გარეშე აკრიფოთ ზოგიერთი კოდი და შემდეგ კომპილირება.
თქვენ არ გაქვთ ამის უფლება ნაბიჯები.
შეგიძლიათ უბრალოდ დაწერა ზოგიერთი კოდი შევიდა ხაზი,
და შემდეგ მიიღოს უშუალო კავშირი თუ არა, რომ ხაზი კოდი
worked-- ძალიან მოსახერხებელი.
>> და ასევე, მხოლოდ ერთი ტექნიკური note-- JavaScript კონსოლი არის მაგალითი
ერთი REPL-- ასე რომ, R-E-P-L, REPL, რომელიც დგას წაკითხული, შეაფასოს,
ბეჭდვითი ციკლი.
თქვენ აპირებს აკრიფოთ რაღაცები , ეს წაიკითხა, რაც თქვენ აკრეფილი,
ის ყველაფერს შეაფასოს იგი, და ეს კიდე ბეჭდვა გამომავალი, და მერე კიდე დაიწყება ისევ.
ეს გაძლევთ საშუალებას სწრაფად წავიდეს წრეების iterating, რომელიც არის მართლაც მაგარი.
>> ვფიქრობ, რეალური ბოლო note-- ეს ფაქტობრივი ბოლო შენიშვნა, დიახ.
როგორ უნდა რეალურად გამოვიყენოთ JavaScript?
ასე რომ, პირველ რიგში, ჩვენ შეგიძლიათ იმპორტი ის გამოყენებით script tag
ზედა ან ბოლოში HTML ფაილი სადმე შიგნით HTML ფაილი,
ნამდვილად.
და შიგნით სცენარი აქვს, არსებობს ორ ქვე-გზები იმპორტიორი JavaScript.
პირველი არის ის, რომელსაც აქვს ცალკე JavaScript ფაილი
რომ ჩვენ იმპორტი მთლიანად, ან მიერ, რომელსაც ფართობი კოდი კინოსცენარზე
უნდა დაიწყოს, და მაშინ წარმატებული სკრიპტი დასრულდება.
და მაშინ ჩვენ უბრალოდ დაწერა JavaScript შიგნით HTML ფაილი.
ეს არის ორი გზა.
თქვენ არ გაქვთ შიგნით HTML.
აუდიტორია: ერთი უკეთესია, ვიდრე სხვა?
SAM GREEN კითხვა იყო, ერთ-ერთი უკეთესია, ვიდრე სხვა.
ასე, რომ, როგორც კოდირების სტილი პრაქტიკა, და ასევე ის მსგავსად დიზაინი პრაქტიკაში.
არსებობს ორი მიზეზი რატომ შეიძლება იყოს უკეთესი.
პირველი ის არის, რომ რაც თქვენი კოდი ბევრი უფრო იკითხება, თუ ყველა თქვენი HTML
არის ერთი ადგილი, ყველა თქვენი CSS არის კიდევ ერთი ადგილი, ყველა თქვენი JavaScript
არის მესამე ადგილი.
მარჯვენა?
მე ვფიქრობ, რომ ჩვენ უნდა უკვე ესაუბრა ამის შესახებ sections-- როგორიცაა CSS-- რა
, რომ არის და ეს გრძელდება ხშირად სხვა ფაილი.
ასე რომ, მსგავსი სახის კონცეფცია აქ.
თქვენ ასევე შეგიძლიათ წარმოიდგინოთ, რომ JavaScript იქნებოდა გამოყენებული ერთზე მეტი
HTML გვერდი, ან შესაძლოა ბევრი HTML გვერდების,
და რომელსაც, რომ JavaScript refactored ერთ
ფაილი, რომელიც შეგიძლიათ იმპორტი უფრო, ვიდრე ერთ ადგილას
საშუალებას იძლევა კოდი უნდა იყოს უფრო მეტი maintainable.
თქვენ წარმოიდგინეთ მიღების ერთ-ერთი შეცვლის JavaScript
და რომელსაც უნდა შეცვალოს ეს 100 სხვადასხვა ფაილები.
და ნაცვლად ჩვენ შეგვიძლია მხოლოდ შეცვლის ერთი, რომელიც არის გზა უფრო ძლიერი.
ხომ არ უპასუხოს შეკითხვას?
ზემოთ.
>> ჩვენ შეგვიძლია ასევე ჩაწერეთ შევიდა კონსოლი, როგორც ჩვენ აღვნიშნეთ.
ისევ და ისევ, ერთი ბოლო note-- ვებ აუდიო აგებული,
თქვენ არ უნდა ჩატვირთოს არაფერი.
ზემოთ.
არსებობს რაიმე კითხვები, გაქვთ ნებისმიერი მეტი შეკითხვები JavaScript,
სანამ ჩვენ გადასვლა?
>> აუდიტორია: [INAUDIBLE]
SAM GREEN ყველა უფლება, მაგარი.
ასე რომ, ახლა ის აპირებს ვისაუბროთ API.
>> HUGH Zabriskie ზემოთ.
მადლობა, სემ.
>> SAM GREEN: რა თქმა უნდა.
HUGH Zabriskie: გასაოცარია, ასე რომ ჩვენ გადაადგილება JavaScript.
ასე რომ, ჩვენ ვისაუბრეთ ზოგიერთი საგნები JavaScript,
და იმ ცვლადების, ფუნქციები, ობიექტების, ფუნქციებს ცვლადები,
ასინქრონული loading.
ეს არის ყველაფერი, რომ თქვენ ვხედავ, როგორც თქვენ იყენებთ ვებ აუდიო.
ასე რომ, ჩვენ უბრალოდ აპირებს გაიგო ეს პირველი მაღალ დონეზე.
>> ეს არის API ასე რომ, ეს არის ის, რომ აგებული, როგორც სემ განაცხადა,
მარჯვენა JavaScript რომ გამოიყენოთ კონსოლი.
და ეს რეალურად, ისევე, როგორც C ++ კოდი რომ მართლაც ჩაშენებული Chrome
და Firefox, და ყველა ამ ბრაუზერები.
ასე რომ, მთავარი იდეა Web აუდიო ის არის, რომ თქვენ უნდა
ამ სახის მილსადენი აუდიო, არა?
ასე რომ, თქვენი აუდიო მონაცემები მოდის გარკვეული ფორმით.
>> არსებობს ერთგვარი სამი ძირითადი forms-- თქვენ გაქვთ Oscillator, რომელიც
ქმნის sine ტალღა, კოსინუსი ტალღა, ჩვენ ვაპირებთ, რომ ნახოთ როგორ მუშაობს.
კიდევ ერთი ძალიან გავრცელებული, რა თქმა უნდა, ეს არის MP3.
იქნებ იწყება სიმღერა, და მაშინ
გსურთ ზოგიერთი ფილტრაცია რომ და გამომავალი
that--, რომელიც შეიძლება იყოს შესაძლო წყარო.
და მაშინ მართლა მაგარი ერთი მიკროფონი.
ასე, რომ თქვენ შეგიძლიათ გამოიყენოთ რამდენიმე ძალიან ძირითადი ზარები JavaScript
უნდა მიიღოთ დაშვება მიკროფონი, და ასე რომ, თუ თქვენ
მინდოდა app მოსწონს მოედანზე დეტექტორი,
მაგალითად, რომ იღებს თქვენი ხმა და ფიგურები
pitch-- ძალიან მარტივი გზა, რომ.
შეგიძლიათ უბრალოდ სახის წაიკითხა ეს წელს, გაერკვნენ, სიხშირე,
და შემდეგ გამომავალი ნომერი.
ამიტომ, ჩვენ დავინახავთ, როგორ მუშაობს, ისევე.
>> დანიშნულების ძირითადად სადაც აუდიო მონაცემების გამომუშავება.
ასე რომ, ზოგადად, ასეთი თქვენი ლეპტოპი მშობლიურ.
სხვა ვარიანტები, როგორიცაა ScriptProcessorNode--
ჩვენ კიდევ კვანძების second-- მაგრამ ძირითადად,
ან თქვენ აყენებს ხმის out თქვენი კომპიუტერის მეშვეობით მშობლიურ,
ან თქვენ სახის ჩაწერა, ასე რომ, თქვენ შენახვის იგი როგორც აუდიო მონაცემები.
ასე რომ, შესაძლოა, თუ ვინმე ქმნის მუსიკა თქვენი app და შემდეგ
გსურთ ჩაიწეროს, რომ და შესაძლოა, როგორც ექსპორტი, ეს SoundCloud, მაგალითად
რომ იქნებოდა ერთი გზა უნდა გააკეთოს, რომ.
ყველა fun stuff, რომელიც ჩვენ ვსაუბრობთ,
ხდება ამ ორ წერტილს შორის, სადაც ჩვენ ჩატვირთვა მუსიკა
და შემდეგ დაბეჭდავს მას.
>> ამიტომ, მე ვაპირებ, რომ ვსაუბრობთ ხუთ ეტაპები აუდიო წარმოების მეორე.
ჩვენ გვაქვს ამ რამ მოუწოდა AudioContext, რომელიც
ეს არის პატარა გადატანა აქ ვხედავთ.
ძირითადად რა AudioContext is-- თუ ჩვენ წასვლა JavaScript კონსოლი ახლა,
ჩვენ შეგვიძლია შევქმნათ ერთი ახლავე.
მხოლოდ მაგალითია REPL, არა?
ჩვენ კითხულობს, შეფასებისა და ბეჭდავს.
>> AudioContext არის გლობალური სახელმწიფო.
ეს struct, რომ ეს ობიექტი აქ, და ეს ინახავს ინფორმაციას
რამ, რომ მიმდინარეობს ეკრანზე დაკავშირებული აუდიო.
ერთ-ერთი მაგალითია მიმდინარე დრო.
ეს გიჩვენებთ ნომერი წამში, ძალიან ზუსტად,
მას შემდეგ, რაც ვებ-გვერდზე დატვირთული.
ასე რომ, ეს არის ძალიან სასარგებლო პატარა ქონება, რომელიც შეგიძლიათ გამოიყენოთ.
ეს წაკითხული only-- ვფიქრობ, რეალურად შეგიძლიათ ცდილობენ ის მნიშვნელობა.
ეს გეტყვით მითითებული ეს, და მაშინ თუ დაბეჭდეთ
ერთხელ ის პრაქტიკულად არ საკმაოდ მუშაობა.
ასე რომ, არსებობს მხოლოდ წაკითხვადი თვისებები JavaScript.
ეს არის მართლაც სასარგებლოა, თუ თქვენ სახის სინქრონიზაციისთვის
ბევრი სხვადასხვა ინფორმაცია, როდესაც თქვენ
სახის სათამაშო სხვადასხვა ხმები.
>> სხვა ნამდვილად სასარგებლო ერთი კონტექსტში დანიშნულების.
ნამდვილად, თუ თქვენ დაინტერესებული, რა ცდილობს ამ საკუთარი console უფლება
ახლა.
ასე რომ, ეს არის AudioDestinationNode.
ძირითადად რა ამ ამბობს, სად არის გამომავალი აპირებს?
ასე რომ, არსებობს ორი რეალური ვარიანტი აქ.
როგორც წესი, ძირითადად მხოლოდ თქვენი მშობლიურ,
ასე AudioDestinationNode ძირითადად უბრალოდ ამბობს
არსებობს ნულოვანი შედეგები ხმა მომავალ წელს, გაიგზავნა სპიკერი.
ასე რომ, ზოგადად, თქვენ არ უნდა ითამაშოს, რომ.
თუ თქვენ დაინტერესებული რეალურად გამოყენებით ScriptProcessorNode ჩაწერა,
ნამდვილად გადაღება me ელექტრონული შემდეგ იმიტომ, რომ ის
ცოტა უფრო რთული.
მაგრამ ზოგადად, თქვენ მხოლოდ ამ სახის საქართველოს outputting ხმის გარკვეული ფორმით.
ასე რომ მაგარი, ჩვენ ხტომა უკან აქ.
აუდიტორია: მე ბოდიში.
HUGH Zabriskie: ჰო.
აუდიტორია: მე ვიცი, თქვენ თქვით გაიგო თქვენ მოგვიანებით ჩაწერა.
შეგიძლიათ ინტერფეისის რომ Pro Tools?
>> HUGH Zabriskie: With Pro Tools?
მოდი ვნახოთ.
მე ასე არ ვფიქრობ.
ასე რომ აპირებს კლიენტს შორის, რომელიც არის JavaScript
კონსოლი, და თქვენი ფაქტობრივი კომპიუტერი, ზოგადად
რაღაც რომ სახის საქართველოს მის საზღვრებს გარეთ, თუ
ნება, სახის ბუნების the-- ეს არის სახის დიზაინის რამ,
მაგრამ თქვენ შეეცადეთ ბრაუზერის ცალკე მომხმარებელი ფაქტობრივი კომპიუტერი.
საერთოდ, ერთადერთი, რაც თქვენ შეუძლია ხელმისაწვდომობის მიკროფონი ან კამერა.
თქვენ არ შეუძლია, მე არ ვფიქრობ, გამოიყენოთ Pro Tools.
თუმცა, თუ თქვენ ის სიმღერა Pro Tools,
ექსპორტი, რომ თქვენ შეიძლება ჩატვირთვა, რომ აქ, გავფილტროთ ის, მაგალითად,
პროცესი, რომელიც, და ჩაიწეროს, რომ შევიდა აუდიო Destination-- ან, no-- სფეროს
პროცესორი Node.
და მაშინ იქიდან, თქვენ შეიძლება ექსპორტის, რომ SoundCloud, თქვენ
შეიძლება გაგზავნას იგი ელექტრონული ფოსტის, ან რასაც თქვენ გსურთ იქიდან.
>> თუმცა, არსებობს სახის უმნიშვნელო ბარიერი შორის მიღების მუსიკა თქვენს კომპიუტერში
და მიღების მუსიკა ონლაინ რეჟიმში.
>> SAM GREEN: და არ არის უნიკალური ამ API.
ეს არის უსაფრთხოების ფუნქცია Chrome, და მე ვფიქრობ, რომ ყველა სხვა თანამედროვე ბრაუზერში.
ბრაუზერი არის თვითმმართველობის შეიცავს.
ასე მაგალითად, ვებ გვერდზე არ შეუძლია გამოყენება JavaScript გახდეს ხმის
on თქვენს მშობლიურ, მაგალითად.
ან ვერ გახდება თქვენი კომპიუტერის გამორთვა.
და არ არსებობს შუალედური წერტილი შორის ორი რამ, არა,
ასე რომ არც თქვენ გაქვთ სრული აბსტრაქცია,
ან თქვენ გახსენით უსაფრთხოების ხარვეზი გაქირავების
პროგრამისტი ცუდი ზრახვები გააკეთებს რასაც უნდათ თქვენი კომპიუტერი.
ამიტომაც არის, რომ Chrome თვითმმართველობის შეიცავს.
>> HUGH Zabriskie: ჰო.
ამას რამე აზრი აქვს?
ზემოთ, ზემოთ.
მე უბრალოდ აპირებს ნახოთ მაგალითია ერთი.
ეს არის საკმაოდ ბევრი როგორც რამდენადაც თქვენ, იმ თვალსაზრისით,
წვდომის მომხმარებლის კომპიუტერში.
თუ თქვენ გაქვთ USB კლავიატურის plugged in, თქვენ შეგიძლიათ გამოიყენოთ რაღაც მოუწოდა ვებ
MIDI API, რომელიც ჩვენ არ ნამდვილად ვილაპარაკოთ აქ,
მაგრამ ეს არის კიდევ ერთი API, რომ ჩაშენებული მინიმუმ Chrome-- ერთხელ,
ეს არის, თუ რატომ გვიყვარს Chrome-- მე ვფიქრობ, Firefox და Safari,
ეს არის მარტივი რამ google-- სხვადასხვა ბრაუზერები
სხვადასხვა მხარდაჭერა, რომელიც APIs მათ არ შეასრულეს.
მაგრამ თუ თქვენ სურდა შეაერთედ კლავიატურა და მუშაობა, რომ ინფორმაცია,
სახის გაგზავნას კლავიატურის ინფორმაციის კომპიუტერი
და შემდეგ გამოიყენოთ, რომ ამჟამად, ამ API სადაც თქვენ მინდა იყოს სამუშაო, რომ.
>> ზემოთ.
კარგი.
ასე რომ, სწრაფად მოძრავი აქ.
როგორ ვაკეთებთ დრო?
>> დინამიკები 1: 15-მდე.
>> HUGH Zabriskie: 15 წუთი დარჩა?
OK, მაგარი.
ასე რომ, ჩვენ რასის წინ აქ.
>> ასე რომ, ძირითადად, მთავარია ფიქრი ეს როგორც მილსადენის
ის არის, რომ ყოველი ნაბიჯი მილსადენის არის მთელი რიგი აუდიო კვანძების.
ჩვენი წყაროს ინფორმაციით, ვთქვათ, არის Oscillator.
ჩვენ უნდა შევქმნათ oscillator კვანძი.
და ეს არის მხოლოდ სახის პატარა ფუნქცია
და ისინი ყველა საფუძველზე გარეთ აუდიო კონტექსტში აქ.
>> აუდიტორია: როცა ეს განაცხადა, oscillator, ნიშნავს
სინამდვილეში ფაქტიურად აპირებს ორი სხვადასხვა ბოძები და უკან?
>> HUGH Zabriskie: არა, ეს იგივეა, ციფრული წარმომადგენლობა.
სინამდვილეში განხორციელებული C ++.
მე რეალურად არ ვიცი specs როგორ ეს რეალურად განხორციელდება,
მაგრამ ეს ყველაფერი მუშაობს როგორც ბინარული მონაცემები.
სინამდვილეში, yeah.
ეს იქნება ამბობდა, მე ვერ რეალურად, თუ თქვენ დაინტერესებული,
მე ვერ გამოგიგზავნით ცოტა მეტი ინფორმაცია, თუ როგორ waveforms
ინახება, რომელსაც ციფრულ ფორმატში.
OK, მაგარი.
>> ასე რომ, ჩვენ მომტანი ტონი მოსწონს sine ტალღის ან რამე მაგდაგვარს, შესაძლოა,
440 ჰერცი.
ჩვენ ვქმნით Oscillator.
თუ გვინდა, რომ მითითებული მოცულობა, ჩვენ დაკავშირება არაფერი რომ GainNode,
რომელიც ჩვენ შეგვიძლია გავაკეთოთ ერთად .creategain.
რომელიც ადგენს თქვენი მოცულობა.
თქვენ შეგიძლიათ გადასცეთ, რომ გადატანა ნებისმიერი სხვა options-- კარგად,
ასე რომ, აუდიო ბუფერული წყარო კვანძი, სადაც თქვენ შეიძლება
შესანახად MP3, რომ თქვენ დატვირთული.
>> Biquad ფილტრი ფილტრაცია თუ გსურთ მიიღოს ყველა ბაზის გარეთ
სიმღერა, ან რაღაც მსგავსი.
ღმერთმა ნუ ქნას გსურთ მიიღოს ბაზის გარეთ სიმღერა.
და AudioDestination კვანძის, კიდევ ერთხელ, ჰგავს, სადაც ჩვენი დასრულებასთან არის.
თუ თქვენ ოდესმე დაინტერესებული ხედავს ყველა სხვადასხვა შესაძლო ვარიანტი,
უბრალოდ წასვლა tab და მოდით ავტო-სრული ამუშავება.
და თუ თქვენ შექმნით, თქვენ დაინახავთ ყველა სხვადასხვა რამ, რომ თქვენ შეგიძლიათ შექმნათ.
თქვენ შეგიძლიათ შექმნათ დინამიური script პროცესორები,
მე კი არ ვიცი რა, რომ არის, შერევით არხი შერწყმისა
და არხის სიგნალის გამყოფები და ყველა რომ.
ზემოთ.
>> ასე რომ, ეს მხოლოდ მაგალითად მილსადენი.
ასე რომ, ჩვენ გვაქვს სამი წყაროდან მოდის.
იქნებ ეს არის waveforms, იქნებ ეს არის MP3s.
ერთი გადის ფილტრი, კიდევ ერთი
არც დამახინჯებული სხვა ერთი პანორამირება მარცხენა და მარჯვენა.
ამის გაკეთება შეგიძლიათ ყველა სახის ნივთები და მათ ყველა მისაღებად შერეული გარშემო ერთად,
და შემდეგ მოდის აუდიო ბოლოს, როგორც დანიშნულების.
ეს არის მაგალითი იმისა, თუ რა უფრო რთული Web აუდიო კოდი ჰგავს.
თქვენ შექმნით ყველა ეს სხვადასხვა ობიექტების უფლება აქ
მე არ ვარ დარწმუნებული, რომ ამ.
არა, ეს არ მიუახლოვდით.
კარგი.
>> SAM GREEN თქვენ ამის კონტროლი, Scroll-Up.
HUGH Zabriskie კონტროლის Scroll--
SAM GREEN: არა, არა.
Control--
>> HUGH Zabriskie: Oh, კონტროლის, გადახვევა?
ოჰ, gotcha.
ჰო.
Wow, nope, nope.
კარგი.
მე ამას არ გააკეთებს, რომ.
>> ასე რომ, yeah, ამ პირველი განყოფილებაში აქ, თქვენ ხედავთ
ჩვენ შექმნის ყველა ამ სხვადასხვა კვანძების გარეთ კონტექსტში.
ჩვენ უბრალოდ piecing მათ ერთად მეორე ნაწილი
ამ ფუნქციის მოუწოდა დაკავშირება.
ეს არის ნამდვილად გასაღები ფუნქცია Web აუდიო.
ეს უბრალოდ ნიშნავს, ერთხელ თქვენ კეთდება რაღაც ხმა ერთი კვანძის,
გაივლის მას შემდეგი კვანძის.
ასე რომ, ჩვენ გვაქვს წყარო, ეს აკავშირებს ანალიზატორი,
ანალიზატორი აკეთებს რაღაც ის, ის მიდის დამახინჯება, და ასე შემდეგ,
და დანიშნულების ბოლოში უფლება აქ.
ზემოთ.
OK, ასე რომ, ჩვენ გავაგრძელებთ მოძრავი.
>> Pipeline-- კიდევ ერთხელ, ეს ყველაზე გავრცელებული ნავთობსადენების,
ასე რომ, ჩვენ ვსაუბრობთ ეს ყველაფერი მოსწონს დამახინჯება, პანორამირება, ყველა ამ პერსონალის.
თუ თქვენ ნამდვილად დაინტერესებული გამოყენებით რამ Pro Tools,
იმ ალბათ დაგაინტერესოთ.
თუ არა, იქნებ უბრალოდ მინდა, რომ ითამაშოს ხმა,
ან იქნებ უბრალოდ გვინდა მითითებული მოცულობა ხმა.
ეს არის ორი ყველაზე გავრცელებული სახის მილსადენების აუდიო წარმოება.
>> ისევ და ისევ, გზები შეგიძლიათ მას in, როგორც oscillator-- ასე რომ, მოდით
გავაკეთოთ დემო რომ უფლება აქ.
ამიტომ, ჩვენ ვაპირებთ, რომ შევქმნათ მარტივი აუდიო კონტექსტში აქ,
და რომ ჩვენ ვაპირებთ შევქმნათ ჩვენი Oscillator.
ასე რომ, კიდევ ერთხელ, ჩვენ უბრალოდ ვაპირებ მოვუწოდო შექმნა Oscillator.
ჩვენ ვაპირებთ, რომ მითითებული სიხშირე რომ, 440 ჰერცი, ყველას საყვარელი.
მაშინ ჩვენ დაკავშირება, რომ დანიშნულების point-- რომელიც სპიკერი, ასე რომ
კონტექსტში დანიშნულების.
და ბოლოს, ჩვენ უბრალოდ, ვამბობთ, დაიწყოს ნულოვანი წამი, ახლა, და ჩვენ არ ჟღერს?
>> [გამოიწერეთ]
>> HUGH Zabriskie: აქ ჩვენ მივდივართ.
ეს არის უბრალოდ sine ტალღა.
OK, მაგარი.
და მაშინ ჩვენ შეწყვეტას.
>> აუდიტორია: სად რომ კავშირი მოდის?
>> HUGH Zabriskie: კავშირი?
ოჰ, ალბათ ჩვენი მიკროფონები.
ასე რომ, ჰო, თუ როგორ გავაკეთოთ ეს.
და რეალურად, თუ მქონდა ინახება ეს გაშვებული,
შეიძლება ჰქონდეს სიხშირე მნიშვნელობა, როგორც ეს გაშვებული,
ასე რომ, fun რამ უნდა ითამაშოს გარშემო.
ზემოთ.
რომ ყოველთვის ლამაზი ერთი უნდა წარმოადგინოს.
>> SAM GREEN: ჩვენ არ ვიფიქროთ, რომ, ჩვენ არ?
HUGH Zabriskie: ჰო, რომ არის nasty ერთი.
ასე რომ, ბუფერული loading-- მე ნახოთ მაგალითად, რომ ძალიან ბოლოს.
ეს ჩატვირთვის MP3.
და მიკროფონი, თქვენ გამოიყენოთ მხოლოდ ფუნქცია მოუწოდა Navigator.getUserMedia ()
მოითხოვოს ხელმისაწვდომობის მომხმარებლის მიკროფონი, რომ ინფორმაცია.
>> აი, ფილტრაცია, მე უბრალოდ შეინახოს მოძრავი ეს.
ეს არის საკმაოდ მაღალი დონე, მაგრამ ფილტრები უბრალოდ საშუალებას გაძლევთ
>> [Beeping]
ფილტრაცია ასევე გაძლევთ საშუალებას შექმნას რამ, როგორიცაა ვარდისფერი
ხმაური, ყავისფერი ხმაური, თეთრი ხმაური.
თუ გსურთ შექმნათ სუფთა ხმაური, რომელიც ზოგიერთი ადამიანი მიყვარს სასადილო გარშემო,
თქვენ შეგიძლიათ გამოიყენოთ ვებ-აუდიო ფილტრაცია გაგვაჩნია.
>> აუდიო Panning-- ასე წარმოიდგინეთ, თუ თქვენ წერა თამაში
და გსურთ ხმის ჟღერს, როგორც ის მოდის, ისევე,
სროლა მთელს ეკრანზე, თქვენ შეგიძლიათ გამოიყენოთ არხები აუდიო
შეიქმნას ამ ტიპის დაყვანილი, რომელიც მოსწონს ეს საკმაოდ mathy,
მაგრამ ეს რეალურად მაგარი, თუ თქვენ მუშაობს,
და იქ კარგი გაკვეთილები ის მე გამოგიგზავნით.
ძირითადად, შეგიძლიათ სახის შევქმნათ ხმა
რაღაც ხდება მიერ ამ 3D გზა.
და თუ თქვენ გაქვთ DJ ინტერესი, თქვენ შეგიძლიათ დაიწყოს შერევას და ჯვარი თანდათან უქრებათ სიმღერები.
>> ეს არის მხოლოდ რამდენიმე ძალიან ძირითადი კოდი, ძირითადად რა მე ადრე.
ეს ადგენს მოცულობა Oscillator, ასე რომ, ჩვენ შევქმნათ ჩვენი oscillator
რომელიც ქმნის ტალღოვანი.
ჩვენ შევქმნათ ჩვენი GainNode, მითითებული ჩვენი სიხშირე,
და შემდეგ დაკავშირება oscillator რომ GainNode, რომელიც მაშინ ძირითადად იცვლება
რამდენად სიგნალი ნებადართულია მეშვეობით.
მაგრამ რეალურად, ეს არის ციფრული რამ, ასე, რომ ეს უფრო just-- yeah.
ეს არ არის, რა ხდება რეალურად, მაგრამ ეს, რა ხდება რეალურ ცხოვრებაში
ერთად მომატება.
>> აუდიტორია: --quantization მოცულობის პარამეტრი?
HUGH Zabriskie: ბოდიში?
აუდიტორია: ეს არის quantized მოცულობა პარამეტრი?
HUGH Zabriskie: ჰო.
და ეს არის ერთი რამ, მე ნამდვილად დეფიციტური ჩემს ცოდნას,
როგორ მომატება მუშაობს ციფრული დონეზე.
მე ვიცი, ფაქტობრივი სიგნალები, რომ, ძირითადად,
კონტროლის რამდენად თქვენ გამაძლიერებელი სიგნალი.
ასე რომ, yeah.
მე გამოგიგზავნით მეტი ინფორმაცია რომ, რადგან მე მინდა იყოს საინტერესო რეალურად
იცოდეს უფრო მეტი, რომ.
მაგრამ ძირითადად პარამეტრების არიან, ერთი არის fold--
ხმამაღალი signal-- და ნულოვანი არის სიგნალი, ან თქვენ არ გაუგია sound.
ჩვენ გამოტოვოთ დემო დრო, რომ იმის გამო, რომ ეს, ძირითადად, რა გავაკეთე ადრე.
ისევ და ისევ, Context.Destination არის აუდიო დანიშნულების კვანძის.
გასაოცარია, OK.
>> ამიტომ, მე ვაპირებ გავაკეთოთ სწრაფი ორი demos.
როგორ ვაკეთებთ დრო?
>> დინამიკები 1: 10-ე წუთზე.
>> HUGH Zabriskie: 10 წუთი?
შესანიშნავი!
გასაოცარია.
>> ასე რომ, პირველი მე ვაპირებ გთხოვთ, ეს ე.წ. ჩემი საყვარელი სიმღერა.
ასე რომ, ეს არის მხოლოდ პატარა HTML JavaScript.
ჩვენ ვაპირებთ, რომ ორი ღილაკი გვერდზე ითამაშოს ჩემი საყვარელი სიმღერა
და შეწყვიტოს ჩემი საყვარელი სიმღერა.
მე შეცვალოს ეს.
>> აუდიტორია: საფარის თქვენი მიკროფონი.
>> HUGH Zabriskie: ჰო.
და მე დატვირთული აქ სკრიპტი, რომელიც basically--
და ეს მართლაც სასარგებლო ამისთვის ჩატვირთვის MP3,
ასე რომ, ეს მხოლოდ იღებს დატვირთვის MP3s გზა სწრაფად.
ეს, ძირითადად, მხოლოდ გადატანა.
უბრალოდ რაც პროცესში დატვირთვის MP3s ბევრად უფრო სწრაფად,
წინააღმდეგ შემთხვევაში, თქვენ იყენებთ HTTP მოთხოვნის, სახის მოსწონს, რას ვაკეთებდით
მიმდინარე ცალი კომპლექტი ერთად სერვერი.
ეს მართლაც მახინჯი, თქვენ არ მინდა ამის გაკეთება.
>> ასე რომ, ეს ბიჭი, ბორის Smus დაწერა ნამდვილად სასარგებლო პატარა ინსტრუმენტი მოუწოდა BufferLoader.
ყველა თქვენ არის უბრალოდ გაივლის მას კონტექსტში, თქვენ გაიაროს ეს list--
ან ჰო, ეს არის სია JavaScript?
SAM GREEN: მასივი.
HUGH Zabriskie: ოჰ, ეს არის მასივი, რომ უფლება.
ეს მასივი ბილიკები სხვადასხვა ფაილები.
და მერე გაივლის ფუნქცია.
ეს არის უკუგამოძახება ჩვენ ვსაუბრობთ შესახებ ასინქრონული loading.
ეს იქნება ე.წ. ერთხელ ფაილი დატვირთული.
და რომ ფუნქცია ეწოდება, როდესაც ფაილი დატვირთული იღებს როგორც პერიმეტრზე
მასივი დატვირთული ბუფერი.
ასე რომ ხდება აქ.
ძირითადად, BufferList არის იქნება ერთი value--
ან ის იქნება მასივი ხანგრძლივობა ერთი, რომ აქვს ეს ინდექსი
ნულის მთელი დატვირთული ფაილი MP3.
ასე რომ, რა გავაკეთო როცა დასრულდება loading არის, უბრალოდ
შექმნას ბუფერული წყარო, რომელიც აუდიო ბუფერული წყარო კვანძი.
შემდეგი ნაბიჯი არის მე ჩატვირთვა source.buffer როგორც სრულად დატვირთული ბუფერული
საწყისი BufferList-- ეს ბევრი buffers--
და მაშინ დააკავშირებს აუდიო ბუფერული დანიშნულების.
ასე რომ, თუ რას აპირებს გააკეთოს არის უბრალოდ დააყენა MP3
სწორი გზით გამომავალი, და დაიწყოს დაუყოვნებლივ
საფუძველზე მიღების ამ მოწოდებას.
>> ზემოთ, ასე რომ ვნახოთ ეს მოხდება მოქმედებაში.
ჩემი [INAUDIBLE] აქ, ვნახოთ.
ასე რომ მე უბრალოდ აპირებს დაიწყოს ძირითადი სერვერზე.
ის, რომ რაღაც თქვენ უნდა გავაკეთოთ, თუ თქვენ
მიღების მოთხოვნები ჩატვირთვის ფაილი.
მე ვაპირებ დაიწყოს ძირითადი სერვერზე.
ეს არის ძირითადად თქვენი Pset ახლა ერთი ხაზი,
მაგრამ ეს მხოლოდ იწყება სერვერზე port 80/80.
ასე რომ, ჩვენ მეტი აქ, ჩვენ მიმდინარეობს ჩატვირთვა 80/80,
ჩვენ ვაპირებთ წასვლა ჩემი საყვარელი სიმღერა.
ასე რომ, თუ მე მოხვდა "თამაში ჩემი საყვარელი სიმღერა "ახლა,
ის აპირებს ჩატვირთვა ჩემი საყვარელი სიმღერა და ითამაშოს it--
[მუსიკა - არწივები "ცხოვრების სწრაფი LANE "]
--which ხდება, რომ "ცხოვრება სწრაფი Lane "მიერ Eagles.
ახლა, მე ვერ მოხვდა "Stop ჩემი საყვარელი სიმღერა "და მოთხრობა იგი.
>> [მუსიკა - არწივები "ცხოვრების სწრაფი LANE "]
>> და თუ მე ნუგეშია, რადგან მე გლობალური ცვლადი მეტი აქ
შენარჩუნება სიმღერა ეს ღირებულება, ის რეალურად ახლა აღიარებულია კონსოლი.
ასე რომ, ეს განცხადება ქმნის ჩემთვის.
ასე რომ, რა სათამაშო ახლა, და შემიძლია უბრალოდ დარეკეთ source.stop ()
რომ.
ისე, თქვენ იცით, რა?
უბრალოდ, ასე რომ თქვენ ბიჭები მოვისმინე ეს song-- თქვენ შეიძლება აღიაროს ეს სიმღერა.
>> [მუსიკა - რიკ Astley, "არასოდეს Gonna მისცეს თქვენ UP "]
[მუსიკა - არწივები "ცხოვრების სწრაფი LANE "]
ჩვენ ახლა ყველანი უკვე Rickrolled.
OK, დიდი, მოძრავი.
ზემოთ.
ასე რომ, ეს არის, ძირითადად, მაგალითად, უბრალოდ, თუ როგორ შეიძლება ჩატვირთვა MP3 ფაილი
[მუსიკა - არწივები "ცხოვრების სწრაფი LANE "]
--and ითამაშოს, და შეწყდეს და დაიწყოს იგი.
მე შეიძლება გაკეთდეს გაცილებით მეტი [INAUDIBLE]
>> ბოლო ერთი გავაკეთებ არის, მე გაჩვენებთ [INAUDIBLE].
>> [მუსიკის დაკვრა]
>> ეს იგივეა, ogg.wave.mp3.
მე ვფიქრობ, თუ სწორად მახსოვს, მე აწარმოებს შევიდა გარკვეული საკითხები .m4a,
მაგრამ მე არ ვარ დარწმუნებული, რომ.
მე ვფიქრობ, რომ mp3.wave--
>> [მუსიკა - რიკ Astley, "არასოდეს Gonna მისცეს თქვენ UP "]
>> OK, დიდი.
მე არ უნდა თქვა, რომ.
ყოველ შემთხვევაში, hello.
ასე რომ, ჩვენ ამ ღია.
ასე რომ, ახლა ყველა გავაკეთო არის, მე ძირითადად ის ძირითადი სინტაქსი შექმნა მუსიკა.
ასე რომ, თუ რაღაც, დაამატოთ g4 1, 2, იმას ნიშნავს, რომ, რომელიც,
რჩეულებში ფორტეპიანო შენიშვნა, G4, რომელიც მეოთხე G
up on ფორტეპიანო ბოლოში.
ასე რომ, ეს არის ერთგვარი MIDI საუბარი, ასე რომ, მათ, ვინც მუსიკა საფუძველზე,
ეს არის მხოლოდ MIDI აღნიშნავს.
>> აუდიტორია: ეს არის G შუა C, არა?
>> HUGH Zabriskie: ეს არის G ზემოთ Middle C, რომ უფლება.
>> აუდიტორია: Above ახლო C.
>> HUGH Zabriskie: ჰო.
სინამდვილეში, დიახ.
მე ვფიქრობ, რომ რეალურად გააკეთა ის ერთ-ერთი [INAUDIBLE],
ასე რომ, ეს შეიძლება იყოს octave ზემოთ რომ.
ასე რომ, ვნახოთ.
თუ მე მოხვდა Play--
[განმეორებადი PIANO შენიშვნა]
--we're აპირებს მესმის, რომ.
იდეა არის ის, რომ მუშაობს ისევე, როგორც ბრძანების იქნებოდა,
ასე რომ, თუ მე ახვიდეთ და down ჩემს კლავიატურაზე, თქვენ
შეიძლება დავუბრუნდეთ წინა ბრძანებები, რომელიც საკმაოდ სასარგებლო.
და ქვემოთ არის ჩემი სია სიმღერები, რომლებიც ყველა გაშვებული loop.
>> აუდიტორია: თქვენ, რა თქმა 88-გასაღები კლავიატურის, არა?
>> HUGH Zabriskie კითხვა იყო, მე თუ, რა თქმა 88-გასაღები კლავიატურის,
და დიახ, მე ვარ.
რა გავაკეთე არის აიღეს 88 ნიმუშები
ფორტეპიანო, თითოეული შენიშვნა.
ასე რომ, ყოველ დროს, თქვენ მოვისმინოთ შენიშვნა ამიერიდან,
რომელიც რეალურად loop რომელიც გამოიყურება მოსწონს ეს დღითიდღე ითამაშა loop,
ასე რომ ყველა შენიშვნა, ეს არის გაშვებული.
რა ხდება, მე შექმნას ბუფერული ერთხელ,
შევქმნა მომატება კვანძის მითითებული მოცულობა.
ეს უბრალოდ მართლა რთული გზა ამბობდა მე
შესანახად ბუფერული წელს source.buffer.
მე ვაძლევ მას მომატება, I დაკავშირება ის მომატება,
მოგების უკავშირდება გამომავალი, და მერე ითამაშოს ეს.
ასე რომ, ეს არის ერთგვარი პროცესი აღების ბუფერული წყარო.
>> აუდიტორია: შეგიძლიათ რეალურად მიიღოს, რომ მშრალი ხმა და სველი [INAUDIBLE]?
>> HUGH Zabriskie: თქვენ შეგიძლიათ, yeah.
იქ ხელახლა ზმნა, არსებობს დაგვიანებით, დამახინჯება.
შეგიძლიათ ძირითადად დააყენა არაფერი შორის, რომელიც სენდვიჩის of-- კარგად,
მილსადენის უკეთესი მეტაფორა, მაგრამ თქვენ შეგიძლიათ დაამატოთ არაფერი რომ.
ზემოთ.
>> ასე რომ, მე დასრულდება დემო აქ გადმოგცეთ გრძნობა
მხოლოდ მტკნარი რაოდენობის ჯერ შეგიძლიათ აწარმოებს, რომ ფუნქცია ერთდროულად.
ამიტომ, მე ვაპირებ ამოიღონ ეს.
მე ვაპირებ, რომ შევქმნათ გენერატორი that-- ძირითადად რა იმას, რომ ეს არის ნამდვილად
სახის რთული სინტაქსი, მაგრამ ეს აპირებს გენერირება შენიშვნები on the fly,
და უბრალოდ დაუკარით მათ ის აფასებს მათ.
[INTERPOSING PIANO]
>> ასე რომ, ჩვენ შეგვიძლია მხოლოდ მიიღოს პატარა მუსიკალური აქ.
[INTERPOSING PIANO]
>> ასე რომ ეს ბრძანება ასეა, მაგალითად,
იგი იღებს იმ სამ შენიშვნები საფორტეპიანო და შემდეგ აყენებს მათ B3.
ეს სინტაქსი შესაძლოა ცოტა მეტი გრძნობა
მათ, ვისაც აქვს მუსიკის ფონზე აქ.
>> მე შეგიძლიათ kick drum.
მე შემიძლია--
>> [INTERPOSING ინსტრუმენტები]
>> --just ითამაშოს გარშემო რომ.
>> ასე რომ თქვენ შეგიძლიათ make--
[INTERPOSING ინსტრუმენტები]
ეს ერთი პატარა უფრო შემაშფოთებელი.
[INTERPOSING ინსტრუმენტები]
>> ასე რომ, შემთხვევით დასძენს მშრალი წინწილა ყველა მე -16 შენიშვნა, 16%
[INAUDIBLE].
>> [INTERPOSING ინსტრუმენტები]
>> ჰო, ისე, როგორც ეს works-- ის ყოველთვის 4: 4.
[INTERPOSING ინსტრუმენტები]
>> ჰო, ისე ოთხი მეოთხედი, და 16/8.
[INTERPOSING ინსტრუმენტები]
>> ასე რომ, საშუალოდ, თქვენ მიიღებთ 60% ჰიტები -16 აღნიშნავს.
>> Anyways, ეს იყო მხოლოდ სახის გამოიჩენენ
ზოგიერთი რამ, რაც შეიძლება ავაშენოთ ვებ აუდიო API.
ეს მართლაც ძლიერი, ეს მართლაც სწრაფი, და შეგიძლიათ ბევრი მაგარი რამ
მასთან ერთად.
ასე რომ კიდევ ერთხელ, რაიმე კითხვა გაქვთ, ელ myself-- Hugh-- ან Sam,
და პატიოსნად, Google აქვს ტონა კარგი რესურსი.
ნებისმიერი ბოლო კითხვები?
ჰო.
>> აუდიტორია: ასე რომ თქვენ შეგიძლიათ თქვათ ჩაშენებული მიკროფონი.
რა მოხდება, თუ თქვენ სურდა გამოიყენოთ უკეთესი მიკროფონი?
HUGH Zabriskie: თუ უნდოდა გამოიყენოთ უკეთესი მიკროფონი?
ასე რომ კიდევ ერთხელ, ეს არის ნაწილი აბსტრაქცია შორის Chrome
და დანარჩენი თქვენს კომპიუტერში.
იმ შემთხვევაში, თუ ეს შესაძლებელია მეშვეობით API, როგორიცაა ვებ MIDI API,
თქვენ შეიძლება ალბათ გამოძებნოს hacks, მაგრამ ზოგადად არა როგორც შესაძლებელი.
>> SAM GREEN თქვენ შეგიძლიათ also-- ყველა Chrome იცის
არის ის, რაც თქვენი default მიკროფონი არის, და ეს იღებს, რომ.
ასე რომ, თუ თქვენ არ ჰქონდა მიკროფონი თქვენ ვერ უცნობია, როგორც კომპიუტერის ნაგულისხმევი მიკროფონი,
თქვენ ვერ შედიხართ, რომ გზა და ეს, ალბათ, მუშაობა.
HUGH Zabriskie: ეს არის კარგი წერტილი.
მე არასოდეს ცდილობდა, მაგრამ თქვენ შეძლებთ სახის
of-- თუ გადამისამართება შეყვანის სპიკერი, თქვენ შესაძლოა, რომ გავაკეთოთ, yeah.
>> ნებისმიერი ბოლო კითხვები?
ზემოთ.
ისე მადლობა ბიჭებს იმდენად უყურებს.
მე Hugh.
SAM GREEN: მე ვარ სემ.
HUGH Zabriskie: ეს არის CS50.