>> ყველა უფლება.
ასე რომ cliffhanger იყო, რა არის Node.js როგორც მოგეხსენებათ, დღეს?
არაფერი? ჰო?
>> თითქოს ფარგლებში წერილობით JavaScript
პროგრამები ფართოდ -
>> OK, რომელიც მუშაობს.
>> - მე ვიცი, ისევე როგორც საერთო მიზნებისათვის, როგორიცაა -
ან რაღაც შეგიძლიათ გააკეთოთ მოსწონს -
[Inaudible შენიშვნა]
>> OK კარგი.
ჰო, ისე ის ფარგლებში.
ეს ძრავა, რომლითაც თქვენ შეუძლია შეასრულოს JavaScript კოდი
სერვერის საიტი.
ეს შეიძლება ნიშნავს მარტივი რამ
როგორიცაა წერა ბრძანების სცენარი არ Python ან Bash
ან Ruby ან PHP, მაგრამ in JavaScript თავად
და შესრულებაში მას მოციმციმე command prompt.
ან თქვენ შეგიძლიათ რეალურად აწარმოებს ის ფარგლებში სერვერზე.
და რეალურად ფარგლებში Node.js თავად,
ამ ჩარჩო არის მთელი bunch ბიბლიოთეკების, მათ შორის,
in HTTP სერვერის ჩამონტაჟებული.
ასე რომ, შეგიძლიათ რეალურად წერენ სერვერზე როგორც ვნახავთ
რაღაც მომენტში, სუპერ ადვილად უბრალოდ გაგება ცოტა
of HTTP და TCP და პორტები.
და თქვენ შეგიძლიათ ქვირითის მოსმენის სერვერზე გარეშე Apache,
გარეშე Microsoft-ის IIS.
რაიმე სხვა პროგრამული დაყენებული,
თქვენ შეგიძლიათ ქვირითის ამ და მოუსმინოს საუკეთესო ნებისმიერი port
სისტემა, რომელიც თქვენ უფლება აქვთ.
ასე რომ, საქმე და რაოდენობა, ნება მომეცით წავიდეთ და გახსნა
ამ მაგალითად, სერვერული 0.js.
ასე რომ შეამჩნია, რომ ზევით ეს ფაილი, უბრალოდ bunch
საქართველოს უინტერესო კომენტარები, და შემდეგ იქ რამდენიმე
წარმომადგენლობითი ხაზების კოდი რომ ჩვენ დავინახავთ recurringly.
ასე რომ, var HTTP იღებს მოითხოვს "HTTP".
ასე რომ, ჩაშენებული Node.js " ინფრასტრუქტურის მთელი bunch
მოდულები, რომლებიც მართლაც მხოლოდ ბიბლიოთეკები და ყველაფერი არის ერთგვარი
სახელი სივრცე უნიკალური იდენტიფიკატორი
როგორც ეს ერთი არის "HTTP".
ასე რომ, როგორც ბევრი ენებს, როგორიცაა Java და C + +
და C, მხოლოდ მაშინ, როდესაც იმპორტი ან არის
ან კვანძის საუბარი მოითხოვს მოდულის აკეთებს ბიტი.
და ყველა ხსოვნას მოითხოვს მისაღებად დატვირთული
შევიდა RAM და შესაბამისად გამოიყენება.
ასე რომ, თქვენ ერთგვარი ჩატვირთვა ამ ბიბლიოთეკების ან მოდულები მოთხოვნით.
ეს იმას ნიშნავს, რომ წავიდეთ წინ და მოითხოვს
ამ პროგრამის HTTP ბიბლიოთეკა,
და ეხება, რომ ბიბლიოთეკა გზა ცვლადში HTTP.
მაგრამ ეს მარცხენა სიმბოლო იქნებოდა უკვე მოუწოდა არაფერს, foo,
ბარი, baz, რომ არ აქვს მნიშვნელობა.
ასე განსხვავებით C + + და Java და C, სადაც, როცა მოითხოვს
ან იმპორტი ბიბლიოთეკა, ეს მხოლოდ ერთგვარი
of ხდება გლობალურად ხელმისაწვდომი,
Node.js მოდულები უფრო მჭიდროდ სივრცე.
ასე რომ, საკუთარი - რომ ფუნქციონალური არის მხოლოდ ხელმისაწვდომი მომენტში
გზით ამ ცვლადის სახელი.
თქვენ არ შეგიძლიათ დავიწყო ფერთა მეთოდები, რომ არსებობს
ეს უფლება გზა რომელიც, ალბათ, კარგი,
რადგან მაშინ თქვენი სივრცე არ მიიღოთ თითქმის როგორც cluttered
როგორც ბევრი ენებზე.
ყველა უფლება, ასე რომ, ახლა, როგორც საერთო ვარაუდობენ, ქმნის HTTP სერვერს
როგორც ჯონათან [აიღო მართლწერა] შესაძლებელი იყო ფაქტიურად
იმდენად მარტივია, რომ მოუწოდებდა შექმნა სერვერზე საშუალებას შიგნით
საქართველოს HTTP მოდული.
ასე რომ, ამ ბრუნდება მინიშნება
რაიმე სერვერზე.
იგი მოვიდა Apache, არ აუცილებლად, როგორც მძიმე წონა.
ეს ერთი პატარა მარტივი.
და ახლა, მე უნდა უბრალოდ უბრალოდ ცოტა რამ.
ასე რომ, პირველ რიგში, ნება მომეცით გადახვევა ქვემოთ ბოლოში აქ
და გამოტოვეთ დამმუშავებლის მეთოდი მომენტში.
და შეამჩნია ეს ხაზი კოდი,
server.on რომელიც არსებითად ნიშნავს სერვერზე -
მოსმენა, როგორც jQuery კოდი
მოსმენა ღონისძიება ე.წ. მოთხოვნა
და მხოლოდ მიიღოს ამოიცნობთ რა უნდა გავაკეთო
როდესაც თხოვნის ღონისძიება ხანძარი სერვერზე.
ჰო?
>> ზარის ფუნქციის დამმუშავებლის.
ასე რომ, ფაქტიურად შეასრულოს კოდი, რომელიც მითითებულია
ამ ცვლადი და რეალურად არ არის ცვლადი სიმბოლო აქ,
რა არის ის, რომ სიმბოლო მხედველობაში?
ისე, ეს სახელი ფუნქციონირებას აქ
და კურატორმა, როგორც ჩანს, იღებს ორ არგუმენტს.
რატომ ორი? ისე, თუ უბრალოდ წაკითხვის დოკუმენტაცია
ამ კონკრეტულ მოდული, თქვენ ეტყვიან, რომ კურატორმა
რომ იქნება გამოძახებულ იქნება გავიდა მინიმუმ ორი არგუმენტები,
მინიშნება მოთხოვნით,
და შიგნით თხოვნით ჩვენ სიტყვასიტყვით ნიშნავს HTTP მოთხოვნის.
ასე რომ, ყველა, ვინც HTTP სათაურებში რომ თქვენ შეიძლება გავიხსენოთ
დასაწყისში სემესტრის ან ზოგიერთი წინასწარი კლასი
ან გამოცდილება მოსწონს მიიღეთ ხაზი და მასპინძელი ონლაინ
და User-Agent ხაზი, ყველა რომ არის encapsulated და უფრო შიგნით
ამ მოთხოვნის ობიექტი.
და საპასუხოდ ობიექტი დალაგებულია მიმავალ მონაცემები.
ასე რომ, თქვენ გაქვთ მინიშნება წინააღმდეგი, რომ აპირებს საშუალებას გაძლევთ
გაგზავნის ინფორმაცია დაბრუნება ბრაუზერის დარეკვით მეთოდები
რომ ეს უკანასკნელი არგუმენტი ე.წ. Res განთავსების საპასუხოდ.
მაგრამ ეს შეიძლება ეწოდოს foo ან ბარი, ეს არის მხოლოდ კონვენციები.
ახლა, რა გავაკეთო?
ისე, როგორც ჩანს, შიგნით ამ სუპერ მარტივი სერვერზე
რომ მე განხორციელებაში, მე ვარ აპირებს შემდეგ.
მე ვაპირებ წერენ HTTP header სტატუსით კოდი 200,
200 მნიშვნელობა OK, ყველა კარგად არის.
და შემდეგ, მე ვაპირებ გადავიდნენ ჩანს.
რა მონაცემები ტიპის მეორე არგუმენტი მარჯვნივ ხელმძღვანელი?
>> ეს ობიექტი?
>> ეს ობიექტი რამდენი გასაღებები და ღირებულებები?
მხოლოდ ერთი თითოეული, მარჯვნივ, ერთი გასაღები ღირებულება წყვილი.
ასე რომ, 'შიგთავსის ტიპი'.
და ერთადერთი მიზეზი მე სიტყვებზე დაყრდნობით, რომ აქ არის
იმის გამო, რომ დეფისი შეიძლება conflated ერთი მინუსის
ან რამე მაგდაგვარს.
ასე რომ, მე უნდა ციტირებით აქ, singe ან ორმაგი შეთავაზებები.
თუმცა ისევ და ისევ საერთო პარადიგმის
in JavaScript კოდი, ხშირად ერთჯერადი შეთავაზებები ამ დღეებში,
მსხვილი ნაწლავის და მაშინ ღირებულება.
ასე რომ, ეს მხოლოდ ე.წ. გონება ტიპის.
ეს არის HTTP header რომ სიტყვასიტყვით აპირებს
უნდა იყოს კმაყოფილი დეფისი ტიპის colon ტექსტის slash ბარის, რომ აპირებს
გასაგზავნი სერვერზე ბრაუზერში
ისე, რომ browser იცის თუ არა, რომ აწარმოებს როგორც Raw ტექსტი
ან HTML ან ფოტო ან ფილმის
ან ფლეშ ფაილი ან არაფერი.
ახლა, სად მე რეალურად მინდა გაგზავნას ორგანოს გვერდი?
ისე, უბრალოდ კითხულობს დოკუმენტაცია
პასუხს ობიექტი შიგნით ამ ბიბლიოთეკაში.
მე ვხედავ, რომ არის მარჯვენა მეთოდი და რომელიც იღებს ტექსტი,
იქნებ სხვა რამ, მაგრამ მინიმალურად სიმებიანი.
და სიმებიანი არის რა შამფურზე ბრაუზერში.
ამ შემთხვევაში მისი სუპერ მარტივი, თავის Hello World,
მაგრამ ეს შეიძლება იყოს opne bracket, html, ახლო bracket,
ღია bracket ხელმძღვანელი, ახლო bracket და ა.შ.,
ეს შეიძლება იყოს Raw html.
მაგრამ ჩვენ შენახვა მაგალითად მარტივი უბრალოდ spitting
out მარტივი გონება ტიპი რომელიც სავარაუდოდ text / plain.
და შემდეგ response.end მხოლოდ ნიშნავს კავშირის დახურვისათვის
და გააგზავნეთ ყველაფერი მაქვს სახის buffered შიგნით
ამ ობიექტის უკან ბრაუზერში.
მე გაკეთდეს. ყველა უფლება.
ასე რომ, ბოლო რამ, მე ვაკეთებ ქვემოთ აქ
და ეს არის გარკვეულწილად თვითნებური და ნიშნავს, cool,
არის მე ვეუბნებოდი სერვერზე საბოლოოდ მოუსმინოს
გარკვეული TCP by default პორტი.
გავიხსენოთ დასაწყისში კლასი, რომ მომსახურება -
თუ თქვენ, როგორც წესი, ცალსახად იდენტიფიცირება ის ნომრები,
AD არის ვებ, 443 არის HTTP საფუძველზე საიტები, 22 SSH, 21 FTP
და 1337 მხოლოდ თვითნებური მაგრამ ეს უფრო მეტია, ვიდრე 1024
რაც იმას ნიშნავს, ყველაზე სისტემები, შემიძლია ეს
გარეშე სჭირდება სუპერ პროფაილი პრივილეგიები.
ასე რომ, ეს უბრალოდ მოსახერხებელია.
მაგრამ 8080 არის off - საერთო ერთი, 8088, მართლა არაფერი დიდი
იმ ათასობით საერთო მაგრამ ეს არის მხოლოდ უფრო ელიტის.
ყველა უფლება, ასე, რა მოხდება როცა რეალურად აწარმოებს ამ?
ისე, მე არ უბრალოდ ეწვევა გვერდზე ბრაუზერში.
ეს ფაილი ეწოდება server-0.js.
იმიტომ, რომ კიდევ ერთხელ, Apache არის ახლა გარეთ სურათზე
უკანასკნელი ნახევარი რა თქმა უნდა.
თუ მინდა ვებგვერდი სერვერზე, მე უნდა დაწეროთ
და შემდეგ აწარმოებს ამ სერვერზე.
მაგრამ აღმოჩნდება, რომ JavaScript როგორც კლიენტის მხარეს
და სერვერის მხარეს არის ინტერპრეტირებული ენა.
ასე რომ, ყველა მჭირდება არის თარჯიმანი.
ასე it's - თუ დაჟინებით აწარმოებს კვანძის და შემდეგ სერვერზე 0.js,
მე შეიძლება იყოს ან არ ვხედავთ ზოგიერთი გამომუშავება დამოკიდებულია
რა ბიბლიოთეკების მე შედის, არაფერი ჩანს ხდება.
მაგრამ ნება მომეცით წასვლა ბრაუზერი და ნება მომეცით წავიდეთ
იმავე IP მისამართი ჩემი CS50 კლიენტებს.
მაგრამ ეს შეიძლება მხოლოდ ასევე იქნება ჩემი Mac
ან ჩემი PC და შემდეგ დააჭიროთ.
რომ რეალურად გამოიყურება Apache.
ასეთი დირექტორია ჩამონათვალში ჩვენ ჩანდა
ერთი წლის პირველ ნახევარში.
ასე რომ, რა დავაშავე?
ჰო.
[Inaudible შენიშვნა]
ზუსტად, არა?
ასე რომ, Apache კვლავ მოსმენის on რა port 80.
მიუხედავად იმისა, რომ შეიძლება შეიცვალოს, რომ მე ვერ ჩართოთ ეს off ერთად
მაგრამ მაინც გაშვებული.
მაგრამ ეს ბიჭები სისტემაში რა თქმა უნდა თანაარსებობენ.
მე უბრალოდ უნდა დააყენოს მსხვილი ნაწლავის 1337 და შემდეგ იქნებ
ან იქნებ არ slash at ბოლოს წვდომისათვის ეს პორტი
რომ ამ სერვერზე არის გაშვებული.
და ახლა ვხედავ, რომ hello, მსოფლიოში დაბრუნდა.
და შემიძლია მოხვდა reload როგორც არაერთხელ, როგორც მე მინდა,
ის ჯერ კიდევ ემსახურება up გვერდზე.
მართლაც, თუ მე გახსნა Chrome-ს ინსპექტორი, წასვლა ქსელი
და შემდეგ განაახლეთ მთელი გვერდი,
შეამჩნევთ, რომ მართლაც ეს იყო თხოვნით გაიგზავნა.
იმ შემთხვევაში, თუ მე შევხედოთ Raw წყარო,
შეამჩნია ჩემი ბრაუზერი უგზავნის ყველა იმ რამ.
და მაშინ პასუხი სერვერზე იყო სუპერ მარტივია.
არის 200.
იმ შემთხვევაში, თუ ეს არ არის ძალიან მაღალი ეკრანზე,
არის content ტიპის.
და შემდეგ Node.js სახის ავტომატურად
ჩემთვის დასძინა თარიღი და ყველა სხვა პერსონალი
რომ ბრაუზერები ჩვეულებრივ ველოდოთ.
ასე რომ, მოდით უბრალოდ ნახეთ ცოტა საღი აზრის ქვითარი.
ნება მომეცით დაბრუნდეს კოდი in server-0.js და ნება მომეცით -
ყოველ ჯერზე მე წასვლას კურატორმა,
ნება მომეცით უბრალოდ ამბობენ console.log.
("ჩვენ გვქონდა სტუმარი!").
მე არ უნდა recompile ან რამე მსგავსი,
ის ინტერპრეტირებული ენა.
ახლა, ნება მომეცით დაბრუნდეს გვერდზე, განაახლეთ ერთი, ორი,
სამჯერ და წავიდეთ უკან ჩემს ფანჯარაში.
და ახლა მე ვხედავ ამ.
ის, რომ უცნაურია, მე ვხედავ ექვსი ხაზები.
საინტერესო ვებ trivia, რატომ მე კიდევ ექვსი მოთხოვნა არ სამი?
ჰო?
[Inaudible შენიშვნა]
ჰო. ასე რომ, როგორც მოგეხსენებათ ცოტა სულელური ხატი დაბრუნება
ბრაუზერის ბარი, რომ ბევრი
საიტებზე გამოყენებული ძალა იყოს ჰარვარდის crest,
ეს შეიძლება იყოს კომპანიის ლოგო ან რამე მსგავსი.
ასე რომ, ბრაუზერები ამ დღეებში სახის
საქართველოს presumptuously მიიღოს დამატებითი HTTP მოთხოვნა
თითქმის ყველა ნახვა, შედიხართ შემოწმება, თუ არსებობს
სტანდარტულად ფაილი ე.წ. favicon.ico
იგივე დირექტორიაში, როგორც ფაილი თქვენ მოითხოვა.
და თუ ასეა, ეს აყენებს ხატი არსებობს.
ასე რომ, ყველა ჩვენ ვხედავთ სწორედ რომ.
და ფაქტობრივად, ვნახოთ, თუ ჩვენ ხედავთ ამ, ვიდრე ტიპის
მხოლოდ "ჩვენ გვქონდა სტუმარი.
ნება მომეცით წავიდეთ წინ და გამომავალი.
და მხოლოდ ის ვიცი, ეს ეძებს დოკუმენტაცია.
არსებობს საკუთრების შიგნით თხოვნის ობიექტი მოუწოდა URL
რომელიც ხდება უნდა იყოს გზა
რომ ეთხოვა ფაქტობრივი URL.
ასე რომ, თუ მე გადატვირთეთ სერვერი უბრალოდ rerunning კვანძის
on server-0.js და ახლა ამის გაკეთება ერთი, ორი,
სამი და დაბრუნდეს აქ.
არსებობს ეს.
Slash არის ის, რაც მე - ადამიანის მოითხოვა
in favicon.ico არის რა ბრაუზერს
presumptuously მოითხოვს.
მაგრამ საქმე არ არის იმდენად favicon პერსონალი
მაგრამ რა სერვერზე ოპერაცია.
ჰო?
>> რატომ, რომ აქვს ზოგიერთი მოთხოვნა?
>> რატომ, რომ უნდა - ბუნებით, თუ როგორ HTTP მუშაობს.
ასე რომ, HTTP შეგიძლიათ მხოლოდ მოითხოვოს ფაილი დროს.
ბრაუზერები შეიძლება იყოს ჭკვიანი ამ დღეებში
და შენარჩუნება TCP კავშირი ღიაა.
თუ აიღო CS143 ან საერთოდ იცნობს ქსელის,
ასე რომ თქვენ შეგიძლიათ ეფექტურობის მიღწევების
შენახვა ქსელში socket ღია
მიღების მრავალი HTTP მოთხოვნები სერიულად მეტი
მაგრამ ისინი ერთი ფაილი პოსტი მოთხოვნა.
ასე რომ, თუ თქვენ ეწვევა რაღაც -
ვგულისხმობ ჩვენ შეგვიძლია წავიდეთ საუკეთესო ნებისმიერი საიტებზე.
თუ წასვლა - მოდით დახევის up Chrome-ს ინსპექტორი აქ.
ეს შეიძლება მიიღოს შეავსოთ საუკეთესო გვერდზე.
გადასვლა ქსელის tab და წასვლა www.cnn.com.
და როდესაც თქვენ ეწვევა cnn.com, მისი გვერდი -
თქვენი ბრაუზერის საკმაოდ atrociously რაც - ჯერ დათვლის.
OK. მინიმუმ 289 HTTP მოთხოვნები ისევ და ისევ.
და სწორედ ამიტომ, როდესაც თქვენ განსაკუთრებით bloated საიტებზე,
ისინი ნელი ჩატვირთვა იმიტომ, რომ ყველა
აქტივების ისინი loading.
ასე რომ, როგორც ჩანს 298.
შეიძლება არსებობს Ajax მიმდინარეობს ამ ეტაპზე ან რამდენიმე
აქტივების უბრალოდ დაბალია.
ასე რომ, თითოეული მათგანი არის ინდივიდუალური მოთხოვნის ბრუნდება
და მეოთხე, უკან და მეოთხე.
და ამიტომაც ადრე, მიუხედავად იმისა, თუმცა ჩვენ ერთგვარი ისაუბრა
ამის შესახებ გარკვეულწილად fancifully სადაც თქვენ დააყენა სკრიპტი tag,
სრულიად იღებს განსხვავება, როდესაც თქვენ -
ეს დაიწყება ბევრი ტრანსპორტისა და ბევრი
ფაილი მიმდინარეობს მოითხოვა.
და თითოეული ეს წარმოადგენს ალბათ, სურათი, მედია ფაილი,
JavaScript ფაილი, CSS ფაილი ან მოსწონს.
ასე რომ, ჩვენ უკვე მდე ზოგიერთი 4 მბ მხოლოდ
შევხედოთ დღევანდელ ამბები.
კარგი კითხვაა.
ყველა უფლება.
ასე რომ, რა არის ზოგიერთი upsides თუმცა?
უფლება, ჩვენ ვიცით, როგორ უნდა გააკეთოს webpages უკვე PHP.
და ბევრ თქვენგანს მოვიდა კლასი იცის Django
და Python ან რელსები ერთად Ruby.
ასე რომ, რატომ გვჭირდება კიდევ ერთი ენა და ინფრასტრუქტურას?
რა არის Node.js განსაკუთრებით კარგი, თუ იცით?
[პაუზა]
ზოგიერთი რამ?
არა? ჰო?
>> დაყრდნობა შეტყობინებები.
>> ასე რომ, relaying შეტყობინებები.
ასე რომ მართალია და ეს სიმართლეა უფრო ტექნიკური მიზეზი
და რომ Node.js და მართლაც JavaScript განსაკუთრებით
კარგად გაუზიარონ ასინქრონული კოდი,
თუ, რომლის დროსაც თქვენ შექმნა ილუზია
აკეთებს სხვადასხვა რამ ერთდროულად.
ასე რომ, მიუხედავად იმისა, რომ ისინი მართლაც ხდება სერიულად,
მართლაც, უმეტეს შემთხვევაში, JavaScript როგორც კლიენტის მხარეს
და სერვერის მხარეს არის ერთი თემა.
რომელიც, თუ თქვენ აღების 161 ან თუნდაც 61 იმას ნიშნავს, რომ -
ამ პროგრამის იცით,
თარჯიმნის შეგიძლიათ სიტყვასიტყვით მხოლოდ ერთი რამ ერთდროულად.
მაგრამ ეს არ არის დიდი რაღაც სერვერზე
სადაც თქვენ ალბათ ათობით ან ასობით ან თუნდაც ათასობით
მომხმარებლების ყველა ცდილობს თქვენი webpage
ამავე დროს.
და მაინც, რომ მიაჩნიათ, რომ გატარება მათ ერთი
შემდეგ სხვა შემდეგ სხვა მით უმეტეს, თუ გარკვეული
იმ მოთხოვნით, როგორც ვნახეთ CNN-ზე შეიძლება მოითხოვოს ემსახურება
300 ფაილი სანამ კიდევ მომდევნო შესახებ
ვისაც სურს, რომ ნახოთ ამბობს ამბები.
Node.js უფრო შეეფერება განთავსების გარემოში, როგორიცაა, რომ.
რადგან ის, რაც ხდება არის ის, ნებისმიერი ნელი გაშვებული პროცესი
მოსწონს კითხულობს ფაილი დისკზე ან querying მონაცემთა ბაზაში ან საუბარი
რამდენიმე სხვა ქსელის სერვერზე,
რომ tends აქვს შეყოვნება, არა?
თუ თქვენ არ მიიღოს 61 ან 161 განსაკუთრებით ყველა ამ სახის
პერიფერიული მომსახურება როგორც წესი, ბევრად უფრო ნელა
ვიდრე აკეთებს არაფერს შიგნით იგივე RAM და იგივე CPU
რომ ვთქვათ, ამ შემთხვევაში სერვერზე არის რეალურად გაშვებული.
მაგრამ რა არის ლამაზი შესახებ Node.js არის, რომ თქვენ შეიძლება -
და JavaScript უფრო ზოგადად არის, რომ თქვენ შეგიძლიათ გააკეთოთ რაიმე
და მერე ამბობენ, "Hmm, ამ აპირებს
მიიღოს ჩემთვის რამდენიმე მილიწამებში ან თუნდაც რამდენიმე წამში.
ნება მომეცით ერთგვარი ჩანგლის, რომ off, " მაგრამ ეს არ არის ნამდვილი პროცესში.
და მაშინ, როდესაც ეს კეთდება აკეთებს რომ ნელი გაშვებული პროცესი
ისევე როგორც grabbing რიგები მონაცემთა ბაზის ან კითხულობს ფაილი. html
საწყისი დისკზე, ეს იქნება დავუბრუნდეთ ჩემთვის საკმაოდ
ვიდრე მე დაველოდოთ მას.
ასე, რომ ეს უფრო ნათელი.
ეს არის ჩემი საშუალებით მიღების ეს უფრო იცნობს.
ყველა უფლება, ასე რომ ეს არის Shake Shack მოედანზე.
ეს არის ერთგვარი საერთო პარადიგმის
ასახსნელად asynchronicity.
ეს არის რეალურად კარგი მაგალითად, იმის გამო, რომ Shake Shack
და Tasty Burger საოცრად ნელი, რასაც ისინი.
მაგრამ საქმე ის არის, რომ ისინი ნამდვილად კარგი აღების ბრძანებებს
და აღების თქვენი ფული შემდეგ რომელიც თქვენ დაველოდოთ თქვენი საკვები.
ასე რომ, ეს არის რეალურად უკეთესი დიზაინი, ვიდრე ალტერნატივა.
იმიტომ, რომ ვფიქრობ, თქვენ ფეხით შევიდა მაღაზიაში მოსწონს ეს და შენ
წინა ხაზი და თქვენ განთავსდება თქვენი ბრძანება და გსურთ
to ბურგერი, როგორც საუკეთესო შემიძლია გეტყვით, სჭირდება მინიმუმ ხუთი
ან მეტი წუთი რეალურად მიიღონ ბურგერი.
ასე რომ, ეს იქნება ერთგვარი ცუდი ბიზნეს მოდელი
თუ მაშინ, როცა თქვენ ელოდება თქვენი ბურგერი, Alice [აიღო მართლწერა]
და ბობ [აიღო მართლწერა] და ჩარლი [აიღო მართლწერა]
და ყველას queuing უკან
და თქვენ სიტყვასიტყვით დაბლოკვის ხაზის ელოდება თქვენი საკვები.
ასე რომ, ცხადია, ერთი Shake Shack
და სხვა სწრაფი კვების ადგილები არ გააკეთებს,
ისინი რაღაც მსგავსი.
მათ მოგცემთ buzzer.
და მათ ერთგვარი გამოგიგზავნოთ თქვენი გზა.
და მათ მოვუწოდებ თქვენ უკან რაც ამ პატარა რამ vibrate
ან ფლეშ მიიღოთ თქვენი ყურადღება.
ასე რომ, ეს არის ფაქტიურად რა?
რაღაც Node.js აკეთებს.
იმ შემთხვევაში, თუ Node.js ან JavaScript უფრო ზოგადად გამოიყენება
და პროგრამისტი არის ჭკვიანი საკმარისი
გააცნობიეროს, "თქვენ იცით, რა?
რასაც უნდა გავაკეთოთ უფლება აქ შეიძლება გარკვეული ნომერი
საქართველოს მილიწამებში ან წამში.
იცით რა?
ნება მომეცით წავიდეთ წინ და არა ეძახით სინქრონულად -
"რომ არის ბიჭი ბლოკირება ყველას ხაზი, "-
ნება მომეცით წავიდეთ წინ და სახის დაიხევს განზე
და უბრალოდ მოვუწოდებთ თავს უკან
როცა ეს ხანგრძლივი გაშვებული ოპერაცია არის სრული. "
და კვლავ უკან, რა თქმა უნდა არის გულისხმობდა ამ შემთხვევაში,
რომ გადმორეკე ფუნქცია, მინიშნება chuck კოდი
რომ მიიღებს შესრულებული როდესაც თქვენი ბურგერი მზად არის,
ჰგავს ეს რამ აქვს გარკვეული სახის ფუნქციონალური ჩაშენებული
რომ იგი იწყებს ვიბრაციული ან buzzing როდესაც დროა თქვენთვის
ეწოდოს დაბრუნება ფრონტის ხაზი.
ასე რომ, რას ნიშნავს რეალური თვალსაზრისით?
ასევე, ჩვენ უნდა მუშაობა ჩვენი გზა up.
ასე რომ, ნება მომეცით წავიდეთ წინ და ამის გაკეთება პირველი.
In სერვერზე 1.js, ნება მომეცით პირველი გამარტივება კოდი
ასე რომ, ჩვენ შეიძლება მიიღოს Baby ნაბიჯები მიმართ უფრო მყარი პრობლემა.
ეს არის ზუსტად იგივე პროგრამა რომ დავწერე ადრე.
მაგრამ რა შეიცვალა?
არსებობს სახის მცირე სინტაქსური განსხვავება
შორის ამ და მობილური 0 მომენტში წინ.
რა jumps out at თუ გახსოვთ?
Yeah Cynthia [აიღო მართლწერა]?
[Inaudible შენიშვნა]
ჰო. ახლა, ჩვენ ხაზი ფუნქციის მიმდინარეობს გავიდა შემოსული
ჩვენ მიღებული მოშორება სახის
საქართველოს uselessly დაასახელა კურატორმა ფუნქცია.
აზრი არა აქვს მხოლოდ, რომ ადრე კი უწოდა ერთ ადგილას,
მე ნამდვილად არ უნდა დაკარგავთ დროს ვაძლევთ მას სახელი
და რაც უფრო რთული წაკითხვის კოდი ზემოდან.
ასე რომ, მოდით უბრალოდ განაცხადოს inline არის ანონიმური ფუნქცია.
და მე ვაკეთებ ორი სხვა რამ.
მე მიღების უკეთესი გამოყენების dot ნოტაცია.
ასე რომ, როგორც jQuery, ბევრი კვანძის მეთოდები შეიძლება მიჯაჭვული ერთად.
ისე, რომ ერთხელ თქვენ კეთდება მოუწოდებს რაღაც, თქვენ არ გაქვთ
დაველოდოთ ახალი ხაზი და მოვუწოდებთ კიდევ ერთი მეთოდი,
შეგიძლიათ უბრალოდ ჯაჭვი მათ ერთად.
და ა.შ. ამ გზით, ჩვენ შეგვიძლია ნამდვილად გამკაცრდეს ამ მდე.
ასე რომ, ეს არის ფაქტიურად სერვერზე ხუთ ხაზები
კოდი სულ განსხვავებით -
განსხვავებით, თუ რა შეიძლება ნორმალურად უნდა გავაკეთოთ, რათა შექმნას რაღაც up.
თუ მე წასვლას სერვერზე 2 ახლა, მოდით გავაკეთოთ ეს.
სერვერზე 2 - რეალურად მოდით დავბრუნდებით რომ სერვერზე 2.
მოდით ახლა გახსნა async-0.js და მივმართო, რომ პრობლემა ხელთ.
ასე რომ, პირველი, მოდით წავიდეთ წინ და ღია
up async-0.js ბრაუზერში.
ასე async-0, ნება მომეცით წავიდეთ უკან ბრაუზერში.
მოხვდა განახლება.
და ახლა, ამ სახის საქართველოს შეცდომა.
მართლაც მე ხედავს 500 in Chrome-ს ინსპექტორი.
მაგრამ ნება მომეცით უფრო ზუსტად მოითხოვოს hello.txt.
OK. ასე რომ, ეს როგორც ჩანს მუშაობა.
ასე async-0.js არ ჩანს ემსახურება up რაღაც ხაზი.
მას არ აქვს ნაგულისხმევი ფაილის მხარდაჭერა.
მაგრამ თუ მე მკაფიოდ მოითხოვოს hello.txt,
რომ როგორც ჩანს, მხარს უჭერს.
რატომ არის, რომ?
ისე, რა მე წასული აქ
და გაკეთდეს ხორციელდება სუპერ მარტივი სერვერზე
იმაზე, სადაც asynchronicity შეიძლება იყოს სასარგებლო.
და რომელიც ხორციელდება ასეთია.
პირველი, მე გამოყენებით HTTP მოდული ერთხელ,
არამედ FS რომელიც ალბათ დგას?
ზოგადად CS, ფაილური სისტემა.
OK ფაილური სისტემა.
ამიერიდან FS, ფაილური სისტემა.
ყველა უფლება, ასე რომ ამჯამად ამ მომეცი?
ფუნქციონალური დაკავშირებული ფაილი როგორიცაა მიღების გავიდა,
გახსნის ფაილი, წერა დირექტორიები, კითხულობს დირექტორიები
და ყველა რომ მსგავსი საქმიანობები.
ასე რომ, ახლა შეამჩნია, ეს კოდი არის იგივე როგორც ადრე,
შექმნა სერვერზე, გავლით in ანონიმური ფუნქცია.
ეს არის სახის თვითნებური.
ეს არ არის ძალიან უსაფრთხო სერვერზე.
სინამდვილეში, თქვენ ვერ შედიხართ ყველაზე ნებისმიერი ფაილი ჩემს მყარ დისკზე
ან სერვერზე მყარ მანქანა განახორციელეს ეს კოდი
იმიტომ, რომ მე უბრალოდ ბრმად თუ გავითვალისწინებთ, რომ მე ვაპირებ
აითვისებდა რასაც შესახებ მოთხოვნილი URL.
და მე ვაპირებ პრეფიქსი იგი dot
ასე, რომ მე ოდნავ უსაფრთხო
იმით, რასაც ფაილი მათ შეუძლიათ მოთხოვნა აქვს მინიმუმ დაწყება
მიმდინარე დირექტორიაში.
რა თქმა უნდა, არსებობს საფრთხე აქ.
"მიზეზი, თუ მათ ნაცვლად არის რა?
მათი გზა, მათ შეუძლიათ ასეთი მუშაობის გარშემო, რომ ძალიან.
Dot, dot, არა?
ასე რომ, თუ მომხმარებელს მხოლოდ დააყენა dot, dot URL, თეორიულად,
ისინი შეიძლება დაიწყოს მიღების my - და აცხადებენ დაგავიწყდათ ფაილი.
ასე რომ, ეს არ ნიშნავს, იყოს უზრუნველყოფილი,
ეს ნიშნავს, რომ მარტივი.
ასე რომ, აქ, მე მაქვს ცვლადი, რომელიც არის გაერთიანების of dot
რომელიც იმყოფება დირექტორია და თხოვნით URL
რომელიც ჩვენ ვნახეთ ადრე ისევე როგორც ირიბის ან / hello.txt.
ახლა, იგი იღებს ცოტა უფრო საინტერესო.
პირველი შეამჩნევთ ბოლოში.
მე მოსმენის შესახებ იგივე პორტი, როგორც ადრე.
ასე რომ რეალურ საინტერესო მუშაობა შიგნით აქ.
ყოველ ჯერზე თხოვნა მოდის ბუნებით
ამ კოდექსის, რა ვარ მე აკეთებს?
მე მოუწოდებდა ფაილი სისტემის წაკითხული ფაილის მეთოდი,
გავლით გზა რომ მინდა წაიკითხოს.
და ახლა, ეს არის რა არის საინტერესო აქ,
ეს არის განხორციელება in ასინქრონული მეთოდი.
თქვენ არ შეგიძლიათ მიიღოთ დაბრუნება ღირებულების წაკითხული ფაილი.
ფაქტობრივად ცნობა, არ არსებობს არა მარცხენა გამოხატვის
მარცხენა წაკითხული ფაილი.
ის არ დაბრუნდება მნიშვნელობა.
პირიქით, ის მოუწოდებს უკუგამოძახება ფუნქცია, როდესაც ის მზად არის
გადმოგცეთ უკან პასუხს.
ასე რომ კიდევ ერთხელ უნდა იყოს მკაფიო, ხოლო yesteryear,
მრავალი პროგრამირების ენებზე, თუ უნდოდა
წაკითხვის ფაილის საქმე წერტილი PHP,
ფაილის ხაზგასმა მისაღებად ხაზგასმით შინაარსი,
თქვენ გაქვთ მარცხენა გამოხატვის ყველა ღირებულება შემდეგ -
ადრე თანაბარი ნიშანი, ეს ნიშნავს, რომ თქვენ მინიჭების
რომ ცვლადი დაბრუნება ღირებულება, რომ ფუნქცია.
შეგიძლიათ გააკეთოთ, რომ Node.js, მაგრამ თქვენ, როგორც წესი,
მოვუწოდებთ ცალსახად სინქრონული ვერსიის ფუნქციები, როგორიცაა,
მე ვფიქრობ, რომ წაიკითხოთ sync ფაილი ან sync წაკითხვის ფაილი.
დამავიწყდა, როგორ დაასახელა ის.
და რომ მისცემს თქვენ დაბრუნების ღირებულება.
მაგრამ თუ ეს ფაილი არის ზოგიერთი დისტანციური ფაილური სისტემა
ან დისკზე არის უბრალოდ ბუნებრივად ნელი, ეს შეიძლება მიიღოს 10 მილიწამებში
ან 2 წამი, რომ ფაილი რეალურად დავბრუნდებით.
ამასობაში, სხვა ვებ სია, რომელიც ემსახურებოდა
თქვენი websit.
თქვენ ბლოკავს.
ეს არის ის, რასაც დაბლოკვის IO, input / output.
ასე რომ, აქ, ეს არის ბევრად უფრო ჭკვიანია.
რადგან ის, რაც Node.js აპირებს
გავაკეთოთ საფუძველზე წერით ასეთია,
ის აპირებს დარეკეთ წაკითხული ფაილის მეთოდი,
ცდილობენ ერთი გოლი ფაილი, რომელიც მივიღე გზა განსაზღვრული ღირებულება P.
და მაშინ, თუ და როდესაც ის მზად გადმოგცეთ უკან შინაარსი
ფაილი P, ეს იქნება მოვუწოდებთ ფუნქცია, რომლის ხელმოწერის
კონვენციის შემდეგ.
ორი არგუმენტები, პირველი რომელიც შესაძლოა შეცდომა ობიექტი,
დედაქალაქის E, ეს ობიექტი ე.წ. შეცდომა ან Null
თუ არსებობს ასეთი შეცდომა.
და მეორე არგუმენტი - მიიღოს guess - იქნება თუ რა?
ეს მოუწოდა მონაცემები აშკარად მაგრამ რა არის მონაცემები უფრო კონკრეტულად?
>> შინაარსი?
>> შინაარსი hello.txt მაგალითად მე გამოყვანილია
up ჩემი ბრაუზერის მომენტში წინ.
ასე რომ, სხვა სიტყვებით წაკითხვის ფაილი და მრავალი Node.js ფუნქციები
მოსწონს არ დაბრუნდნენ ღირებულებებს.
ისინი მოუწოდებენ callbacks და გაიაროს
იმ callbacks რა მოხდება უკვე ტრადიციულად
დაბრუნების ღირებულება.
Upside ამ მიდგომის
რომ თქვენ შეიძლება მოვუწოდებთ წაკითხვის ფაილის T0.
გადმორეკე ფუნქცია სიძლიერეზე არ ეწოდოს ერთი tick შემდეგ
ასე ვთქვათ at T, ეს შეიძლება ეწოდოს T1000,
ათასი ტკიპები შემდეგ.
მაგრამ საქმე ის არის, რომ დანარჩენი კოდი ამ ფაილის
თუ რომელიმე მაშინვე შესრულდება, ხოლო Node.js
ხოლო ფაილური სისტემა გათვლით, თუ როგორ უნდა წაიკითხოთ
რომ ფაილი და მიიღეთ უკან თქვენ.
ასე, რომ თქვენ შექმნათ ამ -
იმდენად ეფექტურად ილუზია
პარალელიზმის ხოლო გაქირავების ნელი გაშვებული პროცესების არ არის
დაბლოკოს მნიშვნელოვანი პერსონალის, ნაწილი, რომელიც მომსახურე მომხმარებლებს.
ასე რომ, როგორ უნდა გაუმკლავდეს ეს?
ეს არის ძალიან გავრცელებული Node.js პარადიგმა.
და იქ გზა მხოლოდ გამარტივება ეს ჩვენ დავინახავთ, სანამ ერთად.
მე პირველად შეამოწმა, თუ შეცდომა არ არის null.
ასე რომ, თუ ეს არ არის ყალბი შემდეგ იყო შეცდომა.
მე არ ვიცი რა არის, შესაძლოა ფაილი არ არსებობს.
არ მქონდა უფლებები.
Pathname არასწორია.
ნებისმიერი რაოდენობის რამ შეიძლება წავიდეთ არასწორი.
ახლა, მე ვაპირებ თვითნებურად დაბრუნების 500
რომელიც შიდა შეცდომა სერვერზე.
რაღაც წავიდა არასწორი.
მე ნამდვილად არ აღელვებს დიაგნოსტიკა იგი.
ასე რომ, მოდით უბრალოდ ვუთხრა მომხმარებლის ის გატეხილი.
და შემდეგ, მე ვაპირებ გავაკეთოთ res.end,
და ეს არის სტენოგრამის ნოტაცია.
შეგახსენებთ, რომ გასულ დროს მე res.write
და მაშინ მე res.end.
თუ თქვენ მხოლოდ მინდა გაუგზავნე ერთი ხაზი გამომავალი,
თქვენ შეგიძლიათ ამის გაკეთება ერთდროულად ერთად res.end ერთად არგუმენტი,
და რომ აპირებს გამოაგზავნოს რაც შეცდომა არის
შიგნით ამ ობიექტი ბრაუზერში.
ეს იყო საკმაოდ arcing გავიხსენოთ მომენტში წინ.
მე არ ვიცი რა ამ ნიშნავდა ერთი შეხედვით.
მაგრამ როდესაც მოვითხოვე ფაილი, რომელიც არ არსებობს -
oops, ჩვენ უნდა აწარმოებს სერვერის ერთხელ.
როდესაც მოვითხოვე ფაილი რომ არ არსებობდა, EISDIR,
ასე რომ, რაღაც შესახებ იგი დირექტორია,
, თუ შემთხვევითი string იქ,
როგორც ჩანს, ეს ნიშნავს, რომ ფაილი კი არ არსებობს.
და ეს იმიტომ, რომ ჩემი კოდი უბრალოდ ვამბობ, რომ წერენ
out რაც Raw შეცდომა ის არის,
ასე რომ, არ არის ძალიან მოსახერხებელი მაგრამ მაინც მე გატარება.
სხვაგან, თუ ეს არ იყო შეცდომა რა ვარ მე აკეთებს?
იგივე, რაც ადრე შამფურზე out 200 OK, ბარის -
text / plain გონება ტიპის და შემდეგ შამფურზე მონაცემები.
და ამიტომაც მე მიღების შინაარსი hello.txt რომელიც მხოლოდ
იმის დასადასტურებლად, თუ მე ვუყურებ at hello.txt,
ეს სიტყვასიტყვით უბრალოდ hello, სამყაროში.
და თუ შეიცვალა ამ hello, სამყაროში, ფაილის შენახვა,
გამეორება სერვერზე, განაახლეთ გვერდი.
ახლა, მე მიიღოს, რომ მობილური.
ასე რომ, მე მართლაც მხოლოდ reimplemented სერვერზე
როგორც არსებობდა მრავალი წლის განმავლობაში, მაგრამ გამოყენებით node.js.
მაგრამ ჩვენ შეგვიძლია გავაკეთოთ ეს კიდევ უფრო cleanly.
ნება მომეცით გახსენით async-1.js.
ახლა შეამჩნია, მე დასძინა, მეორე მოდულის ამ დროს,
როგორც ჩანს, გზა მოდული.
ახლა, ეს არის კარგი შესაძლებლობა შევხედოთ
რა დოკუმენტაცია ჰგავს.
Node.js არის დოკუმენტაცია.
როგორიცაა PHP, ვფიქრობ, რეალურად საკმაოდ კარგი
და სწორი ნაბიჯია.
თუ მივდივარ Node.js და Google და მოძებნოთ Node.js გზა,
რა დაინახავთ, როგორც წესი, პირდაპირი ბმული URL
რომ დააყენა აქ მომენტში წინ.
ასე / api ოფიციალური ადგილზე წავიდეთ დოკუმენტაცია.
და რა თქვენ ნახავთ ზედა
კვანძის ოფიციალური დოკუმენტაცია არის ყველა მეთოდები და
ან თვისებები შიგნით ამ კონკრეტულ მოდული,
ერთი რომელსაც შეუერთდება.
და შეუერთდება არის დამხმარე ფუნქცია რომ აპირებს ნება მომეცით
არ გადაიტვირთოთ ყველა pluses.
და მას აქვს დამატებული ბონუს როგორც თქვენ ნახავთ
ნავსადგომებსა არის ასევე ნორმალიზებას შედეგად გზას.
ასე რომ, თუ მომხმარებელს ან თქვენ გაქვთ dots ან dot წერტილების ან ნებისმიერი კომბინაციის
იმ სახის ნათესავი ბილიკები, მათ შორის upsides
საქართველოს შეუერთდა საშუალებას ის არის, რომ ის აპირებს გაწმენდა ყველა რომ
და მოგცემთ კანონიკური გზა გარეშე
იმ წერტილების ან dot წერტილი.
ასე რომ, ეს არის კარგი რამ ზოგადი უსაფრთხოების მინიმუმ
თუ თქვენ შემოწმების დაბრუნების ღირებულება, რომელიც მე არ ვარ
ამ კონკრეტულ მარტივი საქმე.
მაგრამ მე მინდა, რომ გამოიყენოს იგი.
ასე რომ, მე შექმნათ გზა უფრო პროგრამულად
ერთად path.join ნაცვლად ნედლეულის გაერთიანების.
ასე რომ, ცოტა სუფთა, ვიდრე ადრე.
და ახლა შეამჩნია მე მიმდინარეობს ცოტა უფრო ინტელექტუალური, საკმაოდ
ვიდრე უბრალოდ ბრმად ცდილობენ წაიკითხონ ფაილი,
მე ვაპირებ რეალურად დარეკეთ fs.stat.
ასე რომ, თუ თქვენ იცნობს
დაბალი დონის C ფუნქციები და C, მაშინაც კი, PHP.
ბევრი ბიბლიოთეკები აქვს ამ ფუნქციის stat ბრუნდება
არსებითად სტატისტიკა ფაილის, ფაილის ზომა,
ნებართვების, სახელი და რამ, როგორიცაა, რომ
ასევე მინიშნებით თუ ფაილი არსებობს თუ არა,
და თუ ის ფაილი ან დირექტორია
ან სიმბოლური ბმული ან რაღაც.
ასე რომ, ახლა შეამჩნია, მე ვარ მოუწოდებდა fs.stat.
და შემდეგ, როგორც ჩანს მიხედვით დოკუმენტაცია,
მე უნდა დავუბრუნდეთ შეცდომა ობიექტი
ან Null მოჰყვა მიერ stats ობიექტი.
მაგრამ მოდით შევამოწმოთ ეს, node.js.fs.
აქ არის ფაილი სისტემის დოკუმენტაცია.
ნება მომეცით ვეძებოთ სტატისტიკა.
არსებობს გაცილებით მეტი ფუნქციები აქ.
Oops, რომ stat sync, fs.stat.
ასე რომ, აქ, ეს არის ასინქრონული სტატისტიკა (2).
რომ რაც იმას ნიშნავს, რომ, თუ თქვენ გახსოვდეთ, მთავარი გვერდი,
თავი 2 მთავარი გვერდი,
ეს ნიშნავს, რომ ეს არის ფაქტიურად უბრალოდ node განხორციელება
დაბალი დონის სისტემის ფუნქციას stat.
ასე რომ, უკუგამოძახება იღებს ორი არგუმენტები, შეცდომა და stat
სადაც stat არის fs.stats წინააღმდეგი.
მოდით ვნახოთ რა ეს ობიექტი უნდა გამოიყურებოდეს.
მოდით დააწკაპუნეთ ჰიპერბმულის და მე ვერ ვხედავ, რომ.
სტატისტიკა ობიექტი შეიცავს როგორც ჩანს, რამდენიმე დამხმარე საშუალებას,
არის ფაილი, არის დირექტორია, არის bunch სხვა რამ.
ეს "არის" ფაილი, რომელიც მე მაინტერესებს შესახებ ამ კონკრეტულ შემთხვევაში.
ასე რომ აქ მე.
იყო თუ არა შეცდომა, მაშინ ნება მომეცით მხოლოდ გირაოს ამ დროს
და ვივარაუდოთ.
თუ არსებობს შეცდომა, ეს იყო ალბათ 404 ფაილი ვერ მოიძებნა.
ეს შეიძლება იყოს რაღაც
მაგრამ მე, როგორც პატარა lazy აქ მხოლოდ ფოკუსირება
უფრო საინტერესო დეტალები.
მაგრამ მომხმარებლის ანკეტის მიზნებისათვის, ფაილის არ არის ნაპოვნი,
იყო თუ არა რაიმე შეცდომა ჩამოვაყალიბე ფაილი.
წინააღმდეგ შემთხვევაში, ნება მომეცით შეამოწმოთ, თუ ფაილის მართლაც ფაქტობრივი ფაილი.
ასე რომ, თუ ეს არ არის ფაილი, ის არსებობს.
არსებობს რაღაც, მაგრამ ალბათ დირექტორია
ან იქნებ სიმბოლური ბმული
ან რაღაც, რომ ხმაურიანი on ფაილური სისტემა.
ასეა თუ ისე, შესახებ არ უნდა დანახვა.
ახლა, მე უბრალოდ აპირებს შამფურზე
out პირობითად არასანქცირებული 403.
თუმცა ისევ და ისევ მხოლოდ კონვენციის,
მე არ გამოიყენება რაღაც თეორია.
და მერე ბოლოს, ნება მომეცით ცდილობენ წაიკითხონ ფაილი.
ასე რომ, ნება მომეცით გადახვევა down.
და ახლა შეამჩნია ეს არის სადაც კოდი შეგიძლიათ მიიღოთ პატარა ბინძურ,
შეამჩნია, რომ მე მოუწოდებდა fs.readFile გავლის
იგივე გზა, იგივე გადმორეკე, როგორც ბოლო დროს,
ასე რომ წინა ვერსია.
და მაშინ თუ მინდა იპოვოს -
თუ არ ის, I შამფურზე 500.
და თუ მე არ იპოვოს ის, რაც ონლაინ მივდივართ აქ?
ჩვენ ვაპირებთ, რომ ნახოთ fs წერენ header 200 ალბათ
და res.end გაგზავნის ფაქტობრივი მონაცემები.
მაგრამ შეამჩნია ეს.
და ეს არ არის საჩვენებელ ყველაზე უარესი სცენარით.
მაგრამ მე ამ stat დარეკეთ აქ, ვიდრე მე მაქვს რაღაცები.
ამის შემდეგ, მე მაქვს სულ სხვა ასინქრონული ზარი აქ,
ასე უფრო წანაცვლება.
ასე რომ, მხოლოდ სახის განზოგადების თუ შეიძლება აქ.
რა პრობლემა იჩენს წარმოიშვას ენა, როგორიცაა JavaScript
ამ გარემოში, სადაც თქვენ არ გაქვთ დაბრუნების ღირებულებებს
არამედ თქვენ გაქვთ ამ callbacks.
და რა თქმა უნდა, ეს მხოლოდ სტილისტური რამ ფაქტი
რომ მე შენარჩუნება indenting.
მაგრამ ეს ლოგიკური მომდევნო ნაბიჯი.
დავუშვათ, რომ იქ ერთი ან ორი ან სამი სხვა ფუნქციები
რომ საჭიროა შეასრულოს, რომ იყო ბუნებით ასინქრონული,
და ამიტომ თქვენ უბრალოდ სახის შენარჩუნება indenting გაუმკლავდეს მათ,
გაუმკლავდეს მათ, გაუმკლავდეს მათ.
თქვენ მიიღებთ სახის უკუგამოძახება ჯოჯოხეთი როგორც ადამიანი ეძახით
სადაც თქვენი კოდი იწყებს მისაღებად ძალიან ფართო
და გულწრფელად ნამდვილად მძიმე წასაკითხი.
როგორც არის, შემიძლია სახის ძლივს გეტყვით, რომ ეს არის ერთგვარი ნაკადი
რომელსაც აქვს ამ სახის
საქართველოს სტილისტურად დახრილი რამ ხდება აქ.
ასე რომ, ეს არ არის იდეალური, რადგან ეს შეიძლება ძალიან სწრაფად გახდეს
unwieldy, მიუხედავად იმისა, რომ ორი ასინქრონული მოუწოდებს არ
ასეთი დიდი გარიგება.
ასე რომ, ჩვენ შეიძლება თავიდან ავიცილოთ ეს, არა?
თქვენ შეიძლება არ glimpsed რომ I misclicked მომენტში წინ.
დოკუმენტაცია, თქვენ იცით, ეს ჰგავს არსებობს statSync.
და statSync არ მიიღებს გადმორეკე როგორც არგუმენტი.
იგი იღებს მხოლოდ გზას, რადგან ეს აშკარად არ რა?
ის დააბრუნებს მაგალითად საქართველოს fs.stats.
ასე რომ, ეს შეიძლება იყოს თქვენი პირველი ინსტიქტი, არა?
მით უმეტეს, თუ გადმორეკე ფუნქციები
და asynchronicity არის ცოტა ახალი თქვენ, სიმართლე გითხრათ,
მარტივი მიდგომა, ალბათ, უბრალოდ თავიდან ავიცილოთ პრობლემა ყველა
ერთად დაბრუნდეს დასალაგებლად საქართველოს CS101 პროგრამირების სტილი
სადაც რეკავთ ფუნქცია ან საშუალებას ბრუნდება ღირებულება,
დარეკეთ ფუნქცია, ბრუნდება ღირებულება,
ფუნქცია, ბრუნდება ღირებულება.
და მე ვერ გამოიყენებს, ამიტომ fs.statSync
რომელიც ფაქტიურად იგივე მაგრამ სინქრონული მობილური
რაც იმას ნიშნავს, ის დააბრუნებს ღირებულება.
იგი არ გაივლის მნიშვნელობა გადმორეკე.
მაგრამ რატომ უნდა, რომ ალბათ suboptimal Workaround მიმართო
ერთდროული ფუნქციები?
ჰო?
[Inaudible შენიშვნა]
სწორედ ეს ხდება დიდი ხნის განმავლობაში.
თქვენ მხოლოდ slowing ყველაფერი ქვევით.
იმის გამო, რომ ჰგავს Shake Shack ან Tasty Burger, თუ მათ მოიშორეს
იმ buzzers და ის თქვენ, მომხმარებელს დგანან წინა
ხაზი, სანამ თქვენი საკვები მზად არის ადრე კი აღების მიზნით
პირი უკან თქვენ აშკარად
მეშვეობით დააყენა ანელებს.
ხალხი დაიწყებს ტოვებს, თქვენ სახის მიაპყროს პაკეტი.
შეგიძლიათ ნებისმიერი რაოდენობის ანალოგები აქ.
მაგრამ მოკლედ, ეს ალბათ არ არის კარგი რამ
ბიზნეს ან სერვერზე.
ასე რომ, ასინქრონული კოდი არის როგორც წესი, კარგი მაინც
ამ შემთხვევაში, მაგრამ ეს ნამდვილად იწყება გამოიწვიოს ზოგიერთი Angst.
და რეალურად მე ვერ გაბედავს ამბობენ, როდესაც პირველი წერა ამ პერსონალის,
ეს კიდე ცოტა ცოტა შეგუება.
ასე რომ, მოდით დავიწყოთ აღჭურვა თქვენ გარკვეული ბიბლიოთეკების
და ტექნიკის, რათა ამ პატარა ადვილია.
ასე რომ, ერთი ყველაზე გავრცელებული ბიბლიოთეკების პოპულარული ბიბლიოთეკები
ამ დღეებში, ამ რომელსაც async.js.
და როგორც ბევრი Node.js ბიბლიოთეკების ან მოდულები,
ეს არის ყველა ღია წყაროებიდან.
ისინი თითქმის ყველა ცხოვრობს და მიიღეთ კერა საცავებში რომელიც სახის
of გახდეს დე ფაქტო ადგილი შესანახად ეს ყველაფერი.
და შემდეგ იქ მთელი ინფრასტრუქტურა
დაყენების ეს ყველაფერი ე.წ. NPM, Node პაკეტი მენეჯერი
რომელიც, თუ თქვენ იცნობს ერთად EvanTube არის ერთგვარი
მსგავსი app ან app მისაღებად.
თუ თქვენ იცნობს ერთად Red Hat და Fedora
როგორც მოწყობილობების, ეს მოსწონს yum.
მაგრამ კვანძის - ის პაკეტი მენეჯერი მხოლოდ
ამ კონკრეტულ გარემოში.
ასე რომ, ჩვენ შეგიძლიათ ჩამოტვირთოთ და დააყენოთ რამ, როგორიცაა async ბიბლიოთეკა
და ასევე კიდევ ერთი მოუწოდა ხაზგასმით ბიბლიოთეკის ან მოდული.
მაგრამ ეს რამდენადაც fs, HTTP, გზა,
ეს არის ყველა მოდის აგებული კვანძში.
ასე რომ, თუ ჩვენ წასვლა API Docs, თქვენ რეალურად ვხედავთ, რომ აშენდა
თარგმნეს კვანძის თქვენ მიიღებთ უფასოდ მთელი bunch of მოდულები.
მაგრამ უამრავი ლამაზი ადამიანი ინტერნეტ გააკეთა ათობით
თუ არა, ასობით სხვა ბიბლიოთეკების
რამ უკეთესი ან სხვაგვარად.
ასე რომ, მოდით შევხედოთ როგორ ამ ბიბლიოთეკაში მუშაობს.
ასე რომ, ყველაზე მეტად ეს კოდი არის იდენტური მომენტში.
მაქვს გეზი მიმდინარეობს განთავსებულია up დაბრუნება.
და ახლა მე მოუწოდებდა async.series.
ასე რომ async ბიბლიოთეკა, ის უბრალოდ ბიბლიოთეკა, რომელიც საშუალებას გაძლევთ
გაივლის ან ამაღლება, როგორც წესი, საქართველოს ფუნქციები უნდა ეწოდოს ერთი
შემდეგ სხვა მხოლოდ სახის თავიდან ასაცილებლად, რომ წანაცვლება საკითხი,
და მართლაც მხოლოდ გონებრივი angst რომ იქნება უცვლელად წარმოიშვას
მინიმუმ, როდესაც თქვენ პირველი ჩაყვინთვის to this საკუთარ
პროგრამირების asynchronously.
როგორც განზე, თუ არ იქნა მიღებული 161 და თქვენ შესძლეს საკეტები
და დააყენებს პირობები და ყველა რომ, ასინქრონული კოდი
და გარემოს მსგავსად Node.js რეალურად ბევრი,
ბევრად უფრო მარტივია, სავარაუდოდ,
ვიდრე რეალურად წერა multithreaded კოდი.
ნებისმიერ დროს თქვენ უნდა multithreaded კოდი
თქვენ გაქვთ რეიზი პირობები.
თქვენ უნდა აღელვებს ორი თემა შეიცავს
იგივე რესურსები დისკზე ან მეხსიერებაში.
სილამაზის JavaScript
in Node.js არის იქ ფაქტიურად მხოლოდ ერთი თემა,
რაც იმას ნიშნავს, ბრაუზერის
ან სერვერზე შეიძლება მხოლოდ ერთი რამ ერთდროულად.
უბრალოდ თქვენ, პროგრამისტი
შენარჩუნება ფსიქიკური მოდელი თუ როგორ სახის მდგომ რამ
და გაერკვნენ, თუ როგორ შეკვეთა თქვენს კოდი.
მაგრამ თქვენ არასოდეს არ ინერვიულოთ შესახებ დააყენებს პირობები
საკმაოდ იგივე გზა მაინც Raw კოდი მოსწონს ეს.
ასე რომ, ეს ცოტა ძნელი grack აქ.
მაგრამ - ნება მომეცით გახსნა დოკუმენტაცია რაღაც მომენტში.
Async.js ბიბლიოთეკა, რომელიც ასევე ძალიან googleable,
ის ცხოვრობს GitHub ანგარიში, როგორც ბევრი მათგანი.
არ ვფიქრობ, რომ ეს sketchy, ეს არ არის.
ნება მომეცით გადახვევა ქვემოთ რომ წაკითხული Me აქ.
ასე რომ, async ბიბლიოთეკა უზრუნველყოფს მთელი bunch
მეთოდების შიგნით მას.
მაგალითად, არსებობს მეთოდი ეწოდება ყოველი,
რომელიც, თუ მე დაწკაპეთ ეს მხოლოდ ვხედავთ მის Docs ერთი წუთით,
ეს არის ფუნქცია ან მეთოდი რომელიც საშუალებას გაძლევთ, რომ რამე
ისევე როგორც ოთხი თითოეული მაგრამ პარალელურად.
ისინი ყველა უნდა მოხდეს პოტენციურად პარალელურად.
და მეთოდი, თითოეული მხოლოდ დაბრუნებას აპირებს, როდესაც ყველა
საქართველოს iterations არის სრული.
იქნებ ისინი მოხდეს ერთ შემდეგ სხვა.
იდეალურ შემთხვევაში, მოხდება არსებითად პარალელურად.
მაგრამ საშუალებას არ დაგიკავშირდებათ.
ეს არ ხმაურს თქვენი buzzer მანამ, სანამ ყველა
ელემენტები თქვენ გაქვთ iterated მეტი დაასრულეს.
ასე რომ, ეს მხოლოდ ლამაზი გზა
თავიდან ასაცილებლად გამოყენებით მარტივი ოთხი loop
მაგრამ რეალურად აკეთებს რაღაც asynchronously.
მაგრამ ახლა უფრო პირდაპირ დაკავშირებული ამ მაგალითად,
შეამჩნევთ არსებობს ამ სერია მეთოდი.
და ნება მომეცით უბრალოდ დახევის up მარტივი კანონიკური მაგალითი.
ასე რომ async ბიბლიოთეკების, სერია მეთოდი, როგორც გულისხმობდა
მიერ კვადრატულ ფრჩხილებში მასივი.
რა არის მონაცემები სახის ელემენტები
ამ მასივი საფუძველზე მარტივი მაგალითი?
ეს არის მასივი ფუნქციები.
ასე რომ, C, თქვენ მოვუწოდებთ მათ ფუნქციონირებას პოინტერები.
ამ JavaScript, არსებობს უფრო მეტი სწორად მითითება ფუნქციები
ან ანონიმური ფუნქციები.
და ეს მხოლოდ იმას ნიშნავს, კოლექტორები
რა თქმა უნდა უბრძანა ნულიდან on up.
ასე რომ, მათ სასარგებლოდ ბრძანება, რომელიც არის კარგი
სერია "მიზეზი სერია რა თქმა უნდა, საშუალება რაღაც
იმისათვის, რომ არ პარალელურად.
ასე რომ, ეს მხოლოდ იმას ნიშნავს, რომ ეს ფუნქცია მიიღებს შესრულებული,
მაშინ ეს ერთი, მაშინ ეს ერთი, ეს ერთი, მაშინ ეს ერთი,
თუმცა ბევრი არსებობს
სანამ საბოლოოდ სურვილისამებრ გადმორეკე ეწოდება.
ასე რომ, შეამჩნია პარადიგმა აქ.
და მიუხედავად იმისა, რომ ამ არის ერთი ბიჭი ბიბლიოთეკა,
ის წარმომადგენელმა ძალიან გავრცელებული JavaScript პარადიგმა
საქართველოს კვლავ გამოყენებით callbacks.
ასე რომ, შეამჩნევთ, თუ რას აკეთებთ აქ.
პირველი ფუნქცია, რომ გავიდა მეშვეობით მასივი,
თქვენ განსაზღვრული ანონიმური ფუნქცია მხოლოდ ფუნქცია.
მაგრამ ცნობა, რომ, როგორც ჩანს, შესაბამისად, ამ დოკუმენტაციის
რომ ანონიმური ფუნქცია უნდა მიიღოს არგუმენტი გადმორეკე.
რომ იქნება მომცეთ ან მინიშნება ფუნქცია
რომ თქვენ უნდა მოვუწოდებთ, როდესაც თქვენი კოდი მზად არის დაბრუნდეს ღირებულება.
ასე რომ კიდევ ერთხელ, განსხვავებით მხოლოდ როგორც წესი, საპროცესო პროგრამირება
სადაც თქვენ გამოყენებული დაბრუნების ღირებულებებს მაშინვე
რომ ერთი სხვაობა გამოყენებით ბიბლიოთეკა მოსწონს ეს
in ასინქრონული პროგრამირების მეტი ზოგადად, როდესაც თქვენ მზად ხართ
დაბრუნების მნიშვნელობა მონაცემთა ბაზა, ფაილი,
საწყისი არითმეტიკული გამოხატვის, ეს თქვენზეა
მოვუწოდებთ გადმორეკე ფუნქცია.
და ლამაზი რამ ამ ბიბლიოთეკაში
თუ ჩვენ წაიკითხა დოკუმენტაცია მეტი ყურადღებით არის, რომ,
თუ და მხოლოდ თუ ყველა callbacks ფართობი მოუწოდა
გარეშე შეცდომა ობიექტი, იქნება მთელი რამ წარმატების მისაღწევად?
ასე რომ, სხვა სიტყვებით, თუ არსებობს 2,
თუ არსებობს 10 ანონიმური ფუნქციები
ამ მასივი ამიტომ ამ სერია,
მხოლოდ იმ შემთხვევაში თუ ყველა მათგანი წარმატებული,
იქნება საბოლოო სურვილისამებრ უკუგამოძახება შეიძლება ჩაითვალოს?
თუ ვინმე მათგანი ვერ, ყველა ფუნქცია
მას შემდეგ, რაც არ კი შესრულდება.
ასე რომ, ეს ლამაზი გზა ერთგვარი მქონე daisy ჯაჭვის
რომ შეწყვეტილია ნაადრევად თუ რაღაც მიდის არასწორი.
ასე ვხედავ ამ კონტექსტში, აქ არის თუ როგორ შეიძლება ხელახლა განახორციელოს
რომ წინა პროგრამა.
მე გზა, როგორც ადრე, ასე რომ ეს არის ადვილი ნაწილი.
მე გადაწერეთ ჩასვით ეს ჩონჩხის კოდი
საწყისი დოკუმენტაცია არსებობს async.series ღია ფრჩხილებში,
გახსნა კვადრატული ფრჩხილი.
და ახლა შეამჩნია მაქვს ერთი ფუნქცია ამ დასაწყისში
მეორე, ჩვენ დავინახავთ სადაც ჩვენ მივდივართ ამ.
და ახლა შეამჩნია, რომ ის ცოტა რთული, პირველ რიგში,
მაგრამ ფოკუსირება მხოლოდ ეს ხაზს.
Fs.stat ნიშნავს მიიღოს სტატისტიკა ან რა არა, რომ გზა.
მოვუწოდებთ ამ გადმორეკე როცა მზად.
ეს კოდი არის იგივე როგორც ადრე.
თუ არსებობს შეცდომა, არსებობს ერთი განსხვავება არის.
კიდევ ერთხელ, ძალიან საერთო პარადიგმის in Node.js პროგრამირების არის
თუ რამე მიდის არასწორი და უკუგამოძახება უნდა იცოდეს,
რომ კონვენციის პირველი არგუმენტი გადმორეკე აპირებს
უნდა იყოს, თუ ყველა კარგად არის ან მინიშნება შეცდომა ობიექტი,
კაპიტალის E. ეს იგივეა შეცდომა კლასი, რომელიც არსებობს მსოფლიოში
მაგრამ უფრო, რომ სხვა დროს.
ასე რომ, ამით, თუ არსებობს შეცდომა, რა გავლენა?
კარგად საფუძველზე, რაც მე განაცხადა, რომ სერია აკეთებს,
არის თუ რამე მიდის არასწორია, ჩვენ უბრალოდ სახის მინდა
შეწყვეტა მთელი რიგი ანონიმური ფუნქცია მოუწოდებს.
ასე რომ, ეს საკმარისია ჩემთვის უბრალოდ დააბრუნოს გადმორეკე გავლის
შეცდომის ობიექტი.
რადგან თუ stat მისცა ჩემს უკან შეცდომა,
მე ვერ შექმნა ახალი შეცდომა ობიექტი საკუთარი,
მაგრამ მე ნამდვილად არ მაინტერესებს,
მინდა გავლა რასაც შეცდომა ის არის, რომ რეალურად მოხდეს
ასე, რომ შეიძლება მსგავ ამ გადმორეკე.
და უბრალოდ უნდა იყოს მკაფიო, დაბრუნება არ არის მკაცრად აუცილებელია.
მე არსებითად გსურთ ამის გაკეთება მაგრამ მინდოდა ახლა ამის გაკეთება "დაბრუნდება;
/ / ისე, რომ აღარ კოდი აქ ახორციელებს ".
ასე რომ კიდევ ერთხელ კიდევ ერთი საერთო კონგრესზე JavaScript,
მიუხედავად იმისა, რომ თქვენ არ დაბრუნების ღირებულება თავისთავად,
გსურთ გაივლის ღირებულება რომ გადმორეკე ფუნქცია
მაგრამ მაშინ თქვენ გსურთ შეწყვიტოს აღსრულება
ფუნქცია თქვენ in, ტრივიალური გზა
ამის გაკეთება მხოლოდ მოვუწოდებთ დაბრუნდება აქ.
მაგრამ არაფერი არასწორი,
ჩვენ უბრალოდ აკეთებს დაბრუნების უკუგამოძახება შეცდომა მიუხედავად იმისა, რომ ის აპირებს
დაბრუნება undefined ღირებულება.
ყველა უფლება, ეს არ დაბრუნების ღირებულება სავარაუდოდ.
ყველა მე აინტერესებს არის ინტერნატის შემდგომი აღსრულება.
ასე რომ, ჩემი conflation ამ ორი ხაზი მხოლოდ სტილისტი
კონვენციის უბრალოდ აქვს ნომერი ონლაინ
კოდი უბრალოდ დაწერა 2 დან 1.
ასე რომ, რა?
იმ შემთხვევაში, თუ იქ არ არის შეცდომა -
რეალურად უნდა იყოს ნათელი მე შეიძლება თავიდან ავიცილოთ
რომ აკეთებს, თუ სხვაგან.
თუმცა ისევ და ისევ, სხვა საერთო პარადიგმის არის გამშვები
თქვენი შეცდომები up დაბრუნება და შემდეგ უბრალოდ დააბრუნოს ვიდრე გააგრძელოს
to აბზაცის თქვენი კოდი და elses და elses და elses.
ასე რომ, თუ ეს არ არის ფაილი, ახლა თქვენ იცით,
მე მინდა, რომ გაუმკლავდეს ამ პატარა სპეციალურად.
ასე რომ, აქ როგორც Java ან C + + ან რამდენიმე სხვა ენებზე,
აქ არის თუ როგორ შეიძლება instantiate წინააღმდეგი აკრიფოთ შეცდომა გავლის
in a ნაგულისხმევი გაგზავნა არა ფაილი
და ეს მხოლოდ გარკვეულწილად თვითნებური.
მაგრამ მე სასიგნალო შეცდომა ჩემი საკუთარი.
და რა ამ ბოლო ონლაინ სავარაუდოდ ნიშნავდეს?
ყველა კარგად არის.
თუ გაივლის null შეეხება შეცდომა პარამეტრი, რომელიც უბრალოდ ნიშნავს
კონვენციის ყველა კარგად არის.
ასე რომ, ეს ნიშნავს, რომ ის, რაც მოხდება ლოგიკურად?
თუ null გავიდა რომ უკუგამოძახება
ეს ნიშნავს, რომ ამ ანონიმურ ფუნქციის წარმატებით
ასე ვთქვათ.
ასე რომ, რა უნდა სერია საშუალებას უსწრებს და ახლა ჩვენგან საფუძველზე
ჩემი სიტყვიერი განმარტება ადრე?
[Inaudible შენიშვნა]
გადაადგილება, რათა მომდევნო ერთი, არა?
თუ იგი დაბრუნდა არასამთავრობო null ღირებულება, ეს იქნებოდა მხოლოდ შეწყვეტა
და არა ანონიმური ფუნქცია დაიჭერს მოუწოდა.
არამედ იმიტომ, რომ მას არ აქვს, მაშინ ამ მიიღებს მოუწოდა მომავალი.
ასე რომ, ლოგიკა აქ არის საკმაოდ ბევრი იგივე, როგორც ადრე
და ვნახავთ, როგორ გაწმენდა ეს ყველაფერი კიდევ ერთი მომენტი.
ვხვდები, ეს არის სახის ბევრი
აღიქვას ყველა სიტყვიერ და ვიზუალურად.
მაგრამ ახლა შეამჩნია, მეორე ანონიმური ფუნქცია რომ მინდა
შეასრულოს სერია არის ცდილობენ წაიკითხონ ფაილი.
მოვუწოდებთ ამ უკუგამოძახება როდესაც თქვენ მზად.
თუ არსებობს შეცდომა, უბრალოდ, სიგნალი ის გზა უკუგამოძახება
ასე რომ დანარჩენი ამ პერსონალის შეწყვეტილია.
Else დაბრუნების null.
მაგრამ რატომ ვარ მე გავლით ორ არგუმენტები?
ისე ამ დროს, თუ წავიკითხე ფაილი და დავუბრუნდეთ
როგორც ცვლადში მონაცემები,
მინდა არა მხოლოდ ნიშნავდეს ყველა კარგად არის დაბრუნების null
პირველი არგუმენტი.
მინდა დავუბრუნდე ფაქტობრივი მონაცემები, როგორც მეორე არგუმენტი.
რადგან თუ მე წაკითხვის შემდგომ დოკუმენტაცია,
შეამჩნია ეს უკანასკნელი ბლოკი კოდი კვადრატული ფრჩხილი ნიშნავს, რომ ის,
ბოლოს სერია.
იყო მხოლოდ ორი ანონიმური ფუნქციები ამ სერია.
იყო თუ არა შეცდომა, აქ, მაშინ მე ვიცი, რომ ერთი ბმულები
ამ ჯაჭვის ისე, საუბარი ვერ მოხერხდა.
ასე რომ, სხვა სიტყვებით, ეს შეცდომა იქნება შეცდომა ობიექტი
რომ არის null ასეთის არსებობის შემთხვევაში ამ ბიჭებს ვერ მოხერხდა.
და თუ ეს საქმე, მე უბრალოდ აპირებს გირაოს გარეთ და მე ვაპირებ
ამბობენ, რომ 400, რომელიც ნიშნავს თხოვნა ვერ,
რომ ძალიან generic შეცდომა.
და შემდეგ, მე ვაპირებ ამობეჭდოთ შეცდომა.
ასე რომ, მე არ აწუხებდა იყოს სუპერ anal ამ დროს,
მე არ ვაპირებ გარჩევა შორის 500 და 404 და 403,
მე უბრალოდ სახის ბრმად ტალღის ჩემი მხრივ
და ვთქვათ რაღაც წავიდა არასწორი.
მაგრამ თუ არაფერი გააკეთა არასწორი,
მე ვაპირებ გაგზავნას ამ res.end გავლით ამ მონაცემებს.
ახლა ეს გამოიყურება პატარა cryptic.
თუმცა ისევ და ისევ, თუ წავიკითხე დოკუმენტაცია,
მეორე არგუმენტი ამ საბოლოო, ფინალური გადმორეკე,
ბიჭი რომ მხოლოდ შესრულებული ერთხელ სერია კეთდება
შესრულებაში ან ნაწილი არის საქართველოს, ეს იქნება მასივი
ყველა მეორე არგუმენტები
რომ გადაეცა რომ გადმორეკე.
ახლა, თურმე მთარგმნელობითი ბმული ამ სერიის
რომელიც რეალურად დაბრუნებას მეორე არგუმენტი ის არის, რომ ამ ერთი აქ.
ამიტომ მე ვაპირებ დასალაგებლად შესახებ ნახტომი რწმენის უბრალოდ გამოიყენოთ ვარაუდობენ
ამ დროისათვის, რომ ბოლო მეთოდი
რომელიც გაძლევთ ბოლო ელემენტების მასივი.
იმის გამო, რომ ამ მასივი რომ მიმდინარეობს გავიდა
ჩემთვის აქვს ორი ინდექსები, ნულოვანი და ერთი.
უბრალოდ zero არ აქვს მნიშვნელობა იმიტომ, რომ ეს ბიჭი ბრუნდება -
არ გაივლის მეორე არგუმენტი, მაგრამ ეს ბიჭი აკეთებს.
ასე რომ შედეგი bracket ნულოვანი არაფერია,
შედეგები bracket ერთი შეიცავს რა,
თუ თქვენ უკვე შემდეგ ერთად მდე ამ ეტაპზე?
ფაილი, hello, მსოფლიო content სავარაუდოდ,
ასე რომ, თუ მე რეალურად ბეჭდვა ეს.
და ნება მომეცით დასრულდება ერთი დეტალი აქ.
თუ ეს ერთგვარი ძველი სკოლა, თუ მინდა კიდევ
ბოლო ელემენტები, თუ შეიძლება გავაკეთოთ შედეგები [results.length 1]
ეს ერთგვარი ძველი სკოლის გზა
წვდომის ბოლო ელემენტები in - ან ნულოვანი ინდექსი მასივი.
მაგრამ, როგორც მხარეს, გავიხსენოთ რომ მე მქონდა ამ ბიბლიოთეკაში
აქ ხაზს, რომელიც კონვენციის უბრალოდ მოუწოდა
სიტყვასიტყვით ტირეთი ხასიათი, რომელიც არ არის განსაკუთრებული,
უბრალოდ გამოიყურება cool მოსწონს დოლარის ნიშანი აკეთებს jQuery.
ეს არის მხოლოდ დამხმარე მეთოდი ხაზს dot ბოლო
რომ აკეთებს ზუსტად იგივე.
და თუ თქვენ არ გამოიყენება მას ადრე ხაზგასმით JS ორივე
კლიენტის მხარეს კოდირება
და სერვერის მხარეს არის შესანიშნავად სასარგებლო ბიბლიოთეკა
რომ, როგორც ბევრი ადამიანი აღწერილი ის მინდა jQuery შეიცავს ყველა
მეთოდები, ხალხს სურდა მოვიდა JavaScript თავად.
OK.
>> ასე რომ, ისევე როგორც საკმაოდ ჩემთვის და მე თვალს სერია,
თქვენ გაქვთ, როგორიცაა უკუგამოძახება როგორც არგუმენტი?
>> დიახ.
>> Like ასე რომ, როდესაც თქვენ რეალურად მოსწონს ბიძგი რომ,
და მოსწონს რას ნიშნავს, როდესაც თქვენ უბრალოდ უნდა
ისევე როგორც გადმორეკე და მერე მოსწონს -
[Inaudible შენიშვნა]
>> OK, კარგი კითხვაა.
ასე რომ, ნება მომეცით დახევის up async მთავარ გვერდზე აქ
ან დოკუმენტაცია GetHub.
ასე რომ ეს არის კანონიკური სტრუქტურა.
თუ თქვენ დარეკეთ გამოყენებით ამ კერძოდ საშუალებას სერია,
არსებობს ორი დიდი ნაწილების მას.
ერთი არის მასივი ანონიმური ფუნქციები
და ორი საბოლოო უკუგამოძახება ფუნქცია, რომელიც რეალურად
შესრულებული ძალიან ბოლოს სერია.
ახლა, თუ ჩვენ მიუახლოვდით ცოტა უფრო პირველი
იმ დიდი რამ, array ანონიმური ფუნქციები
by მოთხოვნა ამ ბიჭი დოკუმენტაცია
უნდა იყოს ანონიმური ფუნქცია, რომელიც იღებს
ერთი არგუმენტი ეწოდება უკუგამოძახება ან foo ან ბარი, რომ არ აქვს მნიშვნელობა
მაგრამ ის უწოდა გადმორეკე.
და ეს არის ერთგვარი თქვენი buzzer რომ Shake Shack ხელში თქვენ.
ეს არის საშუალება, რომლითაც თქვენ შეგიძლიათ დაბრუნების ღირებულება
მომხმარებელს იმიტომ, რომ თქვენ ვერ უბრალოდ სიტყვასიტყვით დაბრუნდება.
თქვენ უნდა გავაკეთოთ ის მიერ გზა ამ გადმორეკე.
რადგან თუ შიგნით ამ ფუნქციის ზოგიერთი ნელი გაშვებული
კოდი მოსწონს შეკითხვაზე მონაცემთა ბაზა, წავიკითხე ფაილი ფაილური სისტემა,
თქვენ არ მინდა ლოდინი არ არსებობს და დაბლოკოს ყველას,
გსურთ მოვუწოდებთ გადმორეკე.
ასე რომ, ეს არის ფაქტიურად სახელი არგუმენტი.
მაგრამ მინდა C, თქვენ აქვს ფუნქცია პოინტერები.
ჯავის გაქვთ მინიშნება სისტემის მეთოდები
და იგივე აქ JavaScript.
ეს არის ცვლადი, მაგრამ მისი ტიპის ფუნქცია.
ასე უბრალოდ წერილობით მისი სახელი თუ არა გადმორეკე ან foo
ან ბარი, შემდეგ ღია ფრჩხილებში და ახლო ფრჩხილებში,
თქვენ შესრულებაში, რომ რომ ფუნქცია.
და ჩაბარების null რომელიც ნიშნავს null შეცდომა და ერთი
რაც იმას ნიშნავს, რომ ეს არის მონაცემები, რომ გსურთ გაივლის შემოსული
და მაშინ ბლოკი უნდა იყოს მკაფიო, ეს არის კიდევ ერთი გადმორეკე.
და ის არ მოუწოდა გადმორეკე,
ეს მხოლოდ კონცეპტუალურად არის გადმორეკე საშუალებას ფუნქცია
იმიტომ, რომ მას უწოდებენ განმარტება
ამ ავტორის ბიბლიოთეკის როდესაც მთელი სერია დაასრულა
ან subset მისი თუ შეცდომა მოხდა ადრე.
ასე რომ, სახელი გადმორეკე ფუნქცია, მოუწოდებდა გადმორეკე ფუნქცია,
დასახელება გადმორეკე ფუნქცია, მოუწოდებდა გადმორეკე ფუნქცია,
სხვადასხვა უკუგამოძახება ფუნქციონირებს ყველა ერთად.
>> ჩვენ ახლა აქვს, როგორიც განსაზღვრავს გადმორეკე?
>> არა, რადგან ეს ბიჭი გაივლის თქვენს მასივი
ანონიმური ფუნქციები,
მომცეთ კოდი მას სურს შეასრულოს.
კერძოდ, ყველა უფლება.
ასე რომ, გთხოვთ, აცხადებენ, რომ კოდი იღებს პატარა მარტივი.
ასე რომ, მას შეუძლია.
და თუ თქვენ ჩემნაირი, მიიღოს კომფორტი მაინც იცის,
იგი იღებს, ხოლო შეეგუება ამ.
მაგრამ ჩვენ შეგვიძლია გაწმენდა ეს ყველაფერი ცოტა,
არ ჩააგდოს ძალიან ბევრი თქვენ მაგრამ აქ არის კიდევ ერთი ვარიაცია
და მისი გამოყენების სხვა მეთოდი
ამავე ბიბლიოთეკაში ე.წ. ჩანჩქერი.
თავდაყირა, რომელიც განსხვავებით სერია, სადაც თითოეული
იმ ანონიმური ფუნქციების შესრულებული არსებითად
დამოუკიდებლად თითოეული სხვები.
Waterfall, როგორც სახელი ვარაუდობს, საშუალებას uppermost ფუნქციები
სახის კორიდორი ფასეულობები ქვედა ფუნქცია,
სახის მოსწონს კასკადური წყალი.
ასე რომ upside ამ ის არის, რომ მე არ შემიძლია ასეთი
გამოიყენოს ეს ჩემი უპირატესობა.
In async.waterfall, შეამჩნია შემდეგ.
მე შემიძლია მხოლოდ მოვუწოდებთ fs.stat გავლით გზა
რომ მინდა კიდევ სტატისტიკა.
და მერე მახსოვს, სანამ მე ჰქონდა ანონიმური ფუნქცია
რომ ჰქონდა ორი არგუმენტები სცთებით,
esults და შემდეგ დავურეკე გადმორეკე ფუნქცია ხელით?
სხვა სიტყვა არის უბრალოდ უნდა იყოს ნათელია, გავიხსენოთ, რომ ადრე
in async 2, მე ყველა ამ nasty მუშაობა.
დავურეკე fs.stat გავიდა P,
განაცხადა საკუთარი ანონიმური ფუნქცია.
მე შევამოწმე თუ შეცდომა არ null, მაშინ მე ამ,
სხვაგან მე, რომ მთელი სილამაზე შემდეგი კონვენციების
როგორც Node.js არის, რომ უკუგამოძახება ფუნქციების ზოგადად იგულისხმება
მიიღოს მინიმუმ ერთი არგუმენტი, შეცდომა ობიექტი მოჰყვა ნულოვანი
ან უფრო სასარგებლოა ღირებულებებს.
ასე რომ შეამჩნია პარადიგმა აქ,
ამ გადმორეკე ფუნქცია ვარ გამოცხადების შემდეგნაირად ზუსტად
პარადიგმა, რომ ამ ბიჭს async ბიბლიოთეკა აკეთებს.
რომელიც ვთქვა, რატომ ვარ I ახორციელებს საკუთარი უკუგამოძახება
მეთოდი, როდესაც ავტორი ამ ბიბლიოთეკა ფაქტიურად გადაცემის me
on platter ასე ვთქვათ, გადმორეკე ფუნქცია შემიძლია?
ასე რომ, მე შემიძლია მხოლოდ გაივლის მინიშნება ის მომცა
ისე, რომ დაუყოვნებლივ, ჩემი რამდენიმე ხაზები
კოდი გახდა ერთ ერთი ხაზი კოდი.
ახლა, სად მივდივართ ამ?
შემდეგი ფუნქცია, რომ მინდა შეასრულოს,
შემდეგი ანონიმური ფუნქცია ამ მასივი
ფუნქციების აკეთებს შემდეგ.
განაცხადის პირველი stat არის პირველი არგუმენტი.
ასე რომ რაღაც აქვს შეცვლილია უკვე.
ახლა, ეს ბიჭი, რომელიც დაწერა ბიბლიოთეკა -
და მე ვამბობ, ბიჭი რადგან ეს არის ბიჭი.
ეს ბიჭი ვინ დაწერა ეს ბიბლიოთეკა არის დოკუმენტაცია გარანტიები
იმ შემთხვევაში, თუ ამ ფუნქციას აქ გადის ჩემს უკან შეცდომა ობიექტი
ან null მოსდევს კომა გამოყოფილი სიაში სხვა ღირებულებები,
ის იქნება დარწმუნდით, რომ ის, სხვა ღირებულებები გადასცა
ამ ანონიმური ფუნქცია იმისათვის, მარცხნიდან მარჯვნივ.
და რა გამოყენებული იქნება მხოლოდ გადმორეკე ფუნქცია მარტო უბრალოდ
ხდება ბოლო ასეთი არგუმენტი.
ახლა, მე არ ვიცი, ვინ ვარ აქცენტი მხოლოდ თქვენ იცით.
მაგრამ ახლა, რა წართმევას აქ?
ასე რომ, ჩვენ ვიცით დოკუმენტაცია
ან ადრე რამდენიმე მაგალითი
რომ fs.stat საბოლოოდ მოელის გადმორეკე ორი არგუმენტები,
შეცდომა ობიექტი, რომელიც არის შეცდომა ობიექტის ან null მოჰყვა
მითითებით stats ობიექტი.
ასე რომ, თუ ვფიქრობ, რომ შეცდომა ობიექტი კომა stats ობიექტი,
რომელიც შეესაბამება ამ პარადიგმაში ამ პირის ბიბლიოთეკაში.
ასე რომ, შემიძლია უბრალოდ ვთქვა, რადგან მე არ მეორე არგუმენტი
ის, რომ - რომ აპირებს გადაეცემა by fs.stat
რომ გადმორეკე არის err, stats ზოგადად ამ ბიბლიოთეკაში,
შემიძლია დააყენა მეორე არგუმენტი სახელი აქ
ან რასაც შემიძლია გადარქმევა მას
თუ მინდა მოჰყვა მიერ გადმორეკე აქ.
ასე რომ, მე ვერ გაივლის ერთი მნიშვნელობა აქ აქ.
ახლა, ამ კოდექსის თუმცა მართლაც გარკვეულწილად cryptic არის
მინიმუმ ასლი პასტა უმეტესწილად ადრე.
ერთადერთი განსხვავება ის არის ცნობა აქ მე გამოცხადების შეცდომა
წინააღმდეგი და ახლა მინდა მიიღოს პატარა fancier.
მე რეალურად გვინდა ვიცოდეთ შეცდომა იყო, ამიტომ მე ვაპირებ
რომ Tuck შიგნით ეს ობიექტი უძრავი ქონება თვითნებურად მოუწოდა კოდი
ისე, რომ მე ვიცი, რომ ეს არ არის ფაილი
რომ უნდა იყოს არასანქცირებული, ის HTTP 403.
ნება მომეცით გახსოვდეთ, რომ ადრე მე გაივლის შეცდომა ობიექტი
რომ გადმორეკე.
და მერე ბოლოს ცდილობენ წაიკითხონ ფაილი, ასე რომ, ამ შემთხვევაში,
ჩანჩქერი, მე გატეხილი კოდი ორი დიდი ნაბიჯები
სამი პატარა ნაბიჯი.
ყურადღება მიაქციეთ სილამაზე აქ,
მე მოვუწოდებ fs.readFile გადადის გზას.
და შემდეგ მძიმე ნაწილი გონებრივად, არის უბრალოდ გაივლის
იმ ბიჭს გადმორეკე.
საქმე იმაშია, რომ ის გადაცემის, მე ვარ აპირებს გაივლის fs.readFile.
იმის გამო, რომ ჩვენ ყველა დაცვით ამავე კონვენციები,
პირველი არგუმენტი გადმორეკე არის შეცდომა ობიექტის ან null მოჰყვა
by კომა ან გამოყოფილი სია სასარგებლო პერსონალი.
ასე რომ, რას ნიშნავს ახლა და თუ მე წაკითხვის დოკუმენტაციის მე ვიცი
ეს, ძალიან ბოლო გადმორეკე, ამ ბიჭს აქ გარეთ
კვადრატული ფრჩხილები აპირებს გადაეცემა შეცდომა ობიექტი
ან null რომელიც მე უნდა შემოწმდეს როგორც ყოველთვის ეს კოდი აქ.
და შემდეგ განმარტება ამ მეთოდით
იმ ბიჭს დოკუმენტაცია, უკანასკნელი ღირებულება დაბრუნდა
გასული მეთოდი ჩემი ანონიმური მასივი -
ჩემი მასივი ანონიმური ფუნქციები.
ასე რომ, რას წაიკითხავს ფაილების დაბრუნება
და მე გამოყენებით დაბრუნება თავისუფლად ახლა.
ვგულისხმობ რა წავიკითხე ფაილის უღელტეხილზე არგუმენტები
რომ გადმორეკე მეთოდი მისი ხელით?
ორი არგუმენტები, პირველი არის შეცდომა ობიექტის ან null,
რომ თითქმის ყოველთვის იქნება პასუხი.
და მეორე, რაც ხდება იყოს რა წაკითხული ფაილი?
შინაარსი ფაილი, მონაცემები, როგორც ჩვენ მას ადრე.
ასე რომ, უბრალოდ გამოცხადების err, შედეგად,
შეამოწმეთ შეცდომა ამ არის ერთგვარი მოსაწყენი ახლა.
სხვაგან, მე res.end გადადის, რომ შედეგი.
ეს უდავოდ არ სინქრონიზაციის შესანიშნავად
სანამ რეალურად დაწერა თავს.
მაგრამ ახლა, მიიღოს მოშორებით მინიმუმ ფაქტი
რომ არსებობს, როგორც ჩანს, ამ საერთო პარადიგმა, რომლის მიხედვითაც, თუ ჩვენ
და ავტორები ბიბლიოთეკები ყველა სახის ჯოხი
ამ კონვენციის საქართველოს გადმორეკე მეთოდები.
და პირველი არგუმენტი არის შეცდომა ობიექტის ან null.
და მეორე და მესამე
და მეოთხე ობიექტები რამ ჩვენ ვზრუნავთ და ჩვენ ერთგვარი
შემდგომი წესები და დოკუმენტაცია.
ჩვენ დავიწყეთ კოდი, რომელიც პატიოსნად საკმაოდ მახინჯი.
და მიუხედავად იმისა, უახლესი მაგალითად გულწრფელად სახის მძიმე
გადაიტანოთ თქვენი აზრით გარშემო, ის მაინც ვიზუალურად,
ჰგავს ეს ბევრად უფრო მჭიდრო.
და კიდევ თქვენ კომფორტულად ის, რომ ასე ბევრად უფრო ადვილია,
და ეს იმდენად ნაკლებად ემართებათ შეცდომები, ვიდრე წინა მაგალითი.
ასე რომ, ნება მომეცით დემონსტრირება ერთი ბოლო რამ აქ.
ეს არის მობილური სამ.
და - არა, მოდით დატოვოს ამ ერთი მარტო.
ნება მომეცით წასვლას რამდენიმე სხვა ბოლო რამ, როგორც teasers.
ყველა უფლება, ასე სერვერზე 2.
OK. პირველი, რაიმე შეკითხვები, მე ვიცი, ეს არის ბევრი
მაგრამ თქვენ უნდოდა მეტი ინსტრუქციები, ასე?
თქვენ არ უთქვამს კარგი ინსტრუქცია აუცილებლად.
ჰო?
[Inaudible შენიშვნა]
სწორი, თქვენ არსებითად გამო, რომ ოპერაციული სისტემა
გაერკვნენ, თუ როგორ უნდა juggle ყველა ამ ბურთები ერთდროულად,
კითხულობს ფაილიდან, კითხულობს მონაცემთა ბაზაში.
და ეს არის ეს სკრიპტი სერვერზე თავისთავად, რომ ერთი თემა.
და არსებითად და ფაქტობრივად,
იქ ერთ სურათზე მე არ ჩააგდოს მდე,
და ეს არ არის აუცილებელი, ყველა რომ საგანამანთლებლო
მაგრამ იქნებ ჩვენ მივცემ თქვენ გონებრივი მოდელი.
JavaScript თავად კვანძის
კერძოდ აქვს ე.წ. ღონისძიება loop.
რომლის მიხედვითაც, შეგიძლიათ წარმოიდგინოთ საქართველოს Node.js, პროგრამა,
სიტყვასიტყვით მოსწონს უსასრულო ციკლი.
უბრალოდ ველური loop, ელოდება და ელოდება და ელოდება,
ეძებს ამოცანების დაასრულებს.
და ამოცანა შეიძლება, წავიდეთ მოიტანონ რაიმე მონაცემთა ბაზა
ან აქ მნიშვნელობა მონაცემთა ბაზის ან წავიდეთ მისაღებად ამ ფაილის
ეხლა დისკზე ან აქ მოსთხოვოს მომხმარებელს.
ნებისმიერ შემთხვევაში, ისევე, როგორც ბრაუზერები ღონისძიება ორიენტირებული,
ისე, რომ სერვერზე მხარე ღონისძიება ორიენტირებული.
და ყველაფერი ის, შეადგენენ მოვლენები.
ასე რომ ვინმე Node.js, უბრალოდ დაწერა უსასრულო loop,
დიდი ველური loop, ელოდება პერსონალის მოხდეს.
და როგორც პერსონალის არ მოხდება, ის მთავრდება რიგში, არა?
რა თქმა უნდა, მონაცემთა ბაზა შესაძლოა, დაბრუნების ღირებულება.
და ფაილური სისტემა, ოპერაციული სისტემა შეიძლება დაბრუნდეს ღირებულება
დაახლოებით ამავე დროს მაგრამ არსებობს ალბათ აპირებს
ზოგიერთი შეკვეთით მათ.
და Node.js აპირებს აქვს არსებითად მდგომ
როგორც დიდი მასივი ან ვექტორი, ზოგიერთ მონაცემები სტრუქტურა
რომ ბუფერი ყველა იმ რამ.
იმის გამო, რომ მას შეუძლია ფაქტიურად მხოლოდ გაუმკლავდეს ერთი მათგანი დროს.
ასე რომ, როდესაც თქვენ, დეველოპერი,
წერა ასინქრონული JavaScript კოდი გამოყენებით ასინქრონული
ფუნქცია, თქვენ საშუალებას აძლევს ამ ე.წ. ღონისძიება loop წასვლა
მომდევნო tick, არა?
ასე რომ, სანამ თქვენ მაშინვე დაბრუნდება, როგორც ყველა
ამ ასინქრონული მეთოდები მოსწონს წაკითხული ფაილი და stat,
ისინი დაბრუნდებიან მაშინვე რადგან გადმორეკე საბოლოოდ
იღებს უკან.
როგორც კი დაბრუნდება,
ეს ნიშნავს, რომ ვინმეს შეუძლია მიიღოს popped off საფონდო აქ
ან, რომ ეს შეიძლება popped off წინაშე მდგომ აქ.
ასე რომ, იქ არის სინამდვილეში serialization
ყველაფერი, რაც ხდება,
მიუხედავად იმისა, რომ ყველა ამ პერსონალის შეიძლება ხდება პარალელურ
წლის multithreaded სისტემა.
მაგრამ Node.js თავად და სერვერზე გაშვებული
როგორც ერთი თემა.
და ქვემოთ მხარეს რომ არის t თქვენ არ აუცილებლად max
out თქვენი კომპიუტერის შესაძლებლობების განსაკუთრებით
თუ თქვენ გაქვთ 16 ძირითადი ან თუნდაც 2 ბირთვიანი კომპიუტერი
და თქვენ უბრალოდ გაშვებული ერთი ინსტანციის კვანძში.
მაგრამ თუ თქვენ ერთხელ მიღებული რაღაც 161,
თქვენ თავიდან ასაცილებლად დიდი კოშმარი თავის ტკივილი, როდესაც საქმე
რასის პირობები და საკეტები და semaphore
და წერა ნამდვილად multithreaded კოდი
ასე upsides და downsides.
OK. ასე რომ, უკან, კოდი აქ, ნება მომეცით შესთავაზოს, რომ ჩვენ ვიწყებთ
გაამარტივოს რამ ცოტა.
ჩვენ ვნახეთ სერვერზე ერთი ცოტა წინ, რომელიც ჩანდა მოსწონს ეს.
ასე რომ, სავარაუდოდ, საკმაოდ მარტივია.
მაგრამ ისევე, როგორც მსოფლიოში PHP, არსებობს ფარგლებში
ისევე როგორც Laravel და იქ რამ, როგორიცაა, რელსები და Django,
იგივე Node.js მსოფლიოში.
და ჩვენ უფრო მეტი დროს ამ ოთხშაბათს
და მომდევნო პროექტი.
მაგრამ თუ მე წასვლას სერვერზე 2 დირექტორია,
შეამჩნია რამდენიმე პარადიგმების აქ.
ასე რომ ეს არის - არ აპირებს უნდა იყოს ექვივალენტი მაგალითად
მაგრამ ის გამოყენებით ფარგლებში მოუწოდა express.js,
რომელიც არის უფასო ღია კოდის პროგრამული უზრუნველყოფა როგორც რელსები და Django,
ისევე როგორც Laravel, რომ უბრალოდ საბოლოოდ აპირებს
უნდა იყოს დაფასებული დღეს "რა თქმა უნდა უკვე წერდა
ასეთი მარტივი მაგალითები.
მაგრამ გვენდობიან.
ეს ძალიან სწრაფად გახდეს თქვენი მეგობარი
რადგან ეს დაზოგავს თქვენ ბევრი TDS კოდი.
და საერთო პარადიგმა express.js პროგრამა
აქვს app.js ან server.js ფაილი, რომელიც შეიცავს ლოგიკა
თქვენი პროგრამის ან მინიმუმ შესვლის წერტილი.
თქვენ შეგიძლიათ რამოდენიმე ფაილი.
კვანძის მოდული ქვედირექტორიაში რომელსაც აქვს ბიბლიოთეკები
რომ თქვენ გადმოწერილი ისევე როგორც async
და გამოხატოს საკუთარი თავი სხვა.
და შემდეგ package.json, package.json ასე გამოიყურება,
და თქვენ შეგიძლიათ შექმნათ იგი ხელით ან ინსტრუმენტები შექმნა იგი თქვენთვის
და ეს ფაქტიურად JSON ფაილი
და საინტერესო ნაწილი არის დამოკიდებულებები აქ.
ისევე Laravel, თქვენ ჰქონდა, რომ გამყიდველი დირექტორია
და თქვენ უნდა ფიქრი დაახლოებით პაკეტები და აკეთებს -
რეალურად განახლებაზე ერთად Artisan ან ანალოგიური ბრძანებები,
ბიბლიოთეკების თქვენ არ არის დაყენებული,
ანალოგიურად ერთად package.json აქ და თქვენ მართოთ ბიბლიოთეკებში
და ვერსიები რომ თქვენ აინტერესებს.
ასე რომ, თუ მაქვს package.json, შემიძლია უბრალოდ NPM,
Node პაკეტი მენეჯერი დააყენოთ, ის აპირებს ავტომატურად გამოიყურება
იმ package.json ფაილი.
შეხედეთ და ვხედავ, შემიძლია აქვს უახლესი ვერსია
ყველა მოვაჭრეებს მოდულები
ამ კვანძის ხაზს მოდულები დირექტორია აქ ან იქნებ
ზოგიერთი მშობლის ან წინაპრის დირექტორია.
და თუ არა, რომ ის აპირებს ჩამოტვირთოთ მათ
და დაინახავთ მთელი bunch
of HTTP პერსონალის აპირებს მთელი მავთული.
ასე მაგალითად, ნება მომეცით გაჩვენებთ შინაარსი
კვანძის მოდულები მხოლოდ გამოხატოს.
ნება მომეცით წავიდეთ წინ და თამამად წაშლა კვანძის მოდულები
ისე, რომ ყველა მე ახლა ეს.
და თუ მე არ NPM დააყენოთ, თქვენ ვხედავთ, რომ ის აპირებს წაკითხვის
რომ package.json ფაილი და ჩვენ ვნახეთ გამომავალი მსგავსი
ამ წელს Laravel მსოფლიოში.
ის ჩამოტვირთვის მთელი bunch პერსონალის და რომ ის,
იმიტომ, რომ გამოხატოს თავის მხრივ, დამოკიდებულია მთელი bunch
სხვა ხალხების ბიბლიოთეკები.
ასე რომ, ყველა იმ სახის მიმდინარეობს გადმოწერილი რეკურსიული.
აქამდე, თუ გავაკეთო LS ერთხელ,
იქ ჩემს კვანძის მოდულები დირექტორია უკან
და გამოხატოს, როგორც უკან.
ასე რომ, ეს უბრალოდ გზა გამარტივების პაკეტი მართვა.
ახლა, თუ შევხედავთ app.js ფაილი, ეს ხდება
უნდა იყოს reversion to ჩვენი ადრეული სერვერზე
სადაც ჩვენ უბრალოდ შამფურზე out "Hello, world".
მაგრამ შეამჩნია პარადიგმების აქ,
პირველ რიგში მოითხოვს ექსპრესი მოდულის, მაშინ ჩვენ ამ ხაზის
კოდი, რაც თქვენ იცით, საწყისი დოკუმენტაცია.
თქვენ სიტყვასიტყვით მკურნალობა, რომ მოდულის ცვლადი როგორც ფუნქცია,
ასე რომ ღია ფრჩხილებში close ფრჩხილებში ნიშნავს, შეასრულოს იგი.
რომ აპირებს, როგორც ჩანს, დაბრუნდება რაღაც ჩვენ ვაპირებთ
ზოგადად მოვუწოდებთ app.
როგორ მუშაობს?
მე ნამდვილად არ ვიცი.
მე ნება ვინმეს, თქვენ იცით, in ექსპრესი მსოფლიოში წერენ, რომ.
მე ვაპირებ ახლა დავდგეთ მისი shoulders ისე,
რათა ჩემი განცხადება გაშვებული ცოტა მარტივია.
აქ, მე ვაპირებ მოუსმინოს ამ კონკრეტულ პორტში
რომელიც შეიძლება ყველაზე არაფერი.
აქ არის კოდი რომ იქნებ უფრო თქვენში ახლა
საქართველოს Laravel და routes.php.
ასე რომ, ეს არის ვახშამი მარტივი, მე ვარ უბრალოდ უნდა მიუთითოთ მარშრუტი
განთავსების slash ვარსკვლავი, ყველაფერი უნდა შეიწოვება
ამ მოთხოვნით დამმუშავებლის.
პარადიგმა მოთხოვნის კურატორმა მისი ანონიმური ფუნქცია
თხოვნით არგუმენტი
და საპასუხოდ ობიექტი ისევე, როგორც ადრე.
და res.send გამოხატული საშუალებით თქვენ გააგზავნით კოდი მოყვება
ნებისმიერი გსურთ გააგზავნოთ.
და რა თქმა უნდა, შეგიძლიათ რაღაც fancier
რეალურად გაგზავნის ფაილი ან HTML
ან დინამიურად გენერირებული შინაარსი.
მაგრამ ახლა, ყველა ჩვენ გავაკეთეთ იყო შამფურზე hello, სამყაროში.
თუ ჩვენ წასვლას სერვერზე სამი, ეს კი fancier მხოლოდ
გაჩვენოთ რამდენიმე ფუნქცია.
და ჩვენ გაჩვენებთ კი sexier მობილური
ამ ოთხშაბათს.
მაგრამ თუ თქვენ ოდესმე მსმენია of Socket IO შესაძლოა,
ისე, მე ვფიქრობ, ჯონათან თუ ვინმე ამბობს, ადრე,
ერთი რამ კვანძის მართლაც ცნობილი
არის მისი რეალურ დროში ქცევა, არა?
ვიფიქროთ, PHP in MySQL, თუ იყო განახორციელოს სტატისტიკა სერვერზე
in PHP, რომლის დროსაც ორი ადამიანი იქნებოდა გახსნის ბრაუზერის ფანჯარა foo.com
და შემდეგ დაიწყოს IMing თითოეული სხვა Alice in ერთი ფანჯრის,
Bob სხვა ისე, რომ თითოეული მათგანი ხედავს მისი
ან მისი შეტყობინებები სხვა ფანჯარაში.
რა ამის გაკეთება PHP და MySQL?
გამოყენებით ან ვერ გამოყენებით Laravel სახის of არსებითი, შეგიძლიათ აქვს
როგორც index.php ფაილი.
და შენ უნდა - ში ზოგიერთ შემთხვევაში, ის მივიღე შამფურზე
out ფორმა, ასე რომ იქნება HTML ფორმა
რომ ალბათ წარუდგენს არა via ნორმალური ფორმა წარდგენის
მაგრამ Ajax, ალბათ, არა?
ასე რომ, მე წარმოადგინოს კურატორმა, ასე რომ, თქვენ ჩაწერეთ შევიდა ველში,
თქვენ დააჭიროთ და შემდეგ იგი იღებს გაგზავნილი სერვერის მეშვეობით Ajax.
რას შემდეგ გავაკეთოთ სერვერზე?
ასე რომ, თქვენ მოხვდით index.php
ან რაღაც dot PHP, რომ მიღებული HTTP პარამეტრი
საწყისი მომხმარებელს, Alice ან ბობ მყისიერი გაგზავნა, რას გააკეთებს
ეს იმისათვის, რომ პროპაგანდაა ეს ბობ ან Alice, შესაბამისად?
მე ვგულისხმობ თქვენ სიტყვასიტყვით აქვს ინსტრუმენტები, რომლითაც
ამის გაკეთება თქვენი min.
ასე რომ რას გააკეთებს?
თქვენ გაქვთ ერთი წუთი პროგრამის განხორციელების.
ჰო?
[Inaudible შენიშვნა]
სრულყოფილი. უფლება, ასე რომ თქვენ მოხვდით მონაცემთა ბაზაში.
ჩვენ ვიცით, ცოტა ცოტა MySQL.
ასე რომ, თქვენ გაქვთ მაგიდა რომ არის შეტყობინებები,
იქნებ იქ ჯერ შტამპი, მომხმარებლის ID,
ორგანოს გაგზავნა თავად შექმნა, რომელიც,
განახლება, და ყველა რომ.
ასე რომ, თქვენ შესანახად მონაცემთა ბაზაში.
და ვარაუდობენ Alice აგზავნის პირველი გზავნილი, რა Bob მისაღებად
რომ გაგზავნა ქსელშია მონაცემთა ბაზიდან?
>> ეს შეიძლება იყოს გარკვეული Ajax საპასუხოდ, რომ მუდმივად აპირებს
უკან მონაცემთა ბაზაში top მისაღებად [inaudible].
>> ზუსტად.
ასე რომ, ბობ კოდი, რომელიც კოდია იგივე, რაც Alice არის მხოლოდ ერთგვარი
საქართველოს სიმეტრიული ურთიერთობისათვის,
Bob-ს ბრაუზერის აქვს Ajax კოდი ეს, ალბათ, იქნებ ყოველ 30
წამში უბიძგებენ სერვერის მეშვეობით Ajax sync,
არსებობს ახალი შეტყობინებები?
ყოველ 30 წამში ხდება იყოს სახის suboptimal
იმის გამო, რომ მან უნდა ველოდოთ კიდევ
თუ Alice სიტყვასიტყვით უბრალოდ გააგზავნა გაგზავნა.
ასე რომ, Bob-ს ბრაუზერის იქნებოდა ყოველ მეორე მოხვდა სერვერზე.
მაგრამ ეს ნიშნავს, Alice-ის ბრაუზერის დარტყმის სერვერზე
ყოველი მეორე.
რაც შეეხება ჩარლი [აიღო მართლწერა]
და დავით [აიღო მართლწერა] და ედუარდ [აიღო მართლწერა]
და ყველა სხვა წერილი ანბანი?
რა არის პრობლემა ამ მიდგომის?
ბევრი hits ზედმეტი -
ვგულისხმობ, თქვენ მხოლოდ ეფექტურად დოზირების თქვენი მხედველობა
ან DDOSing, განაწილებული უარი სამსახურის თავდასხმა
საკუთარ საიტზე, რომელსაც ყველა
ამ მომხმარებლის აწარმოებს JavaScript კოდი, რომელიც მხოლოდ pinging
heck out of თქვენს სერვერზე მაშინაც კი, თუ თვითნებური ნომერი, ან,
80 პროცენტს გაუტოლდა არავინ ამბობს არაფერს
ჩატში ოთახში.
მაგრამ თქვენ მხოლოდ შემოწმების რომ დავრწმუნდეთ, რომ ასეთი.
ასე PHP ბევრი ენები უბრალოდ არ არის კარგი
რეალურ დროში კომუნიკაციები.
რადგან PHP გაწვევას არსებობს ცენტრალური მეხსიერების, არა?
თქვენ გაქვთ სხდომაზე ობიექტები რომელიც ქმნის ილუზია
ცენტრალური შენახვის, მაგრამ რომ არის თითო პროფაილი საფუძველზე.
თქვენ არ გაქვთ გლობალური მეხსიერება თქვენნაირი გავაკეთოთ Java Servlet
ნაცნობი ან სხვა ჩარჩო მუშაობს, როგორიცაა, რომ.
Node.js თუმცა, თქვენ უნდა მსოფლიო მეხსიერება "მიზეზი გაქვთ
ერთ სერვერზე და რომ "სისტემაში მახსოვს არაფერი მას სურს
ყველა მომხმარებლებს.
და თქვენ ალბათ მაინც აქვს მონაცემთა ბაზაში.
მაგრამ ლამაზი რამ Node.js ძალიან არის, რომ ეს ბევრად უკეთესი
ვიდრე რაღაც PHP და შექმნა ილუზია,
გატარება მრავალჯერადი რამ ერთდროულად.
და რეალურად, როგორც განზე, თქვენ შეგიძლიათ განახორციელოს სტატისტიკა სერვერებზე PHP,
მაგრამ თქვენ, როგორც წესი, ამის გაკეთება რაღაც მოუწოდა ხანგრძლივი საარჩევნო
რომლის დროსაც თქვენ არ Ping სერვერზე ყოველი მეორე.
თქვენ Ping სერვერზე, სერვერი არ უპასუხოს თქვენ,
განთავსების upwards of 30 წამი, ეს სიტყვასიტყვით ზის
მარყუჟის ელოდება და ელოდება.
და სერვერზე ამოწმებს თუ არის ახალი მონაცემები მონაცემთა ბაზაში
და მხოლოდ ერთხელ, რომ თქვენ ვერ ხედავს, "Oh, აქ არის გზავნილი Bob "
იგი პასუხი HTP სერვერზე?
ასე ეფექტი თქვენი ბრაუზერის ის არის, რომ IE ხატი ან Mozilla
ან რასაც მხოლოდ ინახავს spinning 30 წამის დროს.
მაგრამ თავდაყირა არის, თქვენ არ 30 კავშირი მოითხოვს
30 წამში, თქვენ ერთი.
ასე რომ, ეს ე.წ. ხანგრძლივი საარჩევნო.
მაგრამ კიდევ უკეთესი თანამედროვე ვებ ბრაუზერები რაღაც მოუწოდა
WebSocket, რომელიც თქვენ მიიღოს CS143,
შეგიძლიათ ეფექტურად გააკეთოს TCP კავშირს კლიენტებს
ისევე როგორც ბრაუზერი სერვერზე და შემდეგ გათიშეთ შესახებ, რომ ის
გამოყენების გარეშე თითქმის როგორც ბევრი რესურსი
როგორც HTTP შესაძლოა, ტრადიციულად გააკეთოს.
და Socket IO არის Node.js ბიბლიოთეკა
რომ ხდის ბევრად უფრო ადვილია რათა სოკეტი კავშირები
ან ილუზია არ არსებობს ერთი ძველი ბრაუზერები
ასე რომ თქვენ შეგიძლიათ განხორციელების რეალურ დროში ფუნქციონალური ს.
ასე რომ, აქ არის მაგალითი.
ამ პერსონალის up დაბრუნება იღებს ცოტა უფრო რთული
მაგრამ ეს, ძირითადად, დააკოპირეთ და ჩასვით ეხლა socket.io 's დოკუმენტაცია.
აი, ახლა უფრო ზუსტი მოთხოვნა დამმუშავებლის.
თუ მომხმარებლის თხოვნა slash, რა ფაილის ვარ მე აპირებს
უნდა იყოს, როგორც ჩანს, ემსახურება მათ?
Index.html.
და იქ რამდენიმე ახალი პერსონალის აქ ნაკადი
რომელიც მე გაჩვენებთ რაღაც მომენტში.
მაგრამ ეს არის კიდევ ერთი გზა
მითვისებაში ფაილი ცოტა უფრო ეფექტურად
გარდა უბრალოდ აკეთებს fs.readFile.
ეს პატარა მსოფლიოს სასურველი სტუმარი გახდებით განსაკუთრებით დიდი ფაილი.
ისე დიდი ხნის ამბავი მოკლედ, ამ ხაზების უბრალოდ ემსახურება
up ფაილი სახელად index.html
რომელიც ახლა ვივარაუდოთ შეიცავს HTML ფორმა, რომელიც Alice
და ბობ შეიძლება intercommunicate.
და ბოლოს, io.sockets.on, ასე რომ ეს მოდის ამ ხაზის აქ.
ასე რომ, მე უბრალოდ კითხულობს დოკუმენტაცია io.socket მაძლევს
ხელმისაწვდომობის ე.წ. WebSocket ბრაუზერში,
შორის browser და სერვერზე.
მე მოსმენის სპეციალური ღონისძიება დაკავშირებით რაც იმას ნიშნავს,
როდესაც მომხმარებელს პირველი ჰიტები სერვერზე ცდილობს
გახსნა ამასთან დაკავშირებით, მე ვარ ვაპირებ მოვუწოდო ამ ზარის დაბრუნება.
და ახლა, მე ვაპირებ უნდა გავაკეთოთ შემდეგ.
ყოველ ხუთ წამში, რა მე ვაპირებ ამის გაკეთება?
მე ვაპირებ ასხივებენ ან ეთერში თუ გახსოვთ ნულიდან,
გრაფიკული ენის შესწავლა რომ სამაუწყებლო ბლოკები?
ასე რომ, თქვენ აპირებს გადასცემს
ან გამოიწვიოს ღონისძიება სახელწოდებით თვითნებურად სერვერიდან.
და ის აპირებს შეიცავდეს გაგზავნა Ping
და მიმდინარე თარიღი.
ასე რომ, ეს არის ფაქტობრივი სტატისტიკა სერვერზე რომ Alice
და ბობ შეგიძლიათ გამოიყენოთ, მაგრამ ეს ერთგვარი ავტომატური სტატისტიკა სერვერზე
სადაც შეტყობინებები უბრალოდ სახის sonar pings.
უბრალოდ დღემდე ჯერ რომ იგზავნება ყოველ ხუთ წამში.
ასე რომ, თუ მე რეალურად აწარმოებს ამ რამ - და რომ არის ის.
იყოს ნათელი ქვემოთ აქ, ცნობა ეს მხოლოდ ხე ქვემოთ აქ.
ასე რომ, ნება მომეცით გახდეს ბრმა თვალი რომ.
ნება მიბოძეთ გავაკეთოთ კვანძის app.js.
ნება მომეცით გადასვლა ჩემს ბრაუზერში.
განაახლეთ მთავარი გვერდი აქ.
[პაუზა]
და ნება მომეცით დახურვა ინსპექტორი.
ყოველ ხუთ წამში, მაქვს აქციის მიუხედავად იმისა, რომ არ არის
ინტერაქტიული ადამიანის
რომ რაღაც არის ხდება asynchronously.
ბრაუზერის ცნობა, არ არსებობს დაწნული ხატი.
ის გამოყენებით fancier ფუნქცია of Chrome თანამედროვე ბრაუზერებში
შენარჩუნების ბუდე კავშირი ქვეშ hood
და ეს არის ის, რაც ე.წ. ზოგადად pub / sub მოდელი,
აქვეყნებს / გამოწერას მოდელი, სადაც ჩვენ არ კეთდება
რომ საკმაოდ მკაფიოდ აქ.
მაგრამ რა არის ლამაზი შესახებ ზოგადი pub / sub პარადიგმა არის
რომ თქვენ შეგიძლიათ ერთი გამომცემელი.
ამ შემთხვევაში, ცენტრალურ სერვერზე და ყველა
ინდივიდუალური ბრაუზერები კლიენტებს.
Alices და Bobs შესახებ მსოფლიო შეგიძლიათ გამოიწეროთ იგი,
ასე რომ თქვენ შეგიძლიათ სარელეო შეტყობინებები მათ შორის ნებისმიერი რაოდენობის მომხმარებლებს.
და მიუხედავად იმისა, ისევ ჩვენ არ ხედავს interactivity,
ჩვენ გვქონდა იქნებ 12 ხაზები კოდი უბრალოდ უნდა გავაკეთოთ ეს.
და ეს, ალბათ, არ ნახტომი წარმოსადგენია, თუ როგორ შეიძლება whip
იმ index.html ფაილი რომ აქვს ჭეშმარიტი HTML ფორმა,
ცოტა jQuery კოდი და Ajax, რომ არ გაგზავნის დღისით
მაგრამ მხოლოდ აგზავნის რასაც Alice ან Bob ტიპის სერვერზე
და შემდეგ სერვერზე იქნება სარელეო ის.
და მე გპირდებით, რომ glimpse ერთი ბოლო რამ, უბრალოდ,
აჯავრებენ თქვენ ამ.
თუ ჩვენ წასვლას ნაკადი ნულოვანი და ერთი,
დაინახავთ კოდი, რომელიც მხოლოდ ცოტა განსხვავებული აქ.
უბრალოდ ასე რომ თქვენ ვნახე ეს, ეს არის ალტერნატიული
რა ეწოდება fs.readFile საშუალებას უფრო ადრე, რომლის დროსაც,
თქვენ შეგიძლიათ თქვათ Node.js, "წადით წაიკითხოს ეს ფაილი მეხსიერებაში.
მაგრამ თუ ეს დიდი უბრალოდ მისცეს me ბლოკი დროს. "
და მოგეხსენებათ CS165
ან 161 ფაილი სისტემები აქვს სხვადასხვა
შესრულების თვისებები.
დაგვჭირდება წაკითხვის ბლოკების 512 bytes
ან 2 kilobytes ან რასაც.
ეს არის ოპტიმიზაცია გზა დავუბრუნდეთ ფაილის iteratively
ასე რომ თქვენ შეგიძლიათ შამფურზე ის out უფრო სწრაფად
ბრაუზერში ან ვინც ბოლომდე კლიენტს.
ასე რომ, უზარმაზარი შინაარსი დღეს და ჩვენ ვაპირებთ ჩაყვინთვის
უფრო დეტალურად ოთხშაბათი ტიმ [აიღო მართლწერა]
კერძოდ, ეძებს თუ როგორ ჩვენ შეუძლია თარგმნოს ზოგიერთი იდეები
პირველი ნახევარი რა თქმა უნდა, Laravel და მოდელები
შევიდა ბიბლიოთეკაში, რომ თავად წერდა მოუწოდა Bookshelf.js
რომელიც უფრო პოპულარული თანამეგობრობას
იმიტომ, რომ ეს გაძლევთ ყველაზე მეტად ის,
თუ არ მეტია, ვიდრე ფუნქციონალური eloquent
რომელიც გაწვევას არის ის, რომ ბიბლიოთეკა რისთვისაც Laravel,
ასე უფრო, რომ და მეტი, თუ როგორ
განავითაროს სრული სრულუფლებიანი apps ოთხშაბათს.
ჩვენ ხედავთ შემდეგ.