>> KEVIN შმიდი: Hello everybody.
მოგესალმებით CS50 სემინარი on Node.js.
ჩემი სახელია კევინ.
მე CS50 TF.
და მე ერთგვარი მოსწონს ნამდვილად აღფრთოვანებული ამ სემინარს.
ვფიქრობ Node.js არის ძალიან მაგარი.
მე იმედი მაქვს, რომ ეს სემინარი შეიძლება გამოყენებულ იქნას როგორც კარგი, ვფიქრობ, პლაცდარმი
ზოგიერთი თქვენი საბოლოო პროექტების, თუ თქვენ დაინტერესებული გამოყენებით
რაღაც Node.js.
>> ჩვენ ერთგვარი დაიწყოს სემინარი off მიერ უბრალოდ ვსაუბრობთ ცოტა
სახის ფონზე scalability პერსპექტივები Node.js, და შემდეგ
ჩვენ გადაადგილება ზოგიერთ კოდი მაგალითები.
და მე კოდი ნახვა, და თქვენ შეგიძლიათ შეხედოთ კოდი.
და შემდეგ სემინარზე მე დასალაგებლად განხილვა შესახებ, თუ როგორ შეიძლება შეიქმნას Node.js
თქვენს კომპიუტერში.
>> OK.
მოდით დავიწყოთ.
ასე ვფიქრობ მე, უბრალოდ, მინდა ვისაუბრო ვებ სერვერები, მართლაც, პირველი.
და დაიწყოს ამ დისკუსიის, I ძირითადად აქვს სქემა, რომელიც არის
სახელმძღვანელოს გამოიყენება CS61, რომელიც ძირითადად გვიჩვენებს ურთიერთქმედების
შორის კლიენტი პროცესი, ისევე როგორც თქვენი ვებ ბრაუზერის ან როგორც თქვენი მიზანია კლიენტი ან
ასე რომ, და სერვერზე.
ასე რომ, ეს სახის გამოიყურება მსგავსი სურათზე რომ თქვენ ვნახე ლექცია
ოთხშაბათი, სადაც, ძირითადად, ჩვენ გვაქვს კლიენტის პროცესი, როგორიცაა Google Chrome.
>> და შემდეგ ნაბიჯი ერთი კლიენტი აგზავნის მოთხოვნას.
ასე რომ, შეიძლება იყოს რაღაც კარგად მოდით ეწვევა, მე არ ვიცი, CS50.net.
ასე რომ, ჩვენ გასცეს, რომ მოთხოვნა.
და ახსოვს ვინმეს სახელი ოქმი, რომელიც განსაზღვრავს, როგორ
მოთხოვნა უნდა იყოს სტრუქტურა?
Yep.
>> აუდიტორია: [INAUDIBLE].
>> KEVIN შმიდი: ზუსტად.
ასე რომ, როგორიცაა HTTP, არა?
ასე რომ, ძირითადად დაზუსტება, თუ როგორ მოთხოვნა რეალურად უნდა იყოს ასახული
out, იმიტომ, რომ, დღის ბოლომდე, რომ მოთხოვნა ნამდვილად მომწონს
string რომ ძირითადად ამბობს, მინდა ეს.
და დაზუსტება რომ არის HTTP.
ასე რომ, როგორც ოქმს.
>> ასე შემდეგ სერვერზე იღებს რომ მოთხოვნა.
ასე, რომ თქვენ ბიჭები გვყავს სერვერზე დაყენებული წელს CS50 ელექტრო მოწყობილობების.
ეს Apache.
და ამ კვირას, როდესაც თქვენ მუშაობა პრობლემა მითითებული შვიდი, თქვენ რეალურად უნდა მუშაობა
რომ სერვერზე.
ასე რომ სერვერზე იღებს, რომ მოთხოვნა და მაშინ მას აქვს სახის გადასაფხეკი მის
თავი და ამბობენ, როგორიცაა, რა გავაკეთო ეს?
>> ასე რომ, რის საფუძველზე იგი გადაწყვეტს, მაშინ მას შეუძლია დაუკავშირდეს რაღაც
რესურს.
და რომ რესურსი შეიძლება იყოს ბევრი სხვადასხვა რამ.
ერთი, ეს შეიძლება იყოს მხოლოდ მოსწონს სტატიკური HTML ფაილი.
ასე რომ, ეს შეიძლება იყოს მხოლოდ, ისევე როგორც ზოგიერთი HTML, რომ ჰგავს
თქვენი პირადი ნახვა.
ეს შეიძლება იყოს სტატიკური ფაილი, როგორიცაა იმიჯი ან, როგორც ფილმის, რომ თქვენ გაქვთ.
ეს შეიძლება კი უნდა გაიგო გარკვეული მონაცემთა ბაზა
როგორიცაა MySQL მონაცემთა ბაზაში.
ასე რომ, ეს ყოველთვის არ უნდა დაუკავშირდეს ერთად რესურსი, მაგრამ
ზოგიერთ შემთხვევაში, ეს შესაძლებელი იქნებოდა.
>> ასე რომ, თუ რას აპირებს მას შემდეგ, რაც ის არის, რომ ის აპირებს
უკან გამოაგზავნოს პასუხი.
და პასუხი არის ის, ასევე განსაზღვრული HTTP.
ასე რომ, კლიენტს შეუძლია მიიღოს იგი.
ეს შეიძლება გაანადგურეს ის გარდა და გადაამუშავებს მას.
და შემდეგ თქვენ მიიღებთ ვებ გვერდი როგორიცაა Google ან CS50.net ან
რასაც თქვენ წავიდა.
OK?
>> ასე რომ, ეს არის ძირითადი ურთიერთქმედების, რომ ჩვენ ვაპირებთ, რომ იყოს საქმე.
და ჩვენ საკმაოდ ბევრი იქნება აქცენტი ამ ნაწილში
ურთიერთქმედების, სერვერზე.
OK.
ზემოთ.
ვინმეს გაქვთ რაიმე შეკითხვები აქამდე?
OK.
>> ასე რომ, როგორც ვთქვით, სერვერზე იღებს ამ HTTP მოთხოვნის და შემდეგ გასცემს ამ
HTTP პასუხი.
და როგორც ჩვენ ვისაუბრეთ ადრე, CS50 ელექტრო სერვერზე არის Apache.
ასე რომ, როდესაც თქვენ ბიჭები მუშაობენ P მითითებული შვიდი, თქვენ ვაპირებთ იყოს მუშაობა
Apache სერვერზე.
თქვენ არასდროს ნამდვილად მუშაობა ერთად Apache უშუალოდ ძალიან ბევრი.
თქვენ ერთგვარი კონფიგურაციის Apache პატარა როდესაც თქვენს მიერ მითითებული ვირტუალური მასპინძლებს ან
v მასპინძლებს, და მივიღებთ რომ ცოტა.
>> მაგრამ, ძირითადად, Apache სერვერზე შეიქმნა მუშაობა PHP სახის
გარეთ ყუთში.
ასე რომ, რა ხდება, როდესაც მიდიხარ ერთი თქვენი საიტებზე, როგორიცაა, ვთქვათ,
ადგილობრივი მასპინძელი slash index.php ან რამე, თქვენი ბრაუზერი უგზავნის, რომ
მოთხოვნა, ხოლო შემდეგ Apache ზის და გათვლით out გავაკეთოთ ეს.
და მოქმედება უნდა შესრულდეს რომ კოდის index.php და
შემდეგ ეს off უკან.
ასე რომ იქ რომ.
ასე რომ, ჩვენ ერთგვარი ესაუბრა.
ასე რომ, ეს შეიძლება მხოლოდ ემსახურება სტატიკური ფაილი ან აწარმოებს ზოგიერთი PHP კოდი და მერე საკითხი
პასუხი.
>> ასე რომ საერთო კითხვა, რომელიც შეიძლება მოვიდეს up კარგად, როგორ უნდა ნამდვილად საქმე
მქონე მრავალჯერადი მომხმარებლებს ამავე დროს?
ასე რომ წარმოიდგინეთ, თუ თქვენ წერა ვებგვერდი სერვერზე, თუ თქვენ სერვერზე რომ
თქვენ ცდილობდა შეექმნა რაღაც როგორიცაა C ან რამე მაგდაგვარს,
ძირითადად შეგიძლიათ ვიფიქროთ, თუ როგორ არის შეიძლება იყოს გარკვეული სახის კოდი, რომელიც
მიიღებს მოთხოვნით, მაგრამ შემდეგ ეს უნდა გააკეთოს ეს ყველაფერი მუშაობა.
ეს შეიძლება, მაგალითად, დაუკავშირდეთ მონაცემთა ბაზის ან რამე მაგდაგვარს.
უფლება?
და მაშინ იგი ყველაფერს გააკეთებს, რომ ასეთი დამუშავება და შემდეგ
დააბრუნეს პასუხი.
ასე რომ, როგორც მაღალი დონე მიმოხილვა.
>> მაგრამ ეს არ არის დაუყოვნებლივ აშკარაა, თუ როგორ შეგვიძლია გავაკეთოთ, რომ ისე, რომ ორი ადამიანი ან
კი 1000 ადამიანი ვერ იმუშავებს თქვენი სერვერზე ამავე დროს.
ასე რომ, გამოსავალი, რომ Apache იყენებს ეწოდება თემა ან პროცესები.
ასე რომ თქვენ შეიძლება არ მსმენია ამ თვალსაზრისით ადრე.
ეს OK, თუ თქვენ გაქვთ არ არის, მაგრამ ვფიქრობ შესახებ თემა ან პროცესები, გზები
ოპერაციული სისტემის ან მომხმარებლის პროგრამის ან ასე რომ თუ სერვერზე
სახის შეასრულოს სხვადასხვა რამ ერთდროულად.
ასე, რომ თქვენ შეიძლება მოვისმინეთ ტერმინი ისევე როგორც თემა აღსრულება.
ასე რომ, ეს სახის მოსწონს თქვენ სახის multitasking.
>> და თუ ვნახე ყუთი თქვენი ლეპტოპი, ან რამე მაგდაგვარს,
multicore, რა შეგიძლიათ გააკეთოთ თქვენ შეგიძლიათ აწარმოებს ორი განსხვავებული თემა სხვადასხვა
ნაწილები CPU, რომ მათ რეალურად მოხდეს ამავე დროს.
ასე რომ, ეს მართლაც ძლიერი.
და ეს არის ერთგვარი Apache-ს ამ პრობლემის გადაჭრის.
>> ასე რომ, არსებობს სახის მოსწონს ნებისმიერ საკითხებზე ეს მიდგომა თუმცა?
ასე ვფიქრობ მე სახის წერდა მათ.
მაგრამ ორივე სახის გამოყენება მეხსიერების დიდ ნაწილს.
ეს ძალიან ძვირი შექმნა თემა ან პროცესში.
>> და ნაწილი აზროვნება ის არის, რომ მხოლოდ მაგალითად, როდესაც თქვენ გაშვებული C პროგრამა
როგორც თქვენი ძირითადი და მაშინ, რომ ზარი სხვა ფუნქცია, რომელიც აქვს
გარკვეული სახის Stack.
ასე რომ, თემა ასევე მოითხოვს სრულიად ცალკე დასტის რომელიც
შეიძლება იყოს საკმაოდ დიდი.
და, თუ თქვენ წარმოიდგინეთ მქონე ტონა მომხმარებლის თქვენს საიტზე, თქვენ უნდა
ბევრი სხვადასხვა თემა.
რომ ბევრი stacks მდე მართვა და შენარჩუნება.
ასე რომ, ეს დიდი მეხსიერების მოხმარება.
>> და შემდეგ, ასევე, ვთქვათ, თქვენ მხოლოდ ერთი CPU, ან ვთქვათ თქვენ გაქვთ
მეტი თემა ვიდრე თქვენ გაქვთ იმ multicores.
უფლება?
ასე ვთქვათ გქონდათ 10 თემა და თქვენ მხოლოდ ხუთი პროცესორები.
თქვენ სახის უნდა გავაკეთოთ ეს რამ სადაც თქვენ გადაერთოთ მიმდინარე
ერთი, რომ გაშვებული, რადგან თქვენ ვერ აწარმოებს ყველა 10 ერთდროულად.
და რომ ე.წ. კონტექსტში შეცვლა.
და რომ ტერმინი რეალურად აქვს რამდენიმე სხვადასხვა კონტექსტში, მაგრამ მოდით უბრალოდ
ვფიქრობ, რომ ეს გადართვის ორ თემა.
ეს შეიძლება იყოს საკმაოდ ძვირი, რადგან ძირითადად ის, რაც თქვენ უნდა გააკეთოთ თქვენ
უნდა შეწყვიტოს თუ რას აკეთებს, შენახვა სახელმწიფოს, რომ გაშვებული თემა, და
მერე გადახვიდეთ სხვაგან.
>> ასე რომ ყველას სახის ვხედავ მოტივაცია, რატომ თემა და
პროცესები შეიძლება ცოტა bulky?
და არც თქვენ გაქვთ შეკითხვა?
OK.
ზემოთ.
ვინმეს გაქვთ რაიმე შეკითხვა?
OK.
>> ასე რომ, თუ ჩვენ უკან გადადგმული ნაბიჯია მეორე, არსებობს სახის მოსწონს
დაკვირვება, რომ ჩვენ შეგვიძლია შესახებ ბევრი ვებ პროგრამა.
და ეს მართლაც რომ ბევრი მათგანი რეალურად არ გავაკეთოთ, რომ ბევრი სასარგებლო
მუშაობა შიგნით ძაფი.
ასე რომ ვინმეს დაიწყო P მითითებული შვიდი ყველა?
ასე რომ გსურთ იქნებ აღწეროთ ზოგიერთი ნაწილები?
გიმუშავიათ შესვლისას ან რამე მაგდაგვარს?
>> აუდიტორია: არა
>> KEVIN შმიდი: OK.
არასოდეს გათვალისწინებით.
უკაცრავად.
მაგრამ ძირითადად, იმ P კომპლექტი, თქვენ იქნება მიღების ბევრი სახის
queries მონაცემთა ბაზის მივიღოთ ინფორმაცია, რომ მონაცემთა ბაზაში.
და რა თქვენი კოდი უნდა აკეთებს, რა, რომ Apache პროცესის ან
რომ Apache თემა იქნება აკეთებს მიუხედავად იმისა, რომ აქვს დაუკავშირდეს
მონაცემთა ბაზის არის ის სახის იქნება იჯდა იქ და ის იქნება
ელოდება მონაცემთა ბაზის უპასუხა.
>> ახლა, რომ შეიძლება არ გავს, რომ დიდი საქმე იმიტომ, რომ მონაცემთა ბაზაში არის თქვენი
CS50 ელექტრო მოწყობილობების, არა?
თუმცა, არსებობს გარკვეული სახის ქსელი შეყოვნება არ არსებობს, ვინაიდან, ახლა ინტერნეტში
სერვერზე არ გასცეს საკუთარი მოთხოვნით მონაცემთა ბაზის ურთიერთობა
მონაცემთა ბაზაში და მერე კიდევ რომ ინფორმაცია უკან.
ახლა ის მსგავსად კარგად დაველოდოთ, მე ვარ აპირებს წავიდეს მიიღოს რაიმე
მონაცემთა ბაზაში და შემდეგ იქ ბევრი ელოდება მიმდინარეობს.
ამჯამად რომ აზრი?
>> და ზოგიერთი რამ, ეს არ არის, რომ ცუდი.
იმ შემთხვევაში, თუ ეს უბრალოდ, მაგალითად, შესვლა მეხსიერება, რომ არ მომწონს
საშინელი I / O შეყოვნება.
და როდესაც ვამბობ, I / O შეყოვნება, რა ვარ მხედველობაში არის როგორც ნებისმიერი სახის მოსწონს
input output.
მაგრამ წვდომისათვის ფაილი დისკზე, ისევე როგორც თუ მინდოდა ემსახურება სტატიკური HTML
ფაილი, რომელიც იყო ჩემს ვებ გვერდზე ან ასე რომ, მე სახის უნდა
შეჩერება ცოტა წავიკითხე, რომ ფაილი ამ დისკზე, ხოლო შემდეგ
ეს პროცესი მე ელოდება.
მე არ აკეთებს სასარგებლო შრომა.
>> ეს ასე არ არის ყველაფერი, მაგრამ ეს საერთო განაცხადების მოსწონს P კომპლექტი
შვიდი და ბევრი განცხადება რომ თქვენ არ
რეალურად აკეთებს ბევრი აზროვნება.
და როდესაც ვამბობ, რომ აზროვნება, ვგულისხმობ როგორიცაა კომპიუტერული მუშაობა.
ასე რომ, გამოთვლითი მუშაობა შეიძლება იყოს რაღაც ისევე, როგორც, ვთქვათ, თქვენ სურდა
დაწერეთ სერვერზე, რომ მხოლოდ გამოთვლილია nth Fibonacci ნომერი.
ეს არ გავს განსაკუთრებით fun სერვერზე.
მომწონს არ მოველით, რომ საიტი იყოს მომავალი Facebook, მაგრამ ეს არის გარკვეული
სახის კომპიუტერული მუშაობა.
>> და თქვენ წარმოიდგინეთ, შეცვლის, რომ რამდენიმე სხვა სახის საინტერესო
კომპიუტერული მუშაობა.
ვთქვათ თქვენ წერდნენ რაღაც რომ გამოითვლება ხარისხი
გამიჯვნა ორი ადამიანი ან რამე მაგდაგვარს.
ასე რომ არ გულისხმობს რაიმე სახის გაანგარიშება, არა?
და მაშინაც, გავაკეთოთ, რომ თქვენ ჯერ კიდევ აქვს ბევრი ელოდება იქნებ
თქვენ უნდა მოვითხოვოთ მონაცემთა ბაზა გამოიყურება up, რომელიც მეგობრებთან ერთად, რომლებიც ან
რამე მაგდაგვარს.
ასე არ არის, რომ ასეთი ცნება კომპიუტერული მუშაობა.
ამჯამად რომ აზრი?
ვინმეს გაქვთ რაიმე შეკითხვა?
>> Oh და ვფიქრობ დააყენა სტატისტიკა სერვერები არსებობს რადგან ჩატში სერვერები სახის
კიდევ ერთი კარგი მაგალითია.
სტატისტიკა სერვერზე არ აქვს ბევრი რამ ფიქრი.
ეს უბრალოდ უნდა დაველოდოთ ხალხს შეტყობინებები და მაშინ, როდესაც
ისინი, გადაუგზავნის.
OK?
>> ასე რომ მხოლოდ recap ერთხელ, Apache და მსგავსი ვებ სერვერები, როგორიცაა, რომ ჩანგალი
ბევრი თემა და პროცესები, რომლებიც შეიძლება სახის wasteful.
ამიტომ ვფიქრობ, საკითხი, რომ შეიძლება მოვიდეს რომ არის, ჩვენ უნდა
მრავალი თემა და პროცესები?
რა მოხდება, თუ ჩვენ მხოლოდ ერთი?
>> მოდით სახის ხატავს სურათს რა ეს გამოიყურება ასე.
მოდით მხოლოდ ერთი თემა.
OK?
ასე რომ, წარმოიდგინეთ, ამ ერთი თემა.
>> დავუშვათ ჩვენ ნამდვილად არ აკეთებს რომ ბევრი სასარგებლო - და როდესაც ვამბობ
სასარგებლო, ვგულისხმობ კომპიუტერული სამუშაო -
იმ მრავალი თემა ადრე.
მოდით სახის კონსოლიდაცია ყველაფერი ერთი თემა.
მერე რა, რომ ჩვენ გვქონდა ერთი თემა, რომ სახის უბრალოდ მიდის გარშემო მარყუჟის და
მუდმივად ამოწმებს რამე ახალი მოხდება.
ასე მაგალითად, რაღაც ახალი მოხდა შეიძლება ნიშნავს, მე მივიღე რაღაც უკან
მონაცემთა ბაზაში, ან ვინმე გაიგზავნა ჩემთვის ახალი HTTP მოთხოვნის.
ასე რომ, ამ სახის ღონისძიებები რომ მოხდეს, არა?
>> და მერე რა შემიძლია, როდესაც იმ new რამ არის ამ იგივე თემა
აღსრულების, ამ ერთი თემა შესრულების, მე მოვუწოდებ რამდენიმე კოდი, რომელიც
რომ გაუმკლავდეს, რომ განსაკუთრებული რამ.
ასე მაგალითად, თუ მე მივიღე რაღაც უკან მონაცემთა ბაზიდან, მე ვერ აწარმოებს ჩემი
მცირე კომპიუტერული ნაწილი, რომ რეალურად მხოლოდ ამზადებს, რაც უნდა
გაუგზავნე თავში შესახებ.
ასე აკეთებს, რომ სახის აზრი?
>> მაგრამ რა მართლაც შედეგების ეს?
უფლება?
იმის გამო, რომ ჩვენ წერილობითი ბევრი კოდი, რომელიც -
და მე უბრალოდ აპირებს ხტომა ადრე in სლაიდები, თუ ეს OK.
ასე რომ, თუ არ იბადება, მე უბრალოდ აპირებს უკან გადადგმული ნაბიჯია.
ასე რომ, ეს სახის რამ არის ე.წ. ღონისძიება loop.
OK?
და ეს სახის ძირითადი იდეა Node.js.
>> ასე რომ, რა Node.js რომელიც აკეთებს მართლაც როგორც ვებ სერვერი არ არსებობს ერთი თემა
რომ არის, ძირითადად, მიმდინარეობს გარშემო მარყუჟის ისევე როგორც მაშინ, როდესაც ერთი სახის ფარგლებში
hood of Node.js, რომ მუდმივად შემოწმების, მივიღეთ ახალი რამ?
და მაშინ იგი მიიღებს ელფოსტის რომ შეიქმნა.
მაგრამ კარგი კითხვა ვთხოვო არის, როგორ შეგვიძლია, რომ ეს მოხდეს
არსებული რამ?
>> ამიტომ დააყენა ხაზი C კოდი რომ აქ ძირითადად ჰგავს ის გახსნის
ფაილი, არა?
მე მან უბრალოდ გამოვიდა ალბომი.
ამიტომ მე უნდა გახსნას მისი ახალი ფაილი.
ასე რომ გზა ჩვენი C კოდი მოქმედი -
და ვფიქრობ, ამის მიზეზი მე აირჩია ფაილი იყო იმიტომ, რომ ეს არის ერთგვარი, თუ რამდენად
საქართველოს I / O მუშაობა, რომ ჩვენ გავაკეთეთ C in გრძნობა, რომ იქ input output.
ამიტომ, ჩვენ მოვუწოდებთ ამ კოდი, რომელიც ამას f ღია.
და მერე მომდევნო ხაზი ჩვენი პროგრამა, ჩვენ შეგვიძლია ახლა მუშაობა ვ.
>> ასე რომ, ეს იქნება მაგალითი რაღაც ასეთი სინქრონული ან
დაბლოკვის იმიტომ, რომ პირველი ხაზი იქ ჩვენ ველოდებით სანამ ჩვენ
მიიღეთ ფაილის გახსნა.
ასე რომ მეორე ხაზი, ჩვენ ვიცით, რომ ჩვენ შეუძლია მუშაობა f, მაგრამ ეს ნიშნავს იმას, რომ
რომ მეორე ხაზი ნამდვილად ვერ აწარმოებს სანამ პირველი ხაზი კეთდება.
ამჯამად რომ აზრი?
>> ასე რომ, ეს იქნებოდა ცუდი დააყენოს in ღონისძიება დამმუშავებლის.
და ამის მიზეზი ის არის, რომ ამ სახის ელოდება, არა?
ასე რომ, ეს იქნება აღადგინოთ უკან იგივე.
და ახლა ჩვენ კი არ აქვს სასარგებლოდ მრავალი თემა ან
პროცესები, რადგან მივიღეთ ერთი თემა Node.js.
ამჯამად, რომ აზრი, ყველას?
>> აუდიტორია: Wait.
რა შეცვალა?
>> KEVIN შმიდი: Oh, ასე რომ, დიახ.
ამიტომ მე ვაპირებ მისაღებად შეცვალა.
OK.
მერე რა, რომ ჩვენ გვქონდა რაღაც რომ ჰგავდა ეს?
მერე რა, რომ ახლა მე რედაქტირებული ვ გახსნა პატარა?
ამიტომ მე გავლით იმავე ორი არგუმენტები, როგორც ადრე.
მე მაინც მიყვარს, რომ ახალი სიმღერა რომ იგი გამოვიდა.
მაგრამ მე გავლით მესამე, რაც ეს ცვლადში კოდი.
>> მაგრამ რა არის რეალურად კოდი ამ კონტექსტში?
ეს არის როგორც რეგულარული C ცვლადი?
ეს ფუნქცია, უფლება?
და რომ შეიძლება ცოტა უცნაურია, რადგან მე რეალურად, როგორც ახლა გავლის
ფუნქციონირებს მეორეზე ფუნქცია.
>> ასე რომ, რამდენიმე რამ აღვნიშნო შესახებ.
ერთი, მე რეალურად არ მოუწოდებდა კოდი ფუნქცია.
ასე, რომ თქვენ ვერ ვხედავ კოდექსი მარცხენა paren, მარჯვენა paren.
მე მხოლოდ გავლის კოდი.
და C, რა, რომ ეს რეალურად გავაკეთოთ არის მომეცი მომცეთ, რომ ფაქტობრივი
კოდი და მაშინ ეს შეიძლება აწარმოებს.
მაგრამ ვფიქრობ, რომ ამის შესახებ, როგორც თქვენ ახერხებდნენ კოდი, როცა
რომ ფაილი გაიხსნა.
>> მაგრამ რა ეს იმას ნიშნავს, რომ ახლა დანარჩენი ჩემი პროგრამა, რომელიც შეიძლება გავაკეთოთ
სხვა პერსონალი, შეუძლია გააგრძელოს აკეთებს სხვა პერსონალი, ხოლო ჩვენ, ნამდვილად არ დაველოდებით, მაგრამ
უბრალოდ უკან ჩვენი ხელმძღვანელები, რომ როდესაც რომ ფაილის გახსნა, გაშვება, რომ
კოდი ზედა.
ამჯამად რომ აზრი?
>> და ახლა იდეა Node.js ის არის, რომ კოდი ამ do პერსონალის f
ნაწილი უნდა იყოს საკმაოდ მოკლე და მარტივი და პირდაპირი და ნამდვილად არ იქნება
ძალიან computationally ინტენსიური.
ეს უნდა გახსნა სხვა ფაილი, მაგრამ რომ უნდა იყოს საკმაოდ სწრაფი
იმიტომ, რომ ეს უნდა მხოლოდ ვთქვა, გავაკეთოთ კიდევ ერთი f გახსნა და შემდეგ მოვუწოდებთ ეს სხვა კოდი.
>> ასე რომ, უბრალოდ უნდა იყოს სრულიად ნათელია, რომ f გახსნა, რომ არ ახალი Katy Perry სიმღერა
გაკეთდა mp3, რომ აპირებს საკმაოდ ბევრი დაბრუნებას დაუყოვნებლივ.
და მაშინ ჩვენ შეგვიძლია გავაგრძელოთ აკეთებს სხვა პერსონალი, რადგან ყველა რომ ახლა f
ღია მოწოდება არ არის გითხრათ, ძირითადად, ძირითადი f ღია კოდი ამ ფაილის გახსნის
და როდესაც თქვენ გაკეთდეს გახსნის ამ ფაილი ან როდესაც თქვენ უკან,
მაშინ აწარმოებს, რომ კოდი.
მაგრამ ის ფაქტობრივად არ აწარმოებს, რომ კოდი.
და გქონდათ შეკითხვა?
>> აუდიტორია: თქვენ, როგორც ჩანს, გულისხმობს, რამდენიმე ჯერ დასძინა computationally
ინტენსიური კოდი ერთგვარი შესვენება [INAUDIBLE] ორიენტირებული სისტემა.
[INAUDIBLE]?
>> KEVIN შმიდი: ეს არის დიდი კითხვა.
ასე რომ, რეალურად მაგალითია, თუ როგორ თქვენ შეიძლება ინტეგრირება computationally
ინტენსიური კოდი ცოტა.
ასე რომ, როდესაც მივიღებთ კოდი მაგალითები, მე დარწმუნებული უნდა გაიყვანოს, რომ ერთი.
ის არის, რომ OK?
დიდი მადლობა.
>> რა იყო თქვენი სახელი?
>> აუდიტორია: Aaron.
>> KEVIN შმიდი: Aaron გამოიტანს ძალიან კარგი წერტილი, რომელიც არის ის, რომ, თუ მქონდა
ზოგიერთი computationally ინტენსიური კოდექსი გავაკეთოთ პერსონალის f ნაწილი, დანარჩენი
ჩემი პროგრამა არ შეუძლია და არ შეუძლია მოუსმინოს ახალი მოთხოვნების ან არაფერი, სანამ ყველა
რომ პერსონალის დასრულდა.
ასე რომ, თუ მე წერა Node კოდი ზოგადად თუ ჩვენ რაღაც მე ვაპირებ
ვარაუდობენ, მოგვიანებით, როცა შევხედავთ კოდი მაგალითები, უნდა იყოს დარწმუნებული, რომ
ჩემი კოდი არ გვაკავშირებს ეს ღონისძიება loop.
ამჯამად რომ აზრი?
OK.
ზემოთ.
>> ასე Node.js გთავაზობთ ამ ფარგლებში, თქვენ შეძლოთ ამ ღონისძიების ორიენტირებული
სერვერები.
ასე რომ ამ ტიპის ასინქრონული არასამთავრობო დაბლოკვის I / O ბიბლიოთეკა, ხოლო
სტანდარტული C ბიბლიოთეკების, რომ ჩვენ მუშაობს, როგორიცაა, თუ თქვენ უბრალოდ
მათი გამოყენება იგივე გზა, რომ ჩვენ გამოყენებით მათ f ხსნის და
პერსონალი, ვინც ბლოკავს რადგან თქვენ ნამდვილად უნდა ველოდოთ
რომ ფაილის გახსნა.
>> მაგრამ Node.js გაძლევთ, რომ და ეს ძირითადად კავშირები შევიდა Google-ის V8
JavaScript ძრავა, რომელიც არის მიზეზი რომ Chrome იმდენად სწრაფი at დამუშავება
JavaScript, რადგან იგი აქვს V8 ძრავით.
ასე რომ, მე ვიცი, რომ ჟღერს ერთი იმ WWDC დეველოპერი კონფერენციები რამ
, სადაც ისინი უბრალოდ სახიფათოა bunch of წერილი ნომერი რამ პროცესორები
და აცხადებენ, რომ ეს ასე cool.
მაგრამ ეს არის მაგარი, რომ მათ ეს იმიტომ, რომ JavaScript -
ან იქნებ თუ თქვენ არ იცნობს JavaScript ჯერჯერობით იმიტომ, რომ ჩვენ არ გვქონდა
ლექციებს ეს -
მაგრამ JavaScript არის გაგებული ენაზე.
>> და ეს არის მნიშვნელოვანი ძალიან.
ამიტომ მნიშვნელოვანია, ჩვენი ვებგვერდი სერვერები უნდა იყოს სწრაფი, არა?
და თუ ჩვენ უბრალოდ გაშვებული JavaScript კოდი, რომელიც ინტერპრეტაცია მხოლოდ
ნებისმიერი წლის თარჯიმნის ეს შეიძლება იყოს ნელი.
ასე Node სარგებელი, რომელსაც ამ სუპერ სწრაფი V8 თარჯიმანი.
და მე არ ვიცი, თუ ისინი დაასახელა ის რადგან V8 slap შუბლის
რამ, მაგრამ OK.
>> ასე რომ მე მომზადდა რამდენიმე მაგალითი ამ URL.
სემინარის შემდეგ, მე სახის აპირებს ვისაუბროთ, თუ როგორ შეგიძლიათ მიიღოთ Node კომპლექტი
up, მაგრამ ახლა, უბრალოდ ერთგვარი მინდა გავლა ზოგიერთი კოდი მაგალითები.
ასე რომ, თუ გვინდა, რომ დაიცვას გასწვრივ, ყველა კოდის ხელმისაწვდომია არსებობს.
OK?
>> ასე რომ, მე დავტოვებთ ამ URL up პატარა.
და შემდეგ მე უბრალოდ აპირებს გადართოთ შევიდა ტერმინალში.
ყველას კარგი ამ URL?
ამიტომ მე ვაპირებ გადართოთ მეტი ჩემს ტერმინალის აქ.
>> ასე რომ, აქ არის კოდი, რომელიც მაქვს დღეს.
რატომ არ უნდა დაიწყოს simpler.js ფაილი?
მეორე ის არის, რომ ყველა ამ კოდი იქნება დაწერილი
JavaScript რომელიც თქვენ შეიძლება იყოს ან არ შეიძლება იყოს იცნობს.
ვფიქრობ, რამდენიმე რამ არის, რომ ბევრი of JavaScript კოდი არის ერთგვარი
სინტაქსი და სტრუქტურა ძალიან გავს C, ასე რომ თქვენ შეგიძლიათ სახის აირჩიოთ it up, როგორც
თქვენ წავიდეთ ერთად.
მე ვცდილობდი დაწერა ბევრი დაწყებული კოდი ეს ისე, რომ
მსგავსი C ისე, რომ ეს ცოტა მეტი იკითხება.
მაგრამ როგორც ჩვენ პროგრესის, მე ვიქნები დემონსტრირებას ზოგიერთი დამატებითი
თვისებები JavaScript, რომ სახის cool.
>> მაგრამ მოდით შევხედოთ ამ ნიმუში პროგრამა.
ვფიქრობ, ყველაფერი შეწყვიტა არსებობს.
მე უბრალოდ აპირებს დაფიქსირება, რომ რეალური სწრაფად თუ ეს OK თუ არა.
მე არ ვიცი რა ამ აპირებს.
ის არის, რომ ცოტა უკეთესი?
შეგიძლიათ ნახოთ var და პერსონალი?
OK.
>> ასე რომ, პირველი ხაზი, როგორიცაა JavaScript მობილური ცვლადი
დეკლარაცია.
ასე რომ მხოლოდ ხაზს უსვამს რა ეს იქნებოდა გამოიყურებოდეს C. ასე რომ, ეს არის, ისევე,
მითხრა ინდექსი უდრის სამ ან რამე მაგდაგვარს.
ასე რომ მე არ მიუთითებს.
JavaScript აქვს სახის, მაგრამ ეს ძალიან დინამიურად აკრეფილი ბუნებაში, ისე
არ ითვალისწინებს რაიმე სახის type იგი.
ასე რომ, ეს უბრალოდ var.
ასეთი ცვლადი.
OK?
>> და მე მოუწოდებდა ამ ცვლადის HTTP.
და ჩემს მარჯვნივ, მაქვს გამოხატვის, რომ მინდა დააყენა HTTP.
და ეს ამბობს მოითხოვს HTTP.
ასე რომ, ეს სახის ანალოგიური მოიცავს.
ეს ცოტა უფრო ძლიერი ვიდრე არის იმ გაგებით, რომ მოიცავს
უბრალოდ დააკოპირეთ და ჩასვით header ფაილი ფუნქცია პროტოტიპები ან
რასაც ტიპის განმარტებები.
მაგრამ მოითხოვს რეალურად აპირებს მიიღოს us კოდი.
>> ასე რომ თქვენ შეგიძლიათ ვფიქრობ, რომ ეს იმპორტიორი რამდენიმე კოდი.
ასე რომ სადღაც Node.js მოდული სისტემის ან რასაც, მათ აქვთ ყველა ამ
HTTP სერვერის კოდი ისე, მე უბრალოდ მიღება, რომ ეს ჩემი საკუთარი
პირადი მოხმარების ამ პროგრამაში.
OK?
>> ასე რომ მე არ მაქვს ეს ფუნქცია რომ მე დაწერილი.
და შენიშნავს, მე არ უნდა მიუთითოთ დაბრუნების ტიპის და ტიპი
არგუმენტები ერთხელ.
ასე რომ, სახის ფხვიერი აკრეფილი ასეთი სახის აზრი.
ორი არგუმენტები, რომ სჭირდება, მოთხოვნა და პასუხი.
ასე რომ კონცეპტუალურად სახის მოსწონს ნაცნობი სურათი, რომ ჩვენ გვქონდა
ეკრანზე ადრე, რადგან მივიღებთ ამ მოთხოვნას, რომ ჩვენ
აქვს საწყისი მომხმარებელს.
და მაშინ ჩვენ გვაქვს პასუხი, რომ ჩვენ შეგვიძლია დავწეროთ რამ.
>> ასე რომ, პირველი ხაზი ეს იმას res.writeHead 200 და შემდეგ ამ
content ტიპის ტექსტის დაბლობს.
მოდით ცალი ამ გარდა პატარა.
მოდით უბრალოდ ფოკუსირება res.write პატარა.
ასე წერენ ძირითადად, და წერენ ხელმძღვანელი, უბრალოდ გზები სახის წერენ გარეთ
რამ საპასუხოდ.
OK?
ასე წერენ თავი, თუ ვინმეს ახსოვს საწყისი HTTP ლექცია, თქვენ ბიჭები
მახსოვს headers ზე ყველაზე HTTP რამ?
რატომ არ მე უბრალოდ დემო headers რეალური სწრაფი.
იქნებოდა, რომ იყოს გამოსადეგი?
ან უნდა ჩვენ უბრალოდ სახის -
OK.
დარწმუნებული ვარ.
>> ასე რომ, როდესაც თქვენი ბრაუზერის ღებულობენ google.com ან რამე მაგდაგვარს,
არსებობს რეალურად ცოტა მეტი -
ეს მოსწონს საიდუმლო -
იქ, როგორც პატარა დამატებითი ინფორმაციისთვის რომ მოდის მეშვეობით მილის, ვიდრე უბრალოდ
პატარა ძიება და ყველაფერი.
ასე რომ გაჩვენოთ, მე ვაპირებ გამოყენება პროგრამის მოუწოდა Curl.
OK?
ასე რომ, ეს არის ის, რომ თქვენ შეგიძლიათ აწარმოებს at თქვენი Mac OSX ბრძანების ან
ელექტრო ან რასაც.
და თუ მე Curl HTTP google.com, მე ვაპირებ, რომ ნახოთ HTML.
და ეს არის, სამართლიანობა, მხოლოდ HTML, რომ სახის გიჩვენებთ
გადამისამართება www თუ თქვენი ბრაუზერი არ ავტომატურად ამუშავებს
გადამისამართება.
>> ასე რომ, ეს არის მხოლოდ HTML, მაგრამ მე ვაპირებ დაამატოთ Curl ეს დეფისი I დროშა.
OK?
და ეს აპირებს აჩვენებს მე headers.
ასე რომ ეს არის ასევე ინფორმაცია, რომ მოდის მეშვეობით, როდესაც მივიღებ ამ პასუხს.
OK?
>> ასე რომ ზედა, ხედავთ ამ HTTP 301 გადაადგილება მუდმივად.
და ეს არის ერთგვარი მნიშვნელოვანია, რადგან ეს ეხება სტატუსის კოდი.
ასე რომ 301 აქ არის შემოწმება კოდი რომელიც, ძირითადად, მხოლოდ მთელი რიცხვი
რომ ეუბნება ბრაუზერში ან ვინც არის კითხულობს, თუ ვიტყვი, რომ
თქვენ ბრაუზერში და თქვენ ხედავს ამ, ძირითადად ახლა თუ გადავხედავთ
რომ და ხედავთ 301, თქვენ იცით, მე არ მაქვს რაღაც განსაკუთრებული საფუძველზე
301, ან რაღაც განსაკუთრებული მოხდა საფუძველზე 301.
ასე რომ, ის ამბობს გადავიდა მუდმივად.
>> და შემდეგ, პრაქტიკულად, ჩვენ რამოდენიმე გასაღები ღირებულება წყვილი.
ამიტომ ჩვენ კიდევ მდებარეობა არის www.google.com.
და შემდეგ სახის ყველა ამ სხვა პერსონალი, მაგრამ ძირითადად, რა ადგილმდებარეობა
გამონათქვამი არის ახალი ადგილმდებარეობა არის www.google.com.
ახლა თუ წასვლა google.com, თქვენ სახის იხ. ბრაუზერის სახის blink
მეორე და შემდეგ გადამისამართება თქვენ უფლება დაბრუნება www.google.com.
ასე რომ, პასუხი შეიძლება შეიცავდეს ამ სათაურებში.
>> და რამდენიმე რამ აღვნიშნო.
ასე ვთქვათ ჩვენ რეალურად წარმატებული გამოჩენის ვებ გვერდზე.
ნება მომეცით წასვლა -
რა კარგი საიტი?
მე ვარ ცუდი აზროვნება კარგი საიტებზე ადგილზე.
>> აუდიტორია: ვიკიპედია.
>> KEVIN შმიდი: OK.
მოდით Wikipedia.
ასე რომ აქ მე გადავიდა.
Oh დაველოდოთ.
იყო მე?
დიახ, მე ვიყავი.
OK.
ამიტომ მე მივიღე გავაკეთოთ www.
ასე რომ, მე ვაპირებ ამის გაკეთებას www.
და როგორც ხედავთ, აქ ყველა HTML რომ მისი ბრაუზერი რომ გადაამუშავებს
განთავსების Wikipedia.
>> მაგრამ თუ მე შენარჩუნება სენსორული აქ, რა მე ვხედავ ზედა -
wow, არსებობს ბევრი HTML on Wikipedia -
მაგრამ რა მე ვხედავ ზედა აქ არის ამ 200 სტატუსი კოდი, როგორც ეწინააღმდეგებოდა
301 რომ ვნახე ადრე.
და შეამჩნია, რომ მას აქვს ლამაზი მეგობრული OK შემდეგი მას.
ასე რომ, ეს არის როგორც კარგი სტატუსის კოდი.
>> ამჯამად რომ 200 ნომერი გამოიყურება ნაცნობი?
დიახ, რადგან, როდესაც მე simpler.js, მე დავწერე 200 არსებობს.
ასე რომ ძირითადად ამბობდა ვუთხრა ბრაუზერის ან ვინც ცდილობს
ეს, რომ ისინი წარმატებული.
ან, რომ სახის როგორც ჩვენ წარმატებული იყო ძალიან.
>> და არსებობს ამ სახის სპეციალური სინტაქსი in Javascript გამოცხადების
რუკას ამ გასაღებები, როგორიცაა ინფორმაციის ტიპი და ამ ღირებულებებს, როგორიცაა ტექსტის დაბლობს.
ასე რომ, თუ გადავხედავთ პასუხი, რომ ჩვენ მიიღო უკან Wikipedia ადრე, -
მე ვაპირებ ცდილობენ გადახვევა პატარა სწრაფად -
თქვენ გაქვთ ეს ღილაკები, როგორიცაა სერვერზე და ამ ფასეულობების Apache.
ასე, რომ თქვენ მოხვდით გასაღებები და ღირებულებები.
და თქვენ შეგიძლიათ მიუთითოთ ამ კვანძის რა გაგზავნის უკან.
>> ასე რომ, ეს არის რეალურად სახის, ზოგიერთ გზები, და გარკვეულწილად ეს არ არის
ნამდვილად, მაგრამ ეს ცოტა უფრო დაბალი დონის ვიდრე PHP კოდი, რომ თქვენ შეიძლება იყოს
წერა P მითითებული შვიდი რადგან PHP და Apache სახის იზრუნოს ზოგიერთი
ეს ყველაფერი თქვენთვის.
PHP-ში, თქვენ შეგიძლიათ override ნაგულისხმევი ქცევის წერილობით საკუთარი headers.
მაგრამ მიზნებისათვის, ჩვენ კიდევ წერენ ჩვენი საკუთარი თავით.
>> ასე რომ, რომ ხაზი აზრი ყველას, წერენ ხელმძღვანელი ხაზი?
OK.
გასაოცარია.
>> მაშ რა გავაკეთო არის მე დასრულდება პასუხი განაცხადა მიესალმები მსოფლიოში.
OK.
მაგრამ ეს მხოლოდ ფუნქცია ე.წ. მოთხოვნა დამმუშავებლის.
ასე რომ, ახლა მე რეალურად სახის გაკეთება რაღაც ამ ფუნქციას, არა?
>> ასე რომ, აქ რა გავაკეთო არის ეს ხაზი, რომელიც არ var სერვერზე შეადგენს
HTTP.create სერვერზე, და მერე გაივლის მოთხოვნით დამმუშავებლის.
ასე რომ, ეს სახის Node გზა შექმნაში სერვერზე.
და შეამჩნია, რომ მე გავლით მოთხოვნაში დამმუშავებლის.
ასე რომ, ეს ვეუბნებოდი createServer ფუნქცია, რომელიც მინდა, რომ ჩემთვის
სერვერზე, და, როცა სერვერზე იღებს საპასუხოდ, მე თქვენ გვჭირდებით, რომ მოვუწოდო ამ
მოითხოვოს კურატორმა ფუნქცია.
OK?
>> ასე რომ ხაზი საკმაოდ ბევრი სრულდება დაუყოვნებლივ.
ასე რომ, var სერვერზე ხაზი გაკეთდეს უფლება მას შემდეგ, რაც თქვენ, რომ საკმაოდ ბევრი.
ვგულისხმობ, რომ მას აქვს შექმნას გარკვეული შიდა სახელმწიფო ვიცი, რომ თქვენ უნდა
მოვუწოდებთ, რომ მოთხოვნა კურატორმა ფუნქცია, მაგრამ ის არ აპირებს იჯდეს იქ და
ვთქვათ აქვს შესახებ გაიგზავნა მე თხოვნით ჯერ არ გაქვთ?
აქვს შესახებ გამომგზავნა მოთხოვნა ჯერ არ გაქვთ?
ასე რომ არ დაბლოკოს.
OK?
>> ასე რომ, რა ამ ყველაფერს გააკეთებს არის ის, ძირითადად, ახლა ინახავს მომცეთ ამ კოდექსის
ამ მოთხოვნით კურატორმა ფუნქცია, და შემდეგ მიიღებს, რომ კოდი როცა ვინმე
რაც მოთხოვნით.
და მაშინ ჩვენ გავაკეთოთ server.listen.
>> 1337 არის საკმაოდ თვითნებური.
არ მქონდა კონკრეტული მიზეზი კრეფა რომ ნომერი.
ეს იყო სრულიად შემთხვევითი.
მაგრამ ეს მხოლოდ განსაზღვრავს პორტი.
ასე რომ ყველაზე ვებ სერვერები დაინახავთ, რომ ისინი გამოყენება პორტი 80 იმიტომ, რომ სახის
მსგავსი კონვენციას.
ასე რომ, თუ მე რაღაც, მე არ ვიცი, Wikipedia.org,
და მე ზუსტად მსხვილი ნაწლავის 8 -
oh wow, თქვენ ვერ ხედავთ, რომ.
მე ბოდიში.
უკუეთუ ვიქმ Wikipedia -
დავწერ აქ მხოლოდ ისე, რომ ნათელია კამერა.
მაგრამ თუ მე ამ შევიდა ბრაუზერი colon 80, რომელიც განსაზღვრავს წასვლა
Wikipedia.org at port 80.
ასე რომ, როგორიცაა ამერიკის შეერთებული შტატები მრავალჯერადი პორტების მოსწონს, სადაც თქვენ შეგიძლიათ დაძრულიყო
რამ სახის.
ასე რომ, ეს როგორც წასვლა ამ კონკრეტულ განათავსეთ ამ სერვერზე.
OK.
>> ასე რომ მე უბრალოდ აირჩია 1337.
არსებობს მთელი რიგი ნომერი რომ თქვენ შეგიძლიათ აირჩიოთ.
რომ არ იყო სრულიად განსაკუთრებული.
>> მაგრამ რა მე ვაპირებ ახლა არის მე ვაპირებ აწარმოებს Node.
ნება მომეცით რეალურად შევა, რომ რამდენიმე ხაზების ქვემოთ ასე რომ თქვენ შეგიძლიათ ნახოთ იგი.
მე ვაპირებ ამის გაკეთებას Node, და მე აპირებს simpler.js.
და ჩვენ ვსაუბრობთ, თუ როგორ უნდა Node შეიქმნა ცოტა.
მაგრამ ახლა ის მხოლოდ გაშვებული სერვერზე.
>> ასე რომ, ერთი რამ, ჩვენ შეგვიძლია ვცდილობთ რომელიც არ შეიძლება იყოს, რომ საინტერესო ის არის, ჩვენ შეგვიძლია რეალურად
ცდილობენ, რათა შეამოწმონ ის Curl.
ასე რომ, შემიძლია Curl, და ჩემი მანქანა არის ადგილობრივი მასპინძელი.
თქვენ ასევე ვხედავთ ამ წერილობითი მოსწონს ეს ხანდახან.
ადგილობრივი მასპინძელი და 127.0.0.1 სახის მოსწონს თქვენს სახლში კომპიუტერი.
ასე რომ, ეს როგორც საუბარი თქვენი კომპიუტერი.
OK.
>> და მაშინ შემიძლია ვთქვა, 1337.
ასე რომ, თუ მე აწარმოებს ამ ხაზი კოდი, იგი აცხადებს, რომ Hello World.
და თუ მინდოდა, რომ პერსონალი, ჰქონდა content ტიპის ტექსტის ჩვეულებრივი ან
რაც არ უნდა, შემეძლო, რომ ეს აქ.
და შეამჩნია, რომ არ ვთქვა, OK.
და მე არ text დაბლობს.
და შემდეგ იქ სახის ყველა ამ სხვა პერსონალი, Node დავუმატებთ in
არ არსებობს ჩემთვის.
ეს არ არის სუპერ მნიშვნელოვანია.
>> ვგულისხმობ, არსებობს გარკვეული სახის ტექნიკური ასპექტები იმ სახის
ზემოთ ლაპარაკი, მაგრამ რათა ნახოთ თქვენ, ასევე მაქვს ძალა
შეცვალოთ ეს გარშემო.
ასე, რომ შეიძლება უბრალოდ დაამატოთ bunch პერსონალის იგრძნობა.
და მაშინ ახლა, თუ გავითვალისწინებთ ჩემს გამომავალი, ეს იქნება, რომ.
ასე რომ, ამ სათაურებში ნიშნავს გარკვეული რამ to ბრაუზერები და რამ, როგორიცაა, რომ.
>> და headers შეიძლება ძირითადად ვუთხრა ბრაუზერის როგორ უნდა უპასუხოს რაღაც.
თუ თქვენ ოდესმე მსმენია cookies ადრე, თუ თქვენ ოდესმე ყოფილა აღიზიანებთ
by ვებ გვერდზე შექმნის cookies, ან ჩართული ბმულების ბლოკი ან
რამე მაგდაგვარს.
თქვენ შეგიძლიათ რეალურად მითითებული cookies ამ სათაურებში.
ასე რომ, ისინი ვუთხრა ბრაუზერის როგორ ქცევის რიგ შემთხვევებში.
OK.
>> ასე რომ იყო simpler.js.
ვინმეს გაქვთ რაიმე შეკითხვები რომ კოდის ფაილი?
OK.
ზემოთ.
>> მოდით ამოიღონ r, რომ და შევხედოთ simple.js.
ასე რომ, ეს არის საკმაოდ ბევრი იმავე პროგრამით.
მე უბრალოდ დაწერა ეს ცოტა განსხვავებულად იმიტომ, რომ მინდოდა დასალაგებლად შედეგი
ზოგიერთი თავისებურება JavaScript.
>> ასე რომ შეამჩნია, რომ მოთხოვნა კურატორმა ფუნქცია მთლიანად გაქრა.
Oh yep, არც თქვენ გაქვთ შეკითხვა?
>> აუდიტორია: Yeah, არგუმენტები რომ გავიდა, რომ
ფუნქცია, რა არიან ისინი?
>> KEVIN შმიდი: ასე რომ, იმ JavaScript ობიექტები.
ამ Node.js დოკუმენტაცია, ის ძირითადად ამბობს რა მეთოდები
ხელმისაწვდომია მათთვის.
ჩვენ უბრალოდ არ უნდა ჰქონდეს ხელმისაწვდომობა ეს მეთოდი ეწოდება წერენ ხელმძღვანელი და ბოლოს
და პერსონალის იგრძნობა.
მაგრამ არსებობს მთელი bunch მეტი მეთოდები.
>> და მაგალითად, ისევე, როგორც ერთი მათგანი კერძოდ rec, შეგიძლიათ გააკეთოთ
რაღაც rec.method რომელიც გეტყვით თუ არა ეს HTTP მისაღებად ან
HTTP ჩანაწერის მოთხოვნა და რამ, როგორიცაა, რომ.
ასე რომ იქ ყველა სახის სხვადასხვა თვისებები, მაგრამ ისინი ორივე
JavaScript ობიექტების, და ისინი უბრალოდ უნდა ფუნქციები მათზე, რომ თქვენ
შეგიძლიათ დაწეროთ რამ.
OK?
>> ასე რომ შეამჩნია, რომ მოთხოვნის კურატორმა მთლიანად გაქრა.
მაგრამ კოდი, რომელიც მე მქონდა თხოვნა კურატორმა ჯერ კიდევ არსებობს.
კიდევ მაქვს ამ res.writeHead და მე მაინც აქვს ამ res.end.
და რა ეს არის მაგალითი in JavaScript არის ეს იდეა
ანონიმური ფუნქცია.
და ანონიმური ჰგავს fitting სახელი , რადგან ეს სიტყვასიტყვით არ
აქვს სახელი.
არ არსებობს ფუნქცია თხოვნა კურატორმა არსებობს.
>> არ აქვს სახელი, მაგრამ მაინც მიმდინარეობს არგუმენტი.
ასე რომ, მე მაინც rec და res.
და მე მაინც აქვს კოდი.
ეს არის შესანიშნავად ჯარიმა JavaScript კოდი.
ასე რომ, შემიძლია განვაცხადო ფუნქცია გარეშე მკაფიოდ ვაძლევთ მას სახელი.
ეს ცოტა გაუგებარია, პირველ რიგში.
არსებობს, როგორიცაა სასარგებლო რამ რომ შეგიძლიათ გააკეთოთ
ეს ანონიმური ფუნქციები.
ვინმეს გაქვთ რაიმე შეკითხვები ამ, თუ OK უბრალოდ, ახლა,
სახის უბრალოდ მიიღოს, რომ ეს ყველაფერს გავაკეთებთ იგივე?
Yep?
>> აუდიტორია: ფუნქციები პირველი კლასი JavaScript?
>> KEVIN შმიდი: ისინი პირველი კლასი JavaScript.
და მხოლოდ ის ვიცი, რომ ეს ცნებები გავლის ანონიმური ფუნქცია, როგორიცაა
ეს ვრცელდება JavaScript, რომ თქვენ შეიძლება დაწეროთ თქვენი საბოლოო პროექტი
ბრაუზერში ძალიან.
ასე მაგალითად, JavaScript in თქვენი ბრაუზერის, ასევე, გარკვეულწილად ღონისძიება
ბიძგი იმ გაგებით, რომ ის, რაც თქვენ არ არის, როდესაც მომხმარებელი დააჭერს ამ
button, მინდა აწარმოებს ამ კოდი.
>> ასე რომ მსგავსი იდეები კლიენტის მხარეს, როდესაც მაუსის დაწკაპუნებით ან მათ
მაუსის მეტი ზოგიერთი გამოსახულება თქვენს ვებ გვერდზე, აწარმოებს ამ კოდი.
რომ შეუძლიათ სერვერები.
ასე რომ სახის მოსწონს საინტერესო მიზეზი, რის გამოც JavaScript არის ნამდვილად
შესაფერისი ან ზოგიერთი ადამიანი ფიქრობს, რომ ეს არის შესაფერისი ენაზე ამ სახის
ღონისძიება მძღოლი სერვერზე რადგან თქვენ გაქვთ ეს ანონიმური ფუნქციები.
თქვენ გაქვთ მთელი იდეა ამ ასინქრონული კოდი.
OK.
ვინმეს გაქვთ რაიმე შეკითხვა?
>> OK.
ასე რომ იყო simple.js.
მოდით შევხედოთ კიდევ ერთი ან რამდენიმე.
ასე რომ, ეს sleep.js.
ამიტომ არის ვინმე იცნობს C ფუნქცია ძილის?
ეხლა იქნებ ერთი ადრე ლექციები ან რამე მაგდაგვარს?
>> ასე რომ, ძირითადად შეგიძლიათ გაივლის ვფიქრობ ნომერი წამი ან თუ თქვენ იყენებთ U
ძილის ნომერი მილიწამებში ან nanoseconds.
და ძირითადად პროგრამა უბრალოდ შეწყვიტოს გაშვებული რომ დროის.
უფლება?
და მაშინ ვიღვიძებ საბოლოოდ და მაშინ ეს უბრალოდ გააგრძელოს გაშვებული
პროგრამა.
>> ასე რომ, ამ სერვერზე სახის აძლევს შთაბეჭდილება საძილე.
ასე რომ შეამჩნია, რომ ჩვენ გვაქვს ურთიერთობა res.writeHead 200 header როგორც
ადრე, მაგრამ მაშინ ჩვენ მოუწოდებდა ამ ფუნქცია მოუწოდა კომპლექტი შეყოვნება.
მითითებული შეყოვნება ასევე ხელმისაწვდომია თქვენს ბრაუზერში Google Chrome
ან Safari ან რასაც.
და ძირითადად, თუ რას აკეთებს აქ არის ის აღების ფუნქცია.
განაცხადის, კიდევ ერთხელ, ის ანონიმური ფუნქცია.
ასე რომ სახის cool რადგან ჩვენ გამოყენებით ანონიმური ფუნქციის ფარგლებში
ანონიმური ფუნქცია, რომელიც შეიძლება ცოტა უცნაური.
>> მაგრამ მიღების, რომ ფუნქცია, რომელიც ძირითადად ამბობდა - და გზა ამ
სამუშაოების 5,000 მილიწამებში, მინდა თქვენ შეასრულოს ეს ფუნქცია, რომელიც
უბრალოდ დამთავრდა პასუხი და წერს hey.
ასე რომ, ეს ქმნის შთაბეჭდილებას, როგორიცაა საძილე, მაგრამ გზა ამ რეალურად
მუშაობს ჩვენ აწარმოებს მეშვეობით ამ ხაზის ძალიან სწრაფად.
ჩვენ უბრალოდ წერა რაღაც.
და მაშინ ჩვენ ასევე აწარმოებს მეშვეობით ამ ხაზის ძალიან სწრაფად.
ასე რომ ჩვენ რეალურად არ აპირებს დაველოდოთ ხუთ წამში.
ჩვენ უბრალოდ აპირებს ეს კოდი მომენტალურად.
>> და შემდეგ იქ, კიდევ ერთხელ, ამ პატარა ღონისძიება მარყუჟი, რომ ახლა ეს რამ
რეესტრი, რომ ძირითადად მხოლოდ მუდმივად მიმდინარეობს გარშემო წრე
და ეძებს საათი ერთი თემა და განაცხადა, ხუთ წამში
გავიდა ჯერ არ გაქვთ?
და მაშინ, როდესაც ის ხედავს, რომ მეორე ხელში გადავიდა, როგორიცაა ხუთ წამში ან
რასაც, მაშინ იღვიძებს და ამბობს, oh, რა უნდა გავაკეთოთ?
Oh მაქვს აწარმოებს ამ კოდი.
და შემდეგ ის აპირებს აწარმოებს res.end hey.
>> ასე რომ კიდევ ერთხელ, ჩვენ არასოდეს ელოდება აქ.
ასე რომ, ეს არ არის, რომ ამ კოდექსის შიგნით ამ ფუნქციის აპირებს ხუთ
წამში აწარმოებს.
ეს კოდი აწარმოებს საკმაოდ ბევრი მომენტალურად, მინიმუმ შედარებით
ხუთ წამში, რომ ჩვენ ვსაუბრობთ შესახებ ადრე.
>> ასე რომ მხოლოდ ნახოთ ამ მოქმედებაში, შემიძლია Node.sleep.js.
და გააკეთა მე mess up რაღაც?
შესაძლოა.
უკაცრავად.
ვნახოთ რა შეგვიძლია გავაკეთოთ დაფიქსირება ამ.
OK.
ასე რომ, აუცილებლად გამოიყენებს Node.js.
მე მხოლოდ kidding.
OK.
მხოლოდ ერთი წ.
OK.
მე ვიცი, რა არის.
>> ასე რომ, ის არის, რომ ჩემი მეორე tab აქ, მე გაშვებული Node უკვე
იმავე მისამართზე, 1337.
ასე რომ, შეცდომა რომ ეს ესროლა, თუ გადავხედავთ მას რეალური მჭიდროდ არის, მისამართი
გამოყენება, EADDRINUSE.
ასე რომ მე უკვე იყენებს 1337 აქ.
ასე რომ, თუ მე დახურეს ეს off, და მერე ახლა სცადეთ ეს, იმედია, ყველაფერი
კარგად იქნება.
OK.
ასე რომ თქვენ შეგიძლიათ მხოლოდ ერთი რამ სახის მოსმენის on პორტში ერთდროულად.
სხვა გამოსავალი იქნებოდა ჩემთვის უბრალოდ შეცვალონ, რომ პროგრამა და
ეს იყოს, როგორიც 1338 ან რამე იგრძნობა.
>> მაგრამ ახლა ძილის მიმდინარეობს.
მოდით რეალურად ცდილობენ გარეთ ბრაუზერის ამ დროს, რადგან ის
პატარა unexciting ვხედავ ის ტერმინალში.
ასე რომ მე უბრალოდ აპირებს მისვლას, რომ 127 მისამართი კიდევ ერთხელ 1337.
და თუ ხედავთ, ეს -
მე არ ვიცი, თუ შეიძლება - მაგრამ ჩემი ბრაუზერის აღების ძალიან, ძალიან დიდი
დრო, რათა ჩატვირთოს ან მოსწონს ხუთ წამში.
>> და შემდეგ, რომ საბოლოოდ დასრულდა საპასუხოდ.
და ვერ ვხედავ, რადგან ის გადავიდა მეტი ცოტა, მაგრამ თუ მე
ამ პატარა პატარა, თქვენ ხედავთ, იგი აცხადებს, hey.
ამიტომ, მე მივიღე hey, მაგრამ მას შემდეგ, რაც ხუთ წამში.
და ეს შეიძლება იყოს პატარა სუფთა ვხედავ ის აქ ტერმინალში, ასე ვარ
აპირებს -
მოდით აქ -
მოდით Curl რომ მისამართი ისევ და ისევ 1337.
და მე უბრალოდ სახის უნდა იჯდეს აქ ხუთ წამში.
მაგრამ შეამჩნია, რომ სერვერზე შეგვიძლია new რეაგირება.
ასე რომ ბეჭდავს hey.
>> და დემო ეს, ძირითადად რა შემიძლია ამ მეორე tab -
ასე ვთქვათ, მე ამის გაკეთება სხვა tab, მე ვაპირებ ამის გაკეთებას Curl და იგივე
რამ ერთხელ.
და მე ვაპირებ ცდილობენ გამოაგდონ ამ ბიჭები off ამავე დროს.
ამიტომ მე ვაპირებ ამის გაკეთება, და მე აპირებს რასის აქ და მე
აპირებს ამის გაკეთებას კიდევ ერთხელ.
>> და მოდით ისე, რომ თქვენ ხედავთ, ორივე მათგანი.
რომ ერთი ნაბეჭდი hey და რომ ერთი ნაბეჭდი hey ყველა გზა -
მოდით, რომ ექსპერიმენტი ერთხელ.
რეალურად, მოდით გამოვიყენოთ ეს შეასრულა, თუ ეს OK.
>> ამიტომ მე ვაპირებ გამოიყენოთ shell, რაც საშუალებას იძლევა ჩემთვის ძირითადად აწარმოებს ორი ასლი
ამ პროგრამის პარალელურად.
ასე რომ ყველაფერს აწარმოებს პირველი პროგრამა და მეორე პროგრამის პარალელურად.
ახლა თუ დააჭირეთ Enter, ის აპირებს რათა, რომ მოთხოვნა საკმაოდ ბევრი
მომენტალურად ამავე დროს.
მოდით მივცეთ ამ გასროლა.
>> ასე რომ, ახლა შეამჩნია ის ამბობს, ორი პროცესებში.
და თუ თქვენ საინტერესო, რომ 27,000 ნომერი ძირითადად პროცესში პირადობის მოწმობა.
და შემდეგ შეამჩნია, რომ ნაბეჭდი hey ამავე დროს.
ეს არ იყო, როგორიც ჩვენ უნდა დაველოდოთ ხუთ წამი ერთი და მერე ამის შემდეგ,
ხუთი წამის შემდეგ კიდევ მეორე.
ასე რომ სახის, გარკვეულწილად, ის ნამდვილად არ მტკიცებულება, მაგრამ ეს
ინტუიციური მტკიცებულება, რომ ეს არ არის მხოლოდ მოსწონს ელოდება ხუთ წამში ახლოს და არ აძლევდა
მთელი თემა.
OK cool.
>> ასე რომ, Aaron კითხვაზე ადრე, რომ იყო, თუ რა, თუ რამე -
Yep?
>> აუდიტორია: Wait.
როგორ არის ის, რომ განსხვავებული printf ბუფერული, თუმცა?
არ ეს ავტომატურად ამის გაკეთება?
რატომ აღელვებს ეს?
>> KEVIN შმიდი: Oh, შეიძლება თქვენც ამბობენ, რომ კიდევ ერთხელ?
>> აუდიტორია: არ მოსწონს printf ბუფერული გააკეთოს ზუსტად იგივე რამ?
>> KEVIN შმიდი: printf ბუფერული?
>> აუდიტორია: Yeah.
OK.
არ იყო ერთი ტესტებში ისინი საუბარი იმაზე, თუ როგორ, თუ თქვენ უფლება printf
რაღაც და შემდეგ ეს პაუზის ერთი მეორე, და მაშინ თქვენ გაქვთ ეს loop ათი
ჯერ, ეს დაველოდებით ათი წამი და მაშინ printf ყველაფერი ერთად?
>> KEVIN შმიდი: Oh, OK.
>> აუდიტორია: ეს აკეთებს იგივე რაც მაშინ ამ შემთხვევაში?
>> KEVIN შმიდი: ასე რომ კითხვა იყო, ძირითადად ერთი ყოფილი ტესტებში
ან რამე, არ არსებობს საკითხი, რომ ძირითადად თუ ამბობენ ბეჭდვითი ვ 10
რამ დროს და შემდეგ slept როგორც პროცესი ბეჭდვის იმ out,
ბოლოს რატომღაც, ეს იქნებოდა უბრალოდ ნაგავსაყრელი იმ ყველა out ეკრანზე.
ასე რომ, არსებობს სახის ორ სხვადასხვა ცნებები აქ.
>> ასე ვფიქრობ ერთი რამ არის, რომ ამ შემთხვევაში, ჩვენ საქმე გვაქვს ორი სხვადასხვა
სახის ადამიანი სვამს სერვერზე რამ ამავე დროს.
და იმ მიზეზით, რომ printf სახის ელოდება, როგორიცაა, რომ და dumps ეს ყველაფერი გარეთ
ერთდროულად უფრო დაკავშირებული როგორ printf სახის -
ასე რომ გზა printf ფაქტიურად განხორციელებული ეს არის ძირითადად აქვს
გაიგო, რომ ოპერაციული სისტემის დაწერა რომ პერსონალის კონსოლი.
ასე რომ არ გვინდა, რომ გავაკეთოთ ყველაფერი, პერსონალის მაშინვე, როცა ამბობენ, printf
ზოგიერთი სიმებიანი იმიტომ, რომ შეიძლება კიდევ ძვირი თუ მას აქვს
გავაკეთოთ, რომ ყოველ ჯერზე.
>> ასე რომ, თუ თქვენ აკეთებთ printf hey, თქვენი პროგრამა არ შეიძლება რეალურად ბეჭდვა რომ
დაუყოვნებლივ კონსოლი.
ეს შეიძლება ითქვას, OK, მე დავწერე ის.
და შემდეგ სახის დაველოდოთ თქვენ მისცეს ეს ცოტა უფრო ადრე, ფაქტობრივად,
წერდა ის კონსოლი.
>> ასე რომ, იმ მიზეზით, რომ ეს იყო საქმე -
და ეს სახის unrelated რომ ძილის -
არის ის, რომ ძილის იყო ერთგვარი მხოლოდ გაუკეთეს იქ დემონსტრირება
ის ფაქტი, რომ ის არ დაწეროთ ეს სინქრონულად.
მაგრამ მიზეზი, რომ მხოლოდ შესრულება ისე, რომ თქვენ არ უნდა
მიიღოს, რომ ბევრი კონტაქტები ოპერაციული სისტემა.
>> მაგრამ აქ, რა ჩვენ ნამდვილად ცდილობს ამ ძილის რამ არის მხოლოდ შოუ
რომ როდესაც ჩვენ გვაქვს ორი ადამიანი გამოჩენის ამ ნახვა, ის არ აპირებს დააყენოს
მათ ხაზი, სადაც იგი აპირებს ამბობენ მე უნდა დაგეხმაროთ, და მაშინ, როდესაც მე
მთლიანად დასრულდა ეხმარება თქვენ შემდეგ ამ ხუთ წამში, მაშინ მე ვაპირებ
გადაადგილება გადატანა მომდევნო პირი.
ასე რომ, პირველი პირის მოთხოვნა არ გვაკავშირებს, რომ ღონისძიება loop
თუ ეს აზრი.
>> მაგრამ აქ არის რეალურად მაგალითი რომ რაღაც იქნება უსიამოვნოა
up ღონისძიება loop.
ასე რომ აქ საშინელი ფუნქცია გამოთვლაც nth Fibonacci.
ეს სიტყვასიტყვით უარესი გზით თქვენ შეგიძლიათ გამოთვლაც nth Fibonacci ნომერი.
და ეს არის რეალურად მხოლოდ უნდა ვაღიაროთ სადაც ეს მოვიდა,
არსებობს რეალურად -
ვგულისხმობ, შეგიძლიათ ცდილობენ წავიდეთ პოულობთ მას - მაგრამ იქ, ძალიან ხანგრძლივი წაკითხვა
პოსტი რომ ვიღაცამ დაწერა.
ეს მოსწონს ერთ იმ Reddit რამ.
მაგრამ ვიღაცამ გააკრიტიკა Node.js და ისინი გამოიყენება როგორც მაგალითი.
ასე რომ, მე სახის სასურველი უბრალოდ გაჩვენებთ ორ სხვადასხვა პერსპექტივები მხოლოდ მისაღებად
ზოგადად გაგება ცნებები უკან ამ ორი რამ.
>> მაგრამ ეს არჩეული უბრალოდ საშინელებაა, horribly არაეფექტური computationally
ინტენსიური გზა გამოთვლაც nth Fibonacci ნომერი.
ასე რომ, ისევე, როგორც მინიშნება, თუ რატომ არის ეს საშინელებაა, როგორც ერთი გზა?
Yep?
>> აუდიტორია: Say თქვენ დაიწყოს ერთად 1000.
1000 ყოფს შევიდა 999 და 998.
თითოეული ეს ყოფს შევიდა ორი რამ.
>> KEVIN შმიდი: მარჯვენა.
>> აუდიტორია: ყველა გზა down.
>> KEVIN შმიდი: ზუსტად.
ასე რომ მხოლოდ გავიმეორო კამერა, თუ დარეკეთ FIB on როგორც 1000 ან რამე
მოსწონს, რომ, ეს, ცხადია, არა ნაკლებ ან ტოლი ერთი ისე მე ვაპირებ
გადადით ამ სხვა შემთხვევაში, და შემდეგ მე ვაპირებ მოვუწოდებთ FIB 999 plus FIB 998.
და მაშინ საკმაოდ ბევრი ყველაფერი, მუშაობა, რომ FIB 999 არ არის
სახის ამ დონის.
თუ თქვენ დაცემას, ეს კიდევ უფრო გადაჭარბებული გარდა ამისა, მაგრამ თუ უბრალოდ
ვფიქრობ, კომპიუტერული FIB 998 იღებს ჩვენთვის საკმაოდ ახლოს FIB 999.
ამიტომ, ჩვენ უნდა იყოს ნამდვილად ცოტა მეტი ჭკვიანი, თუ როგორ ჩვენ სახის reuse
ეს, მაგრამ ჩვენ არ reusing ეს ყველაფერი ყველა.
ასე რომ, თქვენ წარმოიდგინეთ, ამ გიგანტური, გიგანტური ხე, რომელიც მხოლოდ საშინელებაა.
>> მაგრამ მაინც, OK.
ასე რომ იყო FIB.
ეს უბრალოდ იღებს, ხოლო გასაშვებად.
Yep?
>> აუდიტორია: [INAUDIBLE].
>> KEVIN შმიდი: Oh, შეიძლება თქვენც ვიმეორებ კითხვას?
>> აუდიტორია: [INAUDIBLE].
>> KEVIN შმიდი: Oh ასე რომ ეს არის უბრალოდ კოდი რომ იქნება ერთგვარი შესახებ
სერვერის მხარეს.
ასე რომ, ეს არ იქნება ნაპოვნი ბრაუზერის ან არაფერი.
ეს ძირითადად რა გვაქვს, რომ როდესაც მომხმარებლის აქ საკმაოდ ბევრი მარკა
მათი თხოვნით კიდევ ერთხელ, როდესაც ჩვენ ერთგვარი რომ მოთხოვნას, ჩვენ ვაპირებთ, რომ მოვუწოდო
ამ ფუნქციის სერვერზე მხარეს.
და მაშინ ჩვენ მიიღოს შედეგი უკან საწყისი მოუწოდებდა, რომ ფუნქცია.
და მაშინ ჩვენ უბრალოდ ბეჭდვა ის შესახებ.
ასე რომ, მომხმარებელს ნამდვილად არ მოგვარდეს ამ ფუნქციის ძალიან ბევრი.
>> ის იყო, რომ კითხვა?
ამჯამად რომ აზრი?
OK.
ზემოთ.
>> ასე რომ კიდევ ერთხელ, ჩვენ ეს მთელი res.writeHead რამ, სადაც ჩვენ ამობეჭდოთ
header.
და მერე ბოლოში საპასუხოდ აკეთებს ჯადოსნური ნომერი FIB 45.
მოდით უბრალოდ აწარმოებს ამ სერვერზე.
ამიტომ მე ვაპირებ გავაკეთოთ Node fib.js.
ასე რომ, ახლა ჩემი FIB სერვერზე გაშვებული.
>> და მერე აქ, მე ვაპირებ გავაკეთოთ ერთი მათგანი.
OK?
ასე რომ მე უბრალოდ აპირებს ამბობენ, Curl.
ასე რომ, ეს აპირებს ცოტა ხნით, მაგრამ იმედია მალე დასრულდება და
ეს იქნება ამობეჭდოთ, რომ 45 Fibonacci ნომერი.
>> აუდიტორია: [INAUDIBLE].
>> KEVIN შმიდი: ეს უნდა გაკეთდეს საკმაოდ მალე.
ასე რომ, ეს უნდა მიიღოს ხუთი ექვსი წამი.
მე არ ვიცი, რომ უბრალოდ V8 მყოფი super სწრაფი, მაგრამ ნებისმიერ შემთხვევაში, ეს არის
ძალიან მოკლე მაგალითი და მიზანმიმართულად inelegant არასამთავრობო ტრივიალური
გამოთვლები.
ასე რომ, რამდენიმე ხნის შემდეგ, იგი ამ.
>> მაგრამ ახლა, რა მოხდება, თუ იმავე სახის ექსპერიმენტი, როგორც ადრე, სადაც მე
ორი მოთხოვნა, ამავე დროს?
ასე რომ აქ მე ვაპირებ Curl on რომ მისამართი, და მე ვაპირებ
უნდა გავაკეთოთ კიდევ ერთი Curl.
და მახსოვს, როცა ეს გავაკეთეთ, რომ ძილის სერვერზე, როდესაც ჩვენ, ძირითადად, იყო ის,
მას შემდეგ, რაც ხუთ წამში, ისინი საკმაოდ ბევრი ორივე დაბრუნდა უფლება
დაახლოებით ამავე დროს.
ასე რომ, ეს არ იყო გაყინული.
>> მაგრამ მოდით ცდილობენ ახლა.
OK, ასე რომ მივიღეთ ჩვენი პროცესებში.
დამახსოვრება ეს პროცესი პირადობის მოწმობა.
ეს იქნება პატარა უხერხულია, ხოლო ჩვენ შეაფერხოს.
მოდით უბრალოდ აქ დარჩენა და დაველოდოთ.
>> ასე რომ, ერთი მათგანი უნდა მოვიდეს შემდეგ უკან, როგორიცაა -
OK, ასე რომ, ერთი დაბრუნდა.
მაგრამ მაშინ რატომ არა მეორე ერთი დავბრუნდებით უბრალოდ არ არის?
Yep?
>> აუდიტორია: სერვერის ვერაფერს ხოლო ის გამოთვლითი, რომ დიდი რაოდენობით.
>> KEVIN შმიდი: მარჯვენა.
ასე რომ, პასუხი იყო, რომ სერვერზე მართლაც არაფრის გაკეთება არ შეუძლია, ხოლო
ის გამოთვლითი რომ Fibonacci ნომერი.
ასე რომ, ახლა მე მივიღე ჩემი ორი რამ უკან.
მაგრამ ვფიქრობ, უბრალოდ ვიფიქროთ კოდი ცოტა მეტი, თუ როგორ მუშაობს
და ყველაფერი.
>> ასე რომ, ეს ფუნქცია აქ არის კოდი, რომელიც მე ვუთხარი ამ სერვერის გასაშვებად, როდესაც ის
იღებს ახალ შემომავალი მოთხოვნით.
ასე რომ, ეს უბრალოდ აპირებს ამ გზით მთელი კოდი, და მაშინ იგი აპირებს
უკან ღონისძიების loop და შემდეგ გააგრძელოს შემოწმების ახალი ღონისძიებები.
ასე რომ, ძირითადად, რასაც ჩვენ ხდება არის სერვერი
მოსმენის ახალი რამ.
პირველი პირი ითხოვს რა 45.
ჩვენ აწარმოებს ამ კოდი გამოთვლაც იგი.
ეს კოდი იღებს დაახლოებით ხუთ ექვს წამში აწარმოებს.
მაშინ ჩვენ დავუბრუნდებით იმ შემთხვევაში loop და შევამოწმოთ ახალი მოთხოვნები.
>> ასე რომ, ეს არის მაგალითი იმისა, თუ როგორ, თუ აქვს რამ, რომ ე.წ. გამოთვლაც
შეკრული, ან გამოიყენოთ უამრავი კომპიუტერული, არა ძალა, მაგრამ არის
computationally ინტენსიური -
ვფიქრობ, ერთი რამ ვთქვა, რომ ეს არის რომ ეს ფუნქცია აკეთებს მთლიანად,
ყველაზე ნაწილი, საკმაოდ სასარგებლო შრომის უფლება.
მთელი დრო, რომ უკუგამოძახება ფუნქცია ჩართულია, ეს იყო საკმაოდ
ბევრი ხარჯავს თავისი დრო მხოლოდ კომპიუტერული, რომ nth Fibonacci ნომერი.
>> მაგრამ ჩვენ მხოლოდ ერთი თემა გამკლავება.
In Apache მოდელი, როდესაც ორი ადამიანი გააკეთა თხოვნით კიდევ FIB 45, ჩვენ
ექნებოდა ორი სხვადასხვა თემა.
და მერე ოპერაციული სისტემის სამუშაო იქნებოდა, ან მომხმარებლის დონეზე
კოდი, რომელიც მართავს თემა, რომ მე იყო ნაჭერი, რომ წლის
CPU, ან თუნდაც თუ ჰქონდა მრავალჯერადი პროცესორები, გავრცელება მათ თანაბრად მთელს CPUs
ისე, რომ ისინი ორივე finish დაახლოებით ამავე დროს.
>> ასე რომ მხოლოდ აჩვენებს, თუ როგორ შეგვიძლია სახის - და ეს არ არის საერთო სრულყოფილი
გამოსავალი, მაგრამ ერთგვარი როგორ შეგვიძლია რათა ჩამოვსულიყავი აქ და გააკეთოს
ცოტა უკეთესი.
ასე რომ, რაც მე აქ არის პროგრამის მოუწოდა FIB C. და ეს ძირითადად იყენებს
კიდევ ერთი კვანძის მოდულები მოუწოდა ბავშვის პროცესი მოდული.
ასე რომ, მე შედის, რომ ზედა სახის მსგავსი მინდა ფუნტი მოიცავს
ბავშვის process.h ან რამე.
ახლა ხელი მიუწვდება ამ CP ცვლადი რომელსაც აქვს ყველა ჩემი ფუნქცია.
>> ასე რომ, ახლა, რასაც მე ვაკეთებ ამ საპასუხოდ გამოტანის მე გაშვებული ამ პროგრამის
dot slash FIB 45.
ასე რომ, რასაც მე ვაკეთებ - და მე უბრალოდ აპირებს დაიხევს out ამ პროგრამის
ცოტა -
არის მე დაწერილი C პროგრამა, რომელიც ძირითადად computes
nth Fibonacci ნომერი.
ასე რომ აქ მხოლოდ პროგრამის მე დაწერილი C რომ computes ეს.
შემიძლია კომპილირება და შემიძლია აწარმოებს ის ბრძანებათა სტრიქონიდან.
და ის აპირებს გამოთვლაც 45 Fibonacci ნომერი.
>> ასე რომ შეამჩნია ეს მხოლოდ იღებს საკმაოდ ბევრი გრძელი.
მე ალბათ შეეძლო გამოიყენება dash 03 to ოპტიმიზაცია იგი ან რამე მაგდაგვარს,
მაგრამ მე უბრალოდ, ისევე როგორც რეგულარული შემდგენელი პარამეტრები.
და ეს ბეჭდავს მას.
>> მაგრამ ახლა, რა ვარ მე სახის აკეთებს?
Oh უკაცრავად, არასწორი ფაილი.
ასე რომ, მე იგივეს პერსონალის სათაურს, როგორც ადრე.
მერე ამისათვის cp.exec.
რა ეს აპირებს არის ის აპირებს ამ პროგრამაში.
მაგრამ გზა ამ მუშაობს ის არის, რომ ის არ აპირებს დაველოდოთ
რომ პროგრამის დასრულება.
უბრალოდ ძირითადად ამბობს შეასრულოს ეს პროგრამა.
ასე რომ, ძირითადად აკრიფოთ ამ შევიდა command prompt სახის.
>> და მაშინ, როდესაც თქვენ გაკეთდეს ის, აწარმოებს ამ ფუნქციას.
ასე რომ, ახლა ჩვენ სახის მიიღოს ამ მთელი აღდგენილი რამ
ისევე, როგორც ჩვენ არ ელოდება.
ს, რომ ასეთი აზრი?
Yep?
>> აუდიტორია: [INAUDIBLE]?
>> KEVIN შმიდი: ასე რომ, ეს რეალურად გახსნას ახალი პროცესი უნდა გავაკეთოთ.
ასე რომ, ეს არის რეალურად, გარკვეულწილად, ბოროტი, არ არის სუპერ ბოროტი, მაგრამ ეს არის
მნიშვნელოვანია, რომ ვთქვა, რომ ეს არის ერთგვარი ბრუნდება, ერთი მხრივ, Apache
მოდელი, სადაც ჩვენ გავაკეთებთ თემა და პროცესები თითოეული მოთხოვნა ან
პროცესების თითოეული მოთხოვნით.
ასე რომ, ეს სახის ანალოგიური რა Apache აკეთებს.
ზოგიერთ შემთხვევაში, ეს იქნება უბრალოდ გამოიყენოთ new თემა, რომელიც ცოტა უფრო მსუბუქი
წონა, ვიდრე პროცესი, მაგრამ Apache იქნებოდა დასრულდება forking ახალი პროცესი
რომელიც სახის რას ვაკეთებთ აქ ირიბად ამით dot slash FIB 45.
>> და მაშინ ამ შემთხვევაში, ჩვენ სახის წარმოეშვას იგივე ხარჯები პროცესებში.
ასე რომ ეს არის მხოლოდ ერთი რამ შეგიძლიათ გააკეთოთ.
მაგრამ უბრალოდ რათა ნახოთ ამ სახის გაშვებული.
და ეს საუბარი მხოლოდ რეალურად მიზნად ისახავს წარდგენის ამ სახის პროგრამების, როგორც
გზა დავანახოთ სხვადასხვა პერსპექტივები როგორ უნდა შეიმუშაოს სერვერები, როგორიცაა, რომ.
ასე რომ, ეს არის გაშვებული და შემდეგ ახლა, თუ ეს კიდევ ერთხელ, მე მივიღე ორი პროცესი პირადობის მოწმობა.
>> მოდით უბრალოდ ვისაუბროთ რამ უნდა აღვნიშნო.
ასე რომ შეამჩნია, რომ ისინი incrementally.
ეს არის ის მაგარი.
რადგან ეს იყო 27.122 ადრე.
მაგრამ ცნობა, ახლა, ისინი დაბრუნდა დაახლოებით ამავე დროს.
>> და ახლა, კარგი კითხვა ვთხოვო შესახებ ამიტომ იყო, რომ საქმე, რომლის სამუშაო
იყო ეს ახლა ერთგვარი რათა ეს ყველაფერი სახის ითამაშოს სამართლიანი თითოეული
მეორე მხრივ, ეს ორი შემთხვევა dot slash FIB 45, მე გაიქცა
ან რომ Node ran?
ვინ სახის ხდის სამართლიანი, რომ ორივე მისაღებად სახის დაბალანსებული ტირაჟი დროს?
>> აუდიტორია: [INAUDIBLE].
>> KEVIN შმიდი: ჰო.
ასე რომ, ძირითადად, როცა ამის გაკეთება dot slash FIB 45 ან რამე მაგდაგვარს, ახლა კი
სახის მდე ოპერაციული სისტემა გაუმკლავდეს runtime იმ პროგრამებს.
და ახლა მას შეუძლია დანიშნოს მათ სხვადასხვა პროცესორები, ან
შეუძლია დანიშნოს მათ.
მას შეუძლია ნაჭერი up დრო, რომ ერთი CPU იღებს იგი ან რომ ისინი
აწარმოებს ერთი CPU.
ასე რომ იდეა, რომ.
ამჯამად, რომ აზრი, ყველას?
ახლა Node ნამდვილად არ თამაშობენ ნაწილი გამყოფი up ამ ამოცანებს.
OK.
>> ასე რომ თითქმის ეს მაგალითი.
მე უბრალოდ მინდოდა ნახოთ კიდევ ერთი რამ იმიტომ, რომ ბევრი ამ აქამდე უკვე
სრულიად super პრაქტიკული ზოგიერთ შემთხვევაში.
მე წარმომიდგენია მოდის სახლში შემდეგ გაიგო და რაღაც და განაცხადა, რომ მოსწონს,
ასევე მე სახის გადმოვიდა, რომ საუბარი, რომ მე შემიძლია Fibonacci სერვერზე
ჩემი საბოლოო პროექტი.
ასე რომ აქ უბრალოდ სახის კიდევ ერთი მაგალითი რომ იმედია იქნება -
იქნებ არა, მაგრამ იქნებ - ცოტა მეტი სახის შესაბამისი საბოლოო პროექტების და
ფიქრი ადრე რამ, როგორიცაა, რომ.
>> ასე რომ, ეს chat.js.
ასე რომ, ეს არის სახის მოსწონს ზოგიერთი ნიმუში სერვერის მხარეს კოდი, რომ თქვენ შეიძლება გამოიყენოთ
შეიქმნა მცირე სტატისტიკა სერვერზე, როგორიცაა თქვენ შეიძლება არ ჩანს
Facebook ჩატი ან რასაც.
ასე რომ, მე არ ვამბობ, რომ ეს არის, როგორიცაა Facebook სტატისტიკა, მაგრამ ეს არის ერთგვარი
ისევე როგორც კარგი - შესაძლოა არ არის კარგი, მაგრამ იქნებ კარგი - ამოსავალი წერტილი სტატისტიკა
სერვერზე თქვენი ნახვა საბოლოო პროექტი.
მოდით შევხედოთ, თუ რას აკეთებს.
>> ასე რომ, ჩვენ ვიღებთ ამ განსაკუთრებული რამ ზედა, ამ var SIO
შეადგენს მოითხოვს Socket.IO.
ასე რომ, ეს არის კიდევ ერთი რამ, რომ არ რეალურად მოდის შეფუთული ერთად
Node მაგრამ შეგიძლიათ დააინსტალიროთ.
ის Node მოდული.
ასე რომ, ისევე, როგორც ზოგიერთი გაგრძელების Node.
>> SocketIO არის რეალურად მართლაც სახის cool.
ეს არის აბსტრაქცია რომ ძირითადად რა ეს არ არის არის ის საშუალებას გაძლევთ
აქვს ამ ნაკადი ურთიერთობა შორის web
ბრაუზერი და სერვერზე.
ასე რომ, დიდი ნაწილი ჯერჯერობით, ჩვენ გვქონდა ეს ძალიან სწრაფად ერთი მეორე ან ორი
მეორე შორის კომუნიკაციების ვებ ბრაუზერი და სერვერზე.
ასე რომ, ძირითადად წასვლა google.com, ოჯახის პერსონალი, გაგზავნის იგი უკან, და შემდეგ
ჩვენ გავაკეთეთ.
ჩვენ არასდროს საუბარი ერთხელ, სანამ მომხმარებლის ტიპების რაღაც.
>> მაგრამ რა Socket.IO და მსგავსი სახის რამ - და SocketIO ფაქტიურად ერთი
რამ, რაც აგებულია როგორც WebSocket რაც სახის ხელმისაწვდომი
როგორც ნაწილი HTML5 -
რომელიც საშუალებას გაძლევთ, რომ ამ გრძელდება დიალოგი.
და ეს არის ძალიან სასარგებლო სტატისტიკა სერვერზე ასეთი რამ, რადგან ეს არის
სახის მოსწონს გრძელდება დიალოგი გარკვეულწილად, რადგან თუ თქვენ chatting
ვინმეს, შეგიძლიათ უბრალოდ გამოგვიგზავნეთ გაგზავნა ქვემოთ მილები, ხოლო შემდეგ
სერვერზე შეგიძლიათ გააგზავნოთ გაგზავნა ქვემოთ მილის მეორე პირი თქვენ
chatting ერთად.
და მაშინ აქვს ამ გაცვლა იგრძნობა.
>> ასე რომ სახის რა SocketIO კარგია.
იმ მიზეზით, რომ SocketIO იყენებს WebSockets როგორც ერთი ის არის, რომ
გარდა იმისა, რომ მხოლოდ ბარის ძველ WebSockets, მას ასევე აქვს გარკვეული ხრიკების ძირითადად
რათა ის ბრაუზერის თავსებადი.
ასე რომ, ბრაუზერები, როგორიცაა Internet Explorer სამწუხაროდ არ უჭერს მხარს WebSockets
უფლება out of box.
ასე რომ, იგი იყენებს ზოგიერთი სხვა სახის cool neat რამ Adobe Flash დაუშვას
თქვენ გაქვთ ჯვარი ბრაუზერის მხარდაჭერა.
ასე რომ, მართლაც სასარგებლო.
>> და რეალურად, მე ვიცი, მე სახის გაშვებული დრო, მაგრამ CS50
განიხილავენ, ოდესმე ჩანს რაღაც მოსწონს, მე არ ვიცი, ცარიელი ასე და ასე არის
პასუხით ჩანაწერი ან რამე მოსწონს, რომ თვისება?
ეს არის ის, SocketIO.
ასე რომ, როდესაც ვინმე იწყებს აკრეფით განხილვა ყუთი, რათა პასუხი ან
რაღაც, თქვენს ბრაუზერს არ რა მოუწოდა SocketIO გამოყოფს გარკვეული სახის
ღონისძიება, რომელიც აცხადებს, რომ ვიღაცა პასუხით ამ პოსტის.
>> შემდეგ სერვერი ამბობს, OK, რა უნდა გავაკეთოთ?
ისე ახლა მე უნდა ვუთხრა იმ სხვა ბიჭები რომლებიც CS50 იმსჯელებს ეძებს
ამ თანამდებობაზე, რომელიც ვიღაცის პასუხით.
ასე რომ სახის რა SocketIO არის კარგი, ეს გრძელდება სახის
ნაკადი დიალოგი.
OK.
>> ასე რომ, რა მაქვს აქ - და ჩვენ უბრალოდ აპირებს იგნორირება კავშირები მასივი
ცოტა -
რა გავაკეთო არის მე კიდევ მოუსმინოს.
ასე რომ უბრალოდ გზა Socket.IO არის ამბობდა, მოდით მოვუსმინოთ ამ პორტს.
და მერე ამისათვის კავშირი.
ასე რომ, უბრალოდ ძირითადად Socket IO-ს გზას ვამბობ, როდესაც ჩვენ ვიღებთ
დაკავშირებით, მინდა აწარმოებს ამ კოდი.
>> და შენიშნავს, რომ ნაცვლად, რომელმაც rec და res გავიდა იქ მაქვს Socket.
და ეს Socket იდეა არის ის, ძირითადად ამ რამ, რომ თქვენ შეგიძლიათ დაწეროთ და წაიკითხოთ
რომ აქვს მომხმარებლის ანკეტის შეტყობინებები შესაძლოა.
და შეტყობინებები, რომ თქვენ გააგზავნოთ შეუძლია გაიაროს, რომ Socket.
ამჯამად რომ აზრი?
ასე რომ, ეს გრძელდება რამ.
>> ასე რომ, რა გავაკეთო არის მოვუწოდებ Socket.emit.
და გადასცემს იღებს საკმაოდ ბევრად ორი არგუმენტები.
პირველი არგუმენტი არის სიმებიანი უბრალოდ წარმოადგენს ტიპის
რამ თქვენ ასხივებენ.
ასე რომ, ამ შემთხვევაში, მე გამოყენება ეს კონტექსტი new გაგზავნა.
და ეს მხოლოდ ძირითადად ამბობდა, რომ ტიპის ამ რამ, რა ვარ
გაგზავნის, არის ახალი შეტყობინება.
ასე რომ თქვენ შეგიძლიათ მოუსმინოთ კონკრეტული სახის როგორც ახალი გაგზავნა ან რასაც
გამოყენებით dot შესახებ.
>> ასე რომ, კავშირი და მომხმარებლის გაიგზავნა არსებობს, თუ გადავხედავთ, სადაც ჩვენ მოვუწოდებთ dot on,
იმ სხვა სტრიქონები, რომელიც წარმოადგენს სახის შესახებ შეტყობინებები.
ასე რომ, ძირითადად, თქვენ შეგიძლიათ ამ ასხივებენ ერთი ამ გაგზავნა ტიპის და
შემდეგ რაღაც საპასუხოდ ერთი ამ გაგზავნა ტიპი
>> ამიტომ მე ასხივებენ ამ ახალ გაგზავნა.
ჩვენ ვაპირებთ იგნორირება connections.push მეორე.
მაგრამ მაშინ მე ვიტყვი, Socket.on შესახებ გაიგზავნა.
ასე რომ, ახლა ეს სახის მოსწონს, როცა პროფაილი აგზავნის ჩემთვის გაგზავნა, მინდა
თქვენ აწარმოებს ამ კოდი.
და შენიშნავს, რომ ანონიმური ფუნქცია ხდება ამ ცვლადის
ე.წ. მონაცემები, რომელიც ძირითადად აპირებს აქვს შესახებ ცნობა.
>> ახლა მოდით სახის საუბარი კავშირები მასივი.
ასე რომ, ეს განკუთვნილია სტატისტიკა კლიენტი სადაც ძირითადად ყველას სახის
იგივე ჩატის.
ასე რომ, ძირითადად, რასაც ჩვენ უნდა შევინარჩუნოთ გარშემო რაღაც მასივი, რომ ძირითადად
წარმოადგენს ყველა იმ ადამიანს, chatting in გარკვეულწილად, თუ ეს აზრი.
უფლება?
იმის გამო, რომ ჩვენ უნდა ვიცოდეთ, ვინც იმ ბიჭებს ასე რომ ჩვენ შეგვიძლია გააგზავნოთ შეტყობინებები
რომ სხვა ადამიანების გაუგზავნე us.
>> რა ეს კოდი არ არის, როდესაც პროფაილი აგზავნის გზავნილი - ეს არის ტიპის
ღონისძიება -
ჩვენ ვაპირებთ აწარმოებს ამ კოდი.
და რას ვაკეთებთ არის ჩვენ აწარმოებს მეშვეობით array, რომ ჩვენ ე.წ. კავშირები.
და საკმაოდ ბევრი ყველა კავშირი გარდა ერთი, რომ ჩვენია, რომ
რა ეს კოდი თქმით, ჩვენ ახალი გაგზავნა, რომ ერთვის გაგზავნა
ინფორმაციას.
>> ასე რომ, თუ თქვენ შეამჩნევთ, აქ, რა გავაკეთე, როცა მომხმარებლის ძიებას new
კავშირი მე დასძინა ერთად JavaScript.push საშუალებას, რომ ეს არის
ძირითადად, მხოლოდ განაცხადა, რომ ისევე, როგორც რჩეულებში რომ Socket როგორც ღირებულების შევიდა
ჩვენი კავშირები მასივი.
ახლა, როდესაც ეს კოდი გადის, ეს იქნება გაუგზავნე რამ იმ კონკრეტულ
კავშირები.
ასე რომ, ეს შეიძლება იყოს კარგი ამოსავალი წერტილი მიღების სტატისტიკა სერვერზე
ან რაღაც მსგავსი.
>> და სახის cool ის არის, რომ კოდი, რომელიც ხედავთ აქ მოსწონს და
ასხივებენ და პერსონალის მოსწონს, რომ არის იგივე სახის JavaScript კოდი, რომ თქვენ
დაწერა ბრაუზერის ურთიერთქმედება სერვერზე.
ასე რომ, რატომ SocketIO არის ერთგვარი სისუფთავე და სასარგებლო, რომ გზა.
>> Oh და მხოლოდ ერთი რამ რეალური სწრაფი.
იყო CS50 საბოლოო პროექტი შარშან რომ ძირითადად ხორციელდება სტატისტიკა
სერვერზე Node.js.
მე ვფიქრობ, რომ Harvardchats.org მაგრამ მე არ ვარ -
OK.
მე არ ვარ დარწმუნებული, თუ რა URL არის, მაგრამ შემიძლია, რომ მას შემდეგ.
მაგრამ ეს სახის cool რა შეგიძლიათ გააკეთოთ Node.js.
>> ასე რომ, იმედი მაქვს, რომ, ზოგადად, თქვენ ბიჭები გვყავს კარგი გაგებით რა Node.js არის სასარგებლო
და როგორ შეიძლება იქნებ ვრცელდება თქვენი საბოლოო პროექტი.
მე იქნება გაგზავნის out კიდევ რამდენიმე რესურსები ერთად ეს.
და დიდი მადლობა გითხრათ მობრძანებისათვის.
დიდი მადლობა.
>> [ტაში]