>> KEVIN SCHMID: Hallo iedereen.
Welkom op de CS50 seminar op Node.js.
Mijn naam is Kevin.
Ik ben een CS50 TF.
En ik ben een beetje zoals echt enthousiast over dit seminar.
Ik denk Node.js is erg cool.
Ik hoop dat dit seminar kunnen worden gebruikt als een goede, denk ik, springplank voor
sommige van uw uiteindelijke projecten als u geïnteresseerd in het gebruik zijn
iets als Node.js.
>> We zullen een soort van start het seminar uit door alleen over een beetje van de
soort achtergrond schaalbaarheid perspectieven van Node.js, en vervolgens
we gaan naar een aantal voorbeelden van code.
En ik zal de code op een website te hebben, en je kunt kijken naar de code.
En na het seminar, zal ik sorteren gesprekstijd over hoe je kunt instellen Node.js
op uw computer.
>> OK.
Dus laten we beginnen.
Dus ik denk dat ik wil alleen maar praten over webservers, echt, als eerste.
En om deze discussie te starten, ik in principe een diagram dat van
het leerboek gebruikt voor CS61, die toont eigenlijk de interactie
tussen een cliënt proces, zoals uw web browser of als uw doel klant of
iets dergelijks, en een webserver.
Dus dit lijkt een soort vergelijkbaar met de foto die je zag in lezing over
Woensdag waar in principe hebben we een aantal clientproces zoals Google Chrome.
>> En dan stap een is de client stuurt een verzoek.
Dus dat kan iets als goed laten we bezoeken, weet ik niet, CS50.net.
Dus we geven dat verzoek.
En heeft iemand herinner me de naam van het protocol dat bepaalt hoe dat
verzoek moet worden gestructureerd?
Yep.
>> PUBLIEK: [onverstaanbaar].
>> KEVIN SCHMID: Precies.
Dus het is zoals HTTP, toch?
Dus eigenlijk geeft aan hoe dat verzoek moeten daadwerkelijk worden gelegd
uit, want aan het eind van de dag, dat verzoek is eigenlijk net als een
string die eigenlijk zegt ik wil dit.
En de specificatie daarvoor is HTTP.
Dus dat is als een protocol.
>> Dus dan is de server ontvangt dat verzoek.
Dus jullie hebben een webserver geïnstalleerd in de CS50 apparaat.
Het is Apache.
En deze week als je werkt op de probleemgebieden stelde zeven, zult u daadwerkelijk werken
met dat web-server.
Dus de server ontvangt dat verzoek, en dan moet het soort krabben haar
hoofd en zeggen als goed wat doe ik met deze?
>> Dus op basis van wat zij beslist te doen, dan het kan hebben om contact op te nemen een soort
van bron.
En die bron zou kunnen zijn van een veel verschillende dingen.
Voor een, kan het zijn gewoon als een statische HTML-bestand.
Dus het kon gewoon zoals sommige HTML die is net als voor
uw persoonlijke website.
Het zou een statisch bestand als een afbeelding te zijn of als een film die je hebt.
Het zou zelfs moeten praten om een ​​soort database
als een MySQL database.
Dus het hoeft niet altijd om te communiceren met een bron, maar in
sommige gevallen kon.
>> Dus dan wat het gaat doen na dat is dat het gaat om
terug te sturen de respons.
En de respons op dit ook opgegeven door HTTP.
Dus dan is de klant kan ontvangen.
Het kan het uit elkaar scheuren en verwerken.
En dan krijg je een webpagina zoals Google of CS50.net of
wat je ging.
OK?
>> Dus dit is de basis interactie die we gaan te maken hebben.
En we vrij veel gaat worden richten op dit deel van de
interactie de server.
OK.
Cool.
Iemand enig vragen tot nu toe?
OK.
>> Dus zoals we al zeiden, de webserver ontvangt deze HTTP-verzoek en geeft dan dit
HTTP response.
En zoals we eerder over gesproken, de CS50 apparaat webserver is Apache.
Dus als jullie werken aan P stelde zeven, je gaat werken met de
Apache web server.
Je zult nooit echt werken met Apache direct teveel.
U soort configureren Apache een beetje wanneer u de virtuele hosts of opgeven
de v gastheren, en we krijgen om dat in een klein beetje.
>> Maar in principe, de Apache web server opgezet om te werken met PHP soort
van uit de doos.
Dus wat er werkelijk gebeurt is wanneer je gaat naar een van uw websites als, zeg,
lokale host slash index.PHP of zoiets, is uw browser stuurt die
aanvraag, en vervolgens Apache zit daar en cijfers uit te maken.
En de actie is om uit te voeren die code in index.PHP en
stuur het dan uit terug.
Dus er is dat.
Dus we soort over gehad.
Dus kon het gewoon een statisch bestand dienen of uitgifte lopen een aantal PHP-code en vervolgens
de reactie.
>> Dus dan is een veel voorkomende vraag die kan komen up is goed, hoe kunnen we echt gaan
met het hebben van meerdere gebruikers tegelijkertijd?
Dus stel als je het schrijven van een web server, als u een webserver had dat
je probeert te schrijven in iets zoals C of iets dergelijks,
in principe kun je nadenken over hoe er een soort code zou kunnen zijn dat
zou het verzoek hebben ontvangen, maar dan het moet al dit werk aan het doen.
Het kan zijn dat, bijvoorbeeld, contact gegevensbestand of iets dergelijks.
Rechts?
En dan zou het dat soort doen verwerking en
teruggestuurd de reactie.
Dus dat is net als de hoge algemeen overzicht.
>> Maar het is niet meteen duidelijk hoe je kan dat doen, zodat twee personen of
zelfs 1000 mensen kunnen werken met uw webserver tegelijkertijd.
Dus de oplossing die gebruik maakt van Apache heet draden of processen.
Dus je hebt misschien gehoord van deze termen voor.
Het is OK als je niet hebt, maar denk gewoon over threads of processen als manieren voor
een besturingssysteem of een gebruiker programma of iets dergelijks of een webserver
om een ​​soort van uit te voeren meerdere dingen tegelijk.
Dus kan je de term gehoord zoals draden van executie.
Dus het is een beetje alsof je soort van multitasking.
>> En als je hebt gezien op de doos van uw laptop, of iets dergelijks,
multicore, wat je kunt doen is je kunt lopen twee verschillende threads op verschillende
delen van de CPU zodat zij feitelijk gebeurt tegelijkertijd.
Dus dit is echt krachtig.
En dit is een soort van Apache's oplossing voor dit probleem.
>> Zo zijn er zoiets als eventuele problemen met deze aanpak al?
Dus ik denk dat ik soort van daar schreef ze.
Maar beiden soort gebruiken veel geheugen.
Het is erg duur om te maken een draad of een proces.
>> En een deel van de redenering is dat gewoon zoals wanneer je draait een C-programma
als uw belangrijkste en toen dat gesprekken andere functie, dat is
een soort stapel.
Dus vragen die vereisen ook een geheel aparte stack die
kan heel groot.
En als je kunt voorstellen dat tonnen gebruikers op uw website, zou je
veel verschillende threads.
Dat is een hoop stapels aan beheren en te onderhouden.
Dus het is een groot geheugen verbruik.
>> En dan ook, laten we zeggen dat je alleen maar een CPU, of laten we zeggen je hebt
meer threads dan je hebt die multicores.
Rechts?
Dus laten we zeggen dat je 10 draden had en je had maar vijf CPU's.
Je hebt soort van deze zaak te doen waar u schakelen tussen de huidige
een die actief omdat u niet alle 10 tegelijk draaien.
En dat heet een context switch.
En die term eigenlijk een paar verschillende contexten, maar laten we gewoon
denk aan het als het schakelen tussen twee threads.
Dat kan behoorlijk duur zijn, omdat eigenlijk wat je moet doen is je
moeten stoppen met wat je doet, slaat de staat dat het runnen van draad, en
dan overschakelen naar ergens anders.
>> Dus doet iedereen soort zien de motivatie waarom draden en
processen is misschien een beetje grof zijn?
En heb je een vraag?
OK.
Cool.
Iemand nog vragen?
OK.
>> Dus als we een stap terug voor een tweede, er is net zoiets als een
observatie dat we kunnen maken over veel webapplicaties.
En dat is echt zo veel van hen eigenlijk doen dat niet veel nuttige
werken binnenkant van een draad.
Dus heeft iemand gestart op P stelde zeven op alle?
Dus wilt u misschien te beschrijven sommige delen?
Heb je gewerkt bij het inloggen of iets dergelijks?
>> PUBLIEK: Nee
>> KEVIN SCHMID: OK.
Maakt niet uit.
Sorry.
Maar in principe, in de P-set, je bent gaat worden maken van een heleboel soort
query naar een database om wat te krijgen informatie uit die database.
En wat uw code is gaan doen, wat dat Apache proces of
dat Apache draad gaat doen terwijl het moet contact
databank is dat het een soort van gaat worden zitten er en het gaat worden
wachten op de database om te antwoorden.
>> Nu dat klinkt misschien niet zo groot een gaan omdat de database op uw
CS50 apparaat, toch?
Maar er is een soort van netwerk latentie daar omdat nu het web
server moet zijn eigen verzoek af te geven aan de database te communiceren met de
databank en krijgen dan dat informatie terug.
Dus nu is het net goed op me wachten, ik ben ga iets te krijgen van de
databank en dan is er een veel wachten gaande.
Is dat logisch?
>> En voor sommige dingen is het niet zo slecht.
Als het net, bijvoorbeeld, toegang tot het geheugen, dat is niet zo
afschuwelijk I / O latentie.
En als ik zeg, I / O latentie, wat ik verwijzend naar is als elke soort als
input output.
Maar om een ​​bestand op de schijf, zoals als ik wilde de statische HTML dienen
bestand dat op mijn webpagina of iets dergelijks, ik heb soort van te
stoppen voor een beetje, lees dat bestand in van de schijf, en vervolgens in
dat proces Ik wacht.
Ik doe nuttig werk.
>> Dit is niet waar van alles, maar het komt vaak voor bij toepassingen zoals P set
zeven en veel applicaties dat je niet
eigenlijk doet veel denken.
En als ik zeg denken, ik bedoel zoals rekenwerk.
Dus rekenwerk kan iets zijn zoals, zeg, je wilde
schrijf een webserver die enkel berekend de zoveelste Fibonacci getal.
Dat klinkt niet als een bijzonder leuke web-server.
Alsof ik zou niet verwachten dat die site te zijn de volgende Facebook, maar dat is wat
soort rekenwerk.
>> En je kunt je voorstellen dat het vervangen met een andere vorm van interessante
rekenwerk.
Laten we zeggen dat je iets aan het schrijven dat berekende de mate van
scheiding tussen twee mensen of iets dergelijks.
Dus dat gaat gepaard met een soort van de berekening, toch?
En zelfs dan, om te doen dat je nog steeds een hoop wachttijd doen voor misschien
u te vragen een database om te kijken up die is bevriend met wie of
zoiets.
Dus er is dat soort van begrip van rekenwerk.
Is dat logisch?
Heeft iemand nog vragen?
>> Oh en ik denk dat ik chat-servers er omdat de chat servers zijn soort
Een ander goed voorbeeld van.
Een chat-server hoeft niet te veel na te denken.
Het heeft alleen maar te wachten voor mensen om berichten en vervolgens wanneer sturen
ze doen, stuur ze.
OK?
>> Dus gewoon om weer samen te vatten, Apache en soortgelijke web servers zoals die vork een
veel draden en processen die kan soort van verspilling.
Dus ik denk dat de vraag die kan komen vanaf dat moeten we hebben
meerdere threads en processen?
Wat als we hadden slechts een?
>> Dus laten we een soort van een beeld schetsen van wat deze eruit zou zien.
Dus laten we gebruiken slechts een draad.
OK?
Dus alleen deze voorstellen met een draad.
>> Laten we aannemen dat we waren niet echt te doen dat veel nuttige - en als ik zeg
nuttig, ik bedoel rekenwerk -
in die meerdere threads voor.
Dus laten we soort consolideren alles in een thread.
Dus wat als we hadden een thread dat soort gaat van net om in de lus en
voortdurend controles deed iets nieuwe gebeuren.
Dus bijvoorbeeld, iets nieuws gebeurd zou kunnen betekenen dat ik iets terug van
de database, of iemand gestuurd mij een nieuwe HTTP-verzoek.
Dus dat zijn soort evenementen dat gebeuren, toch?
>> En dan wat ik kan doen als die nieuwe dingen gebeuren is in deze zelfde thread
van uitvoering, deze enkele draad van uitvoering, kan ik wat code noemen dat
zou behandelen die bijzonder ding.
Dus bijvoorbeeld, als ik iets terug uit de database, kon ik run mijn
kleine computationele deel ervan dat eigenlijk alleen maar bereidt het ding om
terug te sturen naar de gebruiker.
Dus doet dat soort zinvol?
>> Maar wat zijn eigenlijk de implicaties hiervan?
Rechts?
Omdat we hebben geschreven veel van de code die -
en ik ga gewoon vooruit te springen in de dia's als dat is OK.
Dus als je het niet erg, ik ben gewoon ga een stap terug te nemen.
Dus dit soort dingen is riep een gebeurtenis lus.
OK?
En het is een soort van de basis- idee achter Node.js.
>> Dus wat Node.js is eigenlijk doet als een web server is dat er een enkele draad
dat is in principe rond te gaan in een lus als een terwijl een soort onder
de kap van Node.js dat is constant controleren, hebben we nieuwe dingen ontvangen?
En dan zal het handlers draaien die u hebt ingesteld.
Maar een goede vraag is, hoe kunnen we dit te laten gebeuren
met bestaande dingen?
>> Dus heb ik een lijn van C code hier dat lijkt eigenlijk alsof het openen van een
bestand, toch?
Ik Ze kwam net uit met een album.
Dus ik moest haar een nieuw bestand te openen.
Dus de manier waarop onze C-code voor de bediening -
en ik denk dat de reden dat ik bestanden koos was want dit is een soort van de mate
van de I / O-werk dat we hebben gedaan in C in een gevoel dat er input output.
Dus deze code noemen we dat doet dit f geopend.
En dan op de volgende regel van onze programma, kunnen we nu werken met f.
>> Dus dit een voorbeeld van iets zou zijn dat is net als synchrone of
blokkeren omdat op die eerste lijn daar we wachten tot we
krijgen het bestand geopend.
Dus op de tweede regel, we weten dat we kan werken met f, maar dit betekent dat
dat de tweede lijn kan niet echt lopen tot de eerste lijn wordt gedaan.
Is dat logisch?
>> Dus dit slecht zou zijn om te zetten in een event handler.
En de reden daarvoor is dat dit soort wacht, toch?
Dus dit zou ons weer terug op hetzelfde neer.
En nu zouden we niet eens de voordeel van meerdere threads of
processen omdat we een thread in Node.js.
Is dat zinvol voor iedereen?
>> PUBLIEK: Wacht.
Dus wat is de vervanger?
>> KEVIN SCHMID: Oh, dus ja.
Dus ik ga krijgen de vervanging.
OK.
Dus wat als we iets hadden dat zag er zo uit?
Dus wat als ik nu bewerkt f opent een beetje?
Dus ik ben het passeren in dezelfde twee argumenten als voorheen.
Ik hou nog steeds van de nieuwe song dat ze kwam met.
Maar ik ben het passeren van een derde ding dat wordt deze variabele genoemd code.
>> Maar wat is eigenlijk code in dit verband?
Is het als een gewone C variabele?
Het is een functie, toch?
En dat kan een beetje raar, omdat zijn Ik ben eigenlijk net als nu het passeren van een
functioneren in andere functie.
>> Dus een paar dingen op te merken over dit.
Een, ik ben eigenlijk niet bellen de code functie.
Zodat je niet ziet code met de Paren links, rechts Paren.
Ik ben op doorreis in de code.
En in C, wat dit zou eigenlijk doen is geef me een pointer naar dat de werkelijke
code, en dan kan het uit te voeren.
Maar denk maar aan het als je bent het passeren van de code kan worden uitgevoerd wanneer
dat bestand opent.
>> Maar wat dit betekent is dat nu de rest van mijn programma dat kon doen
andere dingen, kan blijven andere doen spul terwijl wij, niet echt te wachten, maar
gewoon aan de achterkant van ons hoofd dat toen van dat bestand openen, run die
code bovenaan.
Is dat logisch?
>> En nu het idee achter Node.js is dat de code in de doe dingen met f
deel moet vrij kort en eenvoudig zijn en eenvoudig en niet echt
zeer rekenintensieve.
Het kan noodzakelijk zijn om bestand te openen, maar dat moet ook vrij snel zijn
want het moet gewoon zeggen doen andere f openen en vervolgens noemen dit een andere code.
>> Dus gewoon om helemaal duidelijk, de f worden openen dat doet de nieuwe Katy Perry lied
gedaan mp3, dat gaat vrij veel onmiddellijk terug.
En dan kunnen we gewoon blijven doen andere dingen, omdat dat nu allemaal f
open oproep doet is vertellen in principe de onderliggende f open code dit bestand te openen
en als je klaar bent het openen van dit file of wanneer u het terug te krijgen,
voer die code.
Maar het hoeft niet daadwerkelijk gereden die code.
En u had een vraag?
>> PUBLIEK: Je leek een paar impliceren keren dat het toevoegen computationeel
intensieve code soort breken de [Onverstaanbaar] aangedreven systeem.
[Onverstaanbaar]?
>> KEVIN SCHMID: Dat is een grote vraag.
Dus ik heb eigenlijk een voorbeeld van hoe je zou computationeel integreren
intensieve code in een klein beetje.
Dus als we in de code voorbeelden, Ik zal er zeker op die ene trekken.
Is dat goed?
Dank u.
>> Wat was je naam?
>> PUBLIEK: Aaron.
>> KEVIN SCHMID: Aaron brengt een zeer goed punt, namelijk dat als ik had
sommige rekenintensieve code in de dingen doen met f deel, de rest van
mijn programma kan niet worden uitgevoerd en kan niet luisteren voor nieuwe aanvragen of iets totdat alle
dat spul is voltooid.
Dus als ik aan het schrijven ben Node code in het algemeen tenzij we iets doen als ik ga
om later te suggereren als we kijken naar de codevoorbeelden, ik moet er zeker van zijn dat
mijn code niet vastbinden dit evenement lus.
Is dat logisch?
OK.
Cool.
>> Dus Node.js biedt dit kader dat U kunt deze gebeurtenis bouwen gedreven
servers.
Dus het heeft dit soort van asynchrone niet-blokkerende I / O-bibliotheken, terwijl
de standaard C-bibliotheken die we geweest zijn werken met, zoals als je gewoon
gebruik ze op dezelfde manier dat we hebben ze te gebruiken met f opent en
spullen, die blokkeren, omdat je eigenlijk moet wachten voor
dat bestand te openen.
>> Maar Node.js geeft je dat en het banden in principe in Google's V8
JavaScript-engine dat is de reden dat Chrome is zo snel bij verwerking
JavaScript omdat heeft deze V8 motor.
Dus ik weet dat klinkt als een van die WWDC ontwikkelaar conferenties ding
waar ze gewoon gooien een stel de brief aantal dingen voor processors
en zeggen: dit is zo cool.
Maar het is cool dat ze deden dit omdat JavaScript -
of misschien als je niet bekend bent met JavaScript maar omdat we nog niet gehad
de lezingen op het -
maar JavaScript is een geïnterpreteerde taal.
>> En dit is een belangrijk punt ook.
Dus het is belangrijk voor onze web servers te snel zijn, toch?
En als we alleen rennen JavaScript code die werd geïnterpreteerd met slechts
alle oude tolk het zou kunnen zijn traag.
Dus Node voordelen van het hebben van deze supersnelle V8 tolk.
En ik weet niet of ze noemde het omdat de V8 klap in het voorhoofd
ding, maar OK.
>> Dus ik heb enkele voorbeelden voorbereid op deze URL.
Na het seminarie, ik soort van naar praten over hoe je Node set kan krijgen
up, maar voor nu, ik heb net een soort van willen te lopen door een aantal voorbeelden van code.
Dus als je wilt om mee te volgen, alle broncode is daar beschikbaar.
OK?
>> Dus ik zal deze URL te verlaten voor een beetje.
En dan ga ik gewoon naar overschakelen naar de terminal.
Is iedereen goed met deze URL?
Dus ik ga om over te schakelen naar mijn terminal hier.
>> Dus hier is de code die Ik heb voor vandaag.
Waarom hebben we niet beginnen met simpler.js bestand?
Het andere ding is dat dit alles code zal zijn om geschreven
Webbrowser die u wel of misschien niet vertrouwd zijn met.
Ik denk dat een paar dingen is dat veel JavaScript-code is het soort
syntax en structuur vergelijkbaar met C, dus je kan soort van pak het op als
je verder gaat.
Ik heb geprobeerd om een ​​groot deel van de te schrijven startcode hiervoor op een manier die
Soortgelijke C zodat het een beetje meer leesbaar.
Maar als we vooruitgang, zal ik tonen sommige van deze aanvullende
kenmerken van JavaScript dat zijn wel cool.
>> Maar laten we eens kijken naar dit voorbeeld programma.
Ik denk dat alles is er afgesneden.
Ik ga gewoon naar die echte fix snel als dat is OK of niet.
Ik weet niet wat dit gaat doen.
Is dat een beetje beter?
Ziet u de var en zo?
OK.
>> Dus de eerste regel is als de JavaScript versie van een variabele
verklaring.
Dus gewoon om te benadrukken wat dit zou uitzien in C. Dus dit is net als
me zeggen index gelijk aan drie of iets dergelijks.
Dus heb ik niet het type opgeven.
JavaScript heeft wel typen, maar het is zeer dynamisch getypeerde in de natuur, zodat
heeft geen enkele vorm van het type op.
Dus het heeft gewoon var.
Dat is hetzelfde als een variabele.
OK?
>> En ik bel deze variabele HTTP.
En op mijn rechterhand, ik heb de uitdrukking die ik wil in HTTP te zetten.
En dit zegt vereisen HTTP.
Dus dit is een beetje vergelijkbaar met omvatten.
Het is een beetje meer als krachtiger dan zijn in die zin dat zijn
zou gewoon kopiëren en plakken de kop bestand voor de functie prototypes of
wat met de type-definities.
Maar vereisen er werkelijk gaande is om ons de code.
>> Zo kunt u denken aan het als importeren van een code.
Dus ergens in de Node.js module systeem of wat, zij hebben dit allemaal
HTTP-server code, dus ik ben gewoon halen het voor mijn eigen
persoonlijk gebruik in dit programma.
OK?
>> Dus dan heb ik deze functie dat ik heb geschreven.
En let op, ik hoefde niet te specificeren de return type of het type van de
argumenten weer.
Dus soort van losse getypt in dat soort gevoel.
Twee argumenten dat het duurt in, de aanvraag en-antwoord.
Dus dat is conceptueel zoiets als bekend van het beeld dat we hadden
op het scherm voordat omdat krijgen we deze aanvraag dat we
hebben van de gebruiker.
En dan hebben we een reactie die kunnen we dingen schrijven.
>> Dus de eerste regel van dit doet res.writeHead 200 en vervolgens deze
content type tekst vlakte.
Dus laten we dit stuk uit elkaar een beetje.
Dus laten we gewoon focussen op res.write voor een beetje.
Dus schrijven is eigenlijk, en schrijf kop, zijn slechts manieren om de soort te schrijven
dingen aan de respons.
OK?
Dus schrijf kop, als iemand herinnert van de HTTP-lezing, doen jullie
herinner headers bij de top van de HTTP-ding?
Dus waarom niet ik demo alleen headers echt snel.
Zou dat nuttig?
Of moeten we gewoon soort van -
OK.
Tuurlijk.
>> Dus als uw browser gaat naar google.com of iets dergelijks,
is er eigenlijk een beetje meer -
dit is als een geheim -
er is net een beetje meer informatie dat komt door de pijp dan alleen
het beetje zoeken en alles.
Dus om u dit te laten zien, ik ga een programma genaamd Curl gebruiken.
OK?
Dus dit is iets dat je kan draaien op Mac OSX opdrachtregel of in de
apparaat of wat dan ook.
En dus als ik Krul HTTP google.com, Ik ga naar de HTML zien.
En dit is, in alle eerlijkheid, maar de HTML dat soort vertelt u
omleiden naar www als uw browser niet automatisch omgaan met de
omleiding.
>> Dus dit is gewoon HTML, maar ik ga toe te voegen aan dit koppelteken markeer ik Krul.
OK?
En dit gaat om te laten zien me de headers.
Dus dit is ook informatie die wordt geleverd door als ik deze reactie.
OK?
>> Dus op de top, dit zie je HTTP 301 permanent verplaatsen.
En dit is een soort van belang omdat dit verwijst naar de status code.
Dus de 301 hier is de status code, dat is eigenlijk gewoon een integer
dat vertelt de browser of wie dan ook is dit leest, als je doet alsof dat
je bent een browser en je ziet dit, eigenlijk nu als je kijkt naar
dat en je ziet een 301, weet je ik heb om iets speciaals te doen op basis van
301, of iets bijzonders gebeurd gebaseerd op 301.
Dus het zegt definitief verhuisd.
>> En dan, in principe, hebben we een bos van belangrijke waarde paren.
Dus krijgen we de locatie is www.google.com.
En dan soort van al die andere dingen, maar in principe, wat de locatie is
gezegde is de nieuwe locatie is op www.google.com.
Dus nu als je naar google.com, zul je soort zien de browser soort blink
voor een tweede en leid je terug naar www.google.com.
Zodat de reacties kunnen bevatten deze headers.
>> En een paar dingen te wijzen.
Dus laten we zeggen dat we waren eigenlijk succesvol in het bezoeken van een webpagina.
Dus laat me gaan -
wat is een goede website?
Ik ben slecht in het denken van een goede websites op de plek.
>> PUBLIEK: Wikipedia.
>> KEVIN SCHMID: OK.
Laten we het doen Wikipedia.
Dus hier was ik verhuisd.
Oh wacht.
Was ik gebleven?
Ja, ik was.
OK.
Dus ik heb naar www doen.
Dus ik ga naar www doen.
En zoals je kunt zien, hier is al de HTML dat de browser zou worden verwerkt
voor Wikipedia.
>> Maar als ik blijf scrollen hier, wat ik zal zien op de top -
wow, er is veel HTML op Wikipedia -
maar wat kan ik hier aan de top te zien is deze 200 statuscode in tegenstelling tot de
301 die ik eerder zag.
En merk op dat het heeft een leuke vriendelijke OK ernaast.
Dus dit is als de goede toestand code.
>> Is dat 200 nummer er bekend uit?
Ja want toen ik dat deed simpler.js, Ik schreef een 200 daar.
Dus dat is eigenlijk te zeggen vertellen de browser of wie probeert te bereiken
dit dat ze succesvol waren.
Of dat soort zoals we waren ook succesvol.
>> En er is een soort van speciale syntax in Javascript voor waarbij een
kaart van deze toetsen als content type en deze waarden zoals tekst vlakte.
Dus als je kijkt naar het antwoord dat we terug van Wikipedia voor, -
Ik ga proberen om te scrollen een beetje sneller -
u deze toetsen zoals server en deze waarden Apache.
Dus je hebt sleutels en waarden.
En u kunt dit aangeven in Knooppunt wat terug te sturen.
>> Dus dit is eigenlijk wel in sommige manieren, en in sommige opzichten is het niet
echt, maar het is een beetje lager niveau dan de PHP-code die je misschien wel
schrijven voor P stelde zeven omdat PHP en Apache soort zorg voor sommige
van deze dingen voor u.
In PHP, kunt u de standaard overschrijven gedrag door het schrijven van uw eigen headers.
Maar voor de toepassing van deze, krijgen we om onze eigen headers uit te schrijven.
>> Dus betekent dat lijn zin om iedereen, de schrijfkop lijn?
OK.
Geweldig.
>> Dus dan wat ik doe is dat ik het einde van de respons door wereld zeggen hallo.
OK.
Maar dat is slechts een functie riep behandelaar.
Dus nu heb ik eigenlijk soort van doen iets met deze functie, toch?
>> Dus hier wat ik doe is er dit lijn die var server gelijken doet
HTTP.create server, en dan heb ik pas in de behandelaar.
Dus dit is een soort van de Node manier van het creëren van een server.
En merk op dat ik het passeren in het verzoek handler.
Dus dit is het vertellen van de createServer functie die ik wil dat je me een te maken
server, en als die server ontvangt een reactie, ik heb je nodig om dit te bellen
handlerfunctie vragen.
OK?
>> Dus die lijn vrij veel eindigt meteen.
Dus de var server lijn wordt recht gedaan nadat je dat vrij veel.
Ik bedoel, het is op te zetten een aantal interne staat om te weten dat je zou moeten
noem dat verzoek handler functie, maar het gaat niet om daar te zitten en
zeggen heeft de gebruiker gestuurd me nog een verzoek?
Heeft de gebruiker een verzoek stuurde me nog?
Zodat het niet blokkeren.
OK?
>> Dus wat dit zal doen, is het in principe slaat nu een verwijzing naar deze code,
deze aanvraag handler functie, en vervolgens zal die code uit te voeren wanneer iemand
een verzoek doet.
En dan doen we server.listen.
>> De 1337 is er vrij willekeurig.
Ik had geen bijzondere reden voor het kiezen dat nummer.
Het was totaal willekeurig.
Maar dat geeft de poort.
Dus de meeste webservers je zult zien dat ze Gebruik poort 80 want dat is een soort
van, zoals de conventie.
Dus als ik naar iets als, Ik weet het niet, Wikipedia.org,
en ik zet colon 8 -
oh wow, kun je niet zien dat.
Het spijt me.
Maar als ik dat doe Wikipedia -
Ik zal het hier schrijven gewoon zo dat het is duidelijk op de camera.
Maar als ik dit in een browser met een dubbele punt 80, die aangeeft naar
Wikipedia.org op poort 80.
Dus het is net hoe de Verenigde Staten heeft meerdere poorten als waar u kunt verzenden
dingen van de soort.
Dus het is net naar deze bijzondere Plaats op deze server.
OK.
>> Dus ik koos voor 1337.
Er is een hele reeks van getallen die je kunt kiezen.
Dat was niet helemaal speciaal.
>> Maar wat ik nu ga doen is Ik ga Node lopen.
Laat me daadwerkelijk in te voeren dat een paar lijnen naar beneden, zodat u het kunt zien.
Ik ga Node doen, en ik ben gaat simpler.js lopen.
En we praten over hoe je Node opgezet in een klein beetje.
Maar nu is het gewoon de server draait.
>> Dus een ding kunnen we proberen die al niet zijn dat spannender is kunnen we eigenlijk
proberen om toegang te krijgen in Curl.
Dus ik kan doen Curl, en mijn machine lokale host.
U ziet ook deze schriftelijke als dit soms.
Lokale host en 127.0.0.1 zijn soort van als uw computer thuis.
Dus het is als praten met uw eigen computer.
OK.
>> En dan kan ik zeggen 1337.
Dus als ik zonder deze lijn van code, het zegt hallo wereld.
En als ik wilde dat spul zien dat had content type tekst effen of
wat dan ook, ik kon zelfs dit hier plaatsen.
En merk op dat het zegt OK.
En ik heb wel tekst vlakte.
En dan is er soort van al die andere spul dat Node zal toevoegen in
er voor mij.
Dat is niet super belangrijk.
>> Ik bedoel, er zijn een soort van technische aspecten van de op dat soort zijn
van cool om over te praten, maar om te laten zien je, ik heb ook de bevoegdheid om
veranderen deze rond.
Dus ik kan gewoon voeg een stelletje van dat soort dingen.
En dan nu, als ik kijk in mijn uitvoer volgt dat.
Dus deze headers betekenen bepaalde dingen om browsers en dat soort dingen.
>> En headers kan in principe vertellen een browser hoe te reageren op iets.
Als je ooit hebt gehoord van cookies voor, of als je ooit geïrriteerd bent geweest
door een webpagina instellen van cookies, of aangezet koekje blok of
zoiets.
Je kunt eigenlijk stellen cookies in deze headers.
Dus ze vertellen een browser hoe gedrag in sommige gevallen.
OK.
>> Dus dat was simpler.js.
Heeft iemand enig vragen op dat broncode bestand?
OK.
Cool.
>> Dus laten we verwijderen de r uit dat en kijk naar simple.js.
Dus dit is vrij veel hetzelfde programma.
Ik schreef het een beetje anders want ik wilde om te sorteren van highlight
sommige functies van JavaScript.
>> Dus merken dat de behandelaar functie is totaal verdwenen.
Oh ja, heb je een vraag?
>> PUBLIEK: Ja, de argumenten die worden doorgegeven aan die
functie, wat zijn dat?
>> KEVIN SCHMID: Dus dat zijn JavaScript-objecten.
In de Node.js documentatie het zegt eigenlijk wat methoden zijn
op hen.
We toevallig de toegang tot deze methode genaamd schrijfkop en einde
en dat soort dingen.
Maar er is een hele hoop meer methodes.
>> En bijvoorbeeld, als een van hen in het bijzonder op rec, kunt u doen
iets als rec.method die zal u vertellen of het een HTTP te krijgen of
HTTP POST verzoeken en dat soort dingen.
Dus er is allerlei verschillende eigenschappen, maar ze zijn allebei
JavaScript-objecten, en ze hebben net functies verbonden aan hen die je
kunnen dingen schrijven.
OK?
>> Zo merken dat verzoek handler is volledig verdwenen.
Maar de code die ik had in het verzoek handler is er nog steeds.
Ik heb nog steeds deze res.writeHead en ik heb nog deze res.end.
En wat dit is een voorbeeld van in Javascript is dit idee van een
anonieme functie.
en anoniem is als een passende naam voor omdat het doet letterlijk niet
hebben een naam.
Er is geen functie verzoek handler daar.
>> Heeft geen naam, maar het nog steeds is het nemen van een argument.
Dus ik heb nog rec en res.
En ik heb nog steeds de code.
Dit is prima JavaScript-code.
Dus ik kan een functie verklaren zonder expliciet een naam te geven.
Het is een beetje verwarrend in het begin.
Er zijn een aantal als nuttige dingen dat je kunt doen met
Deze anonieme functies.
Heeft iemand enig vragen over dit, of is het OK gewoon om, voor nu,
soort van gewoon accepteren dat het zal hetzelfde doen?
Yep?
>> Publiek: Zijn functies eerst klasse in JavaScript?
>> KEVIN SCHMID: Ze zijn in de eerste klasse in JavaScript.
En weet gewoon dat deze begrippen passeren in een anonieme functie als
dit toepassen op de JavaScript dat u kan schrijven in uw uiteindelijke project voor
de webbrowser ook.
Dus bijvoorbeeld in de JavaScript uw browser, het is ook een beetje evenement
gedreven in de zin dat wat je zult hebben is wanneer de gebruiker deze klikt
knop, ik wil dat je deze code uitvoert.
>> Dus het is het zelfde soort ideeën van de client-side als een muisklik of ze
muis over enkele afbeelding op uw webpagina, voer deze code.
Die kan worden toegepast op servers.
Dus dat is net zoiets als de spannende reden waarom is JavaScript een echt
geschikt of sommige mensen denken dat het een geschikte taal voor dit soort
evenement driver server omdat je Deze anonieme functies.
Je hebt het hele idee van deze asynchrone code.
OK.
Iemand nog vragen?
>> OK.
Dus dat was simple.js.
Dus laten we eens kijken naar een meer of een paar meer.
Dus dit is sleep.js.
Dus is er iemand bekend met de C-functie slaap?
Van misschien een van de eerdere lezingen of iets dergelijks?
>> Dus eigenlijk kan passeren denk ik een aantal seconden of als je gebruik maakt U
slapen een aantal milliseconden of nanoseconden.
En eigenlijk het programma zal gewoon stoppen lopen voor die tijd.
Rechts?
En dan zal het uiteindelijk wakker en dan zal het gewoon blijven draaien
het programma.
>> Dus deze server soort geeft de indruk van slapen.
Dus merken dat we dezelfde res.writeHead 200 met de header als
voor, maar dan zijn we dit roepen functie genaamd set timeout.
Stel timeout is ook beschikbaar in uw webbrowser Google Chrome
of Safari of wat dan ook.
En eigenlijk wat het hier doet is dat het nemen van een functie.
Let op, nogmaals, het is een anonieme functie.
Dus dat is wel cool omdat we met behulp van een anonieme functie binnen een
anonieme functie die kan een beetje raar.
>> Maar het nemen van die functie, die eigenlijk te zeggen - en de manier waarop deze
werken is in 5000 milliseconden, ik wil dat je die functie uit te voeren die
net eindigt de reactie en schrijft hey.
Dus dit geeft de indruk van dergelijke slapen, maar de manier waarop deze daadwerkelijk
werkt is gaan we lopen door deze lijn zeer snel.
We zijn net iets te schrijven.
En dan zullen we ook doorlopen deze lijn zeer snel.
Dus we eigenlijk niet gaan vijf seconden wachten.
We gaan gewoon lopen deze code onmiddellijk.
>> En dan is er, nogmaals, deze kleine gebeurtenis lus die nu heeft dit ding
registers die in principe slechts voortdurend rond te gaan in een cirkel
en kijken naar de klok in een enkele draad en het zeggen, heeft vijf seconden
nog niet geslaagd?
En dan wanneer het ziet dat de tweede de hand heeft bewoog als vijf seconden of
wat dan ook, dan is het wakker wordt en zegt: oh, wat moet ik doen?
Oh ik moet deze code uitvoert.
En dan gaat lopen res.end hey.
>> Dus nogmaals, we hier nooit te wachten.
Dus het is niet dat deze code binnenkant van deze functie zal vijf nemen
seconden lopen.
Deze code zal vrij veel draaien ogenblikkelijk, althans ten opzichte
de vijf seconden dat we aan het praten waren over vroeger eerder.
>> Dus gewoon om dit in actie te laten zien, Ik kan doen Node.sleep.js.
En heb ik verknoeien iets?
Mogelijk.
Sorry.
Laten we eens kijken wat we kunnen doen om dit op te lossen.
OK.
Dus zeker gebruiken Node.js.
Ik maak maar een grapje.
OK.
Slechts een sec.
OK.
Ik weet wat het is.
>> Dus het probleem is dat in mijn andere tab hier was ik actief Node al op
dat hetzelfde adres, 1337.
Dus de fout die deze gooide, als we kijken in het echt nauw, is het adres in
gebruiken, EADDRINUSE.
Dus ik was al gebruik van 1337 hier.
Dus als ik sluit deze af, en dan heb ik nu probeer dit uitvoeren, hopelijk, alles
komt goed.
OK.
Dus je kunt maar een ding soort van het luisteren op een poort in een keer.
Een andere oplossing zou zijn geweest voor mij om alleen te bewerken dat programma en maak
het zijn als 1338 of zoiets als dat.
>> Maar nu slaap loopt.
Dus laten we eigenlijk proberen het uit in de browser dit keer, want het is een
beetje saaie om te zien in een terminal.
Dus ik ga gewoon naar die 127-adres weer op 1337.
En als je het kan zien -
Ik weet niet of je kunt - maar mijn browser van het nemen van een zeer, zeer lange
tijd om te laden of als vijf seconden.
>> En dan na dat, het eindelijk eindigde de respons.
En je kunt het niet zien, omdat de zaak wordt bewogen over een beetje, maar als ik
dit een beetje kleiner, je ziet het zegt he.
Dus ik heb de hey, maar na vijf seconden.
En het zou een beetje schoner zijn om te zien het hier op de terminal, dus ik ben
gaan naar een doen -
laten we hier -
laten we Curl dat adres opnieuw met de 1337.
En ik gewoon een soort moet zitten hier vijf seconden.
Maar merk op dat de server kunnen nieuwe antwoorden accepteren.
Drukt het zo hey.
>> En om deze demo, eigenlijk wat Ik kan doen in deze andere tab -
dus laten we zeggen dat ik dit doen in een ander tabblad, Ik ga Krul en hetzelfde te doen
nogmaals ding.
En ik ga proberen om deze kick jongens af op hetzelfde moment.
Dus ik ga dit doen, en ik ben gaat hier dan om te racen en ik ben
gaan om het opnieuw te doen.
>> En laten we het zo maken dat je kunnen beiden zien.
Dat een gedrukte hey en dat een afgedrukt hey helemaal aan -
laten we het nog een keer doen dat experiment.
Eigenlijk, laten we gebruik deze truc, als dat is OK.
>> Dus ik ga een shell ding gebruiken kan ik in principe lopen twee exemplaren
van dit programma in parallel.
Dus het zal het eerste programma uit te voeren en het tweede programma in parallel.
Dus nu als ik op Enter drukt, gaat het op dat verzoek vrij veel te maken
diens tegelijkertijd.
Dus laten we dit een schot.
>> Dus nu merken dat zegt twee processen.
En als je nieuwsgierig bent, dat 27.000 nummer is in feite het proces ID.
En dan merken ze gedrukt hey tegelijkertijd.
Het was niet zoals we moesten wachten vijf seconden voor een en dan daarna,
vijf seconden later krijgen de tweede.
Dus dat is een soort van, in sommige opzichten, het is niet echt bewijzen, maar het is
intuïtief bewijs dat het niet alleen als vijf seconden te wachten en het blokkeren
de hele thread.
OK cool.
>> Dus vroeg Aaron een vraag eerder dat was, tja, wat als we iets doen -
Yep?
>> PUBLIEK: Wacht.
Hoe is dat anders dan printf buffer, hoewel?
Niet automatisch dat doen?
Waarom hebben we zorgen over te maken?
>> KEVIN SCHMID: Oh, kon je zeggen dat nog een keer?
>> PUBLIEK: Houdt niet van printf buffer doen precies hetzelfde?
>> KEVIN SCHMID: De printf buffer?
>> PUBLIEK: Ja.
OK.
Was niet in een van de quizzen ze waren praten over hoe als je gelijk printf
iets en dan hebben deze te pauzeren een tweede, en dan heb je het lus tien
tijden, zal het tien seconden wachten en dan printf alles samen?
>> KEVIN SCHMID: Oh, OK.
>> PUBLIEK: Is het hetzelfde doen ding dan in dit geval?
>> KEVIN SCHMID: Dus de vraag was in principe in een van de voormalige quizzen
of iets, was er een vraag die eigenlijk als je zegt afdruk f 10
dingen tegelijk en dan sliep als in het proces van het afdrukken van die welke,
aan het eind een of andere reden, het zou dumpen die allemaal uit op het scherm.
Dus er is een soort van twee verschillende concepten hier.
>> Dus ik denk dat een ding is dat in dit geval, we te maken met twee verschillende
soort mensen de server te vragen voor dingen tegelijk.
En de reden dat de printf soort wacht als dat en dumpt het allemaal uit
tegelijkertijd is gerelateerd aan hoe printf soort -
dus de manier printf is eigenlijk geïmplementeerd is het heeft in feite neer op
praten om het besturingssysteem te schrijven dat spul op de console.
Zodat het niet willen doen dat allemaal spullen onmiddellijk wanneer je printf zeggen
een stukje tekst want dat kon krijgen duur als het moet
doe dat elke keer.
>> Dus als je printf hey, je programma misschien niet echt drukken dat
onmiddellijk naar de console.
Het zou kunnen zeggen, OK, schreef ik het.
En dan soort van wachten tot je geven het een beetje meer voordat daadwerkelijk
het uit te schrijven naar de console.
>> Dus de reden dat dat het geval was -
en het is een soort van niet-verwante om de slaap -
is dat de slaap was soort van gewoon geïnjecteerd daar aantonen de
feit dat het niet schrijven het synchroon.
Maar de reden daarvoor is gewoon prestaties, zodat je niet hoeft te
maken dat veel contacten het besturingssysteem.
>> Maar hier, wat we echt proberen te doen met deze slaap ding is gewoon tonen
dat wanneer we twee mensen een bezoek deze website, gaat het niet om te zetten
ze in een lijn waar het gaat om te zeggen Ik moet je helpen, en toen ben ik
helemaal klaar om je te helpen na deze vijf seconden, dan ga ik naar
verplaatsen naar de volgende persoon.
Dus het verzoek van de eerste persoon niet binden die gebeurtenis lus
als dat zinvol is.
>> Maar hier is eigenlijk een voorbeeld van iets dat zal binden
de gebeurtenis lus.
Dus hier is een verschrikkelijke functie om bereken de nde Fibonacci.
Het is letterlijk het erger manier kunt u bereken de n-de Fibonacci getal.
En dit is eigenlijk alleen maar te erkennen waar deze vandaan kwam,
Er is eigenlijk -
Ik bedoel, kan je proberen te gaan vinden - maar er is net een heel lange blog
plaatsen dat iemand schreef.
Het is als een van die Reddit dingen.
Maar iemand bekritiseerd Node.js, en ze gebruikte dit als voorbeeld.
Dus ik soort van wilde gewoon laten zien twee verschillende perspectieven alleen maar om
een algemeen begrip van de concepten achter deze twee dingen.
>> Maar dit wordt gekozen als gewoon een verschrikkelijk, vreselijk inefficiënt computationeel
intensieve manier om het te berekenen n-de Fibonacci getal.
Dus net als een kanttekening, waarom is het verschrikkelijk als op een bepaalde manier?
Yep?
>> PUBLIEK: Zeg je begint met 1000.
1000 splitst in 999 en 998.
Elk van deze splitst in twee dingen.
>> KEVIN SCHMID: Juist.
>> PUBLIEK: Helemaal naar beneden.
>> KEVIN SCHMID: Precies.
Dus gewoon te herhalen voor de camera, als ik roepen jokken op zoals 1000 of zoiets
als dat, het is natuurlijk niet minder dan of gelijk is aan een, dus ik ga
ga naar deze zaak anders, en dan ga ik te bellen jokken 999 plus jokken 998.
En dan vrijwel alle van die werk dat jokken 999 doet is
soort op dit niveau.
Als je naar beneden gaat, is het nog overbodig dan dat, maar als je gewoon
denk berekenen fib 998 krijgt ons vrij dicht bij jokken 999.
Dus moeten we eigenlijk een beetje meer slim over hoe we soort hergebruiken
deze, maar we zijn niet hergebruiken deze dingen helemaal.
Dus je kunt je voorstellen dit gigantische, gigantische boom dat is gewoon verschrikkelijk.
>> Maar goed, OK.
Dus dat was fib.
Het duurt gewoon een tijdje te lopen.
Yep?
>> PUBLIEK: [onverstaanbaar].
>> KEVIN SCHMID: Oh, kon je herhaal de vraag?
>> PUBLIEK: [onverstaanbaar].
>> KEVIN SCHMID: Oh dus dit is gewoon code dat gaat zijn soort op de
server-side.
Dus dit is niet van plan te vinden in de browser of iets.
Het is eigenlijk wat we hebben is dat wanneer de gebruiker hier vrij veel merken
opnieuw hun verzoek, toen we een soort van een verzoek, gaan we bellen
deze functie op de server.
En dan zullen we het resultaat terug te krijgen van het roepen van die functie.
En dan gaan we gewoon uitprinten het aan de gebruiker.
De gebruiker hoeft dus niet echt te gaan met deze functie te veel.
>> Was dat de vraag?
Is dat logisch?
OK.
Cool.
>> Dus nogmaals, we doen dit hele res.writeHead ding waar we uitprinten
de header.
En dan uiteindelijk ik het antwoord door te doen het magische getal is fib 45.
Dus laten we gewoon deze server draaien.
Dus ik ga een Node fib.js. doen
Dus nu mijn fib server draait.
>> En dan hier, ik ga een van deze doen.
OK?
Dus ik ga gewoon zeggen, Curl.
Dus het gaat een tijdje duren, maar hopelijk binnenkort zal eindigen en
het zal dat 45 afdrukken Fibonacci getal.
>> PUBLIEK: [onverstaanbaar].
>> KEVIN SCHMID: het moet gedaan te krijgen vrij snel.
Dus moet het 5-6 seconden duren.
Ik weet het niet, dat is gewoon V8 wordt super snel, maar in ieder geval is dit een
zeer kort voorbeeld en met opzet inelegant van een niet-triviale
berekening.
Dus na een tijdje, krijgt het dit.
>> Maar nu, wat als ik dat zelfde soort experiment als voorheen waar ik
twee verzoeken op hetzelfde moment?
Dus hier ga ik een Krul op dat adres, en ik ga
naar een andere Curl doen.
En vergeet niet, toen we dit voor de slapen server, toen hadden we het in principe
na vijf seconden, ze vrij veel beide kwam terug recht
rond dezelfde tijd.
Dus het was niet bijzonder vastgebonden.
>> Maar laten we nu proberen.
OK, dus we kregen onze twee processen.
Vergeet niet dat zijn de proces-id's.
Dit gaat om een ​​beetje onhandig terwijl we kraam.
Dus laten we gewoon hier blijven wachten.
>> Dus een van hen moet komen terug na zoals -
OK, dus je kwam terug.
Maar waarom dan niet de tweede een terug komen gewoon nog niet?
Yep?
>> Publiek: De server kan niets doen terwijl het berekenen van dat grote aantal.
>> KEVIN SCHMID: Juist.
Dus de reactie was alleen dat de server echt kan niets doen terwijl
het is het berekenen van dat Fibonacci getal.
Dus nu heb ik net mijn twee dingen terug.
Maar ik denk gewoon na te denken over de code een beetje meer, hoe het werkt
en alles.
>> Dus deze functie hier is de code die Ik heb deze server verteld worden uitgevoerd wanneer het
krijgt een nieuwe inkomende verzoeken.
Dus het is gewoon te lopen door deze hele code, en dan is het gaat om te gaan
terug naar het evenement lus en dan verder controleren op nieuwe gebeurtenissen.
Dus eigenlijk wat we hebben gebeurt is de server
luisteren naar nieuwe dingen.
De eerste persoon vraagt ​​wat 45 is.
We lopen deze code om het te berekenen.
Deze code duurt ongeveer vijf zes seconden draaien.
Dan gaan we terug naar het evenement lus en controleren op nieuwe aanvragen.
>> Dit is dus een voorbeeld van hoe als u hebben dingen die zogenaamde compute
gebonden, of gebruiken veel computationele, geen macht, maar net als zijn
rekenintensieve -
Ik denk dat een ding te zeggen over dit is dat deze functie volledig aan het doen is,
voor het grootste deel, mooie nuttig werk rechts.
De hele tijd dat die callback functie liep, was het vrij
veel het grootste deel van zijn tijd slechts computergebruik dat n Fibonacci getal.
>> Maar we hadden alleen een thread te behandelen.
In de Apache-model, als twee mensen maakte het verzoek om jokken 45, we
zou hebben gehad twee verschillende draden.
En dan de taak van het besturingssysteem zou zijn geweest, of het gebruikersniveau
code die de draden beheert, zou hebben geweest te snijden die op de
CPU, of zelfs als je meerdere CPU's gehad, verdeel ze gelijkmatig over de CPU's
zodat ze beiden afwerking ongeveer tegelijkertijd.
>> Dus gewoon om te laten zien hoe we kunnen sorteren van - en dit is niet een totaal perfect
oplossing, maar een soort van hoe we maak een kom hier terug en doen
een beetje beter.
Dus wat ik hier heb is een programma genaamd Fib C. En dit principe maakt gebruik van
een andere een van Node modules genoemd Het Kind Process Module.
Dus ik heb begrepen dat aan de top soort van als ik een pond zou doen onder
kind process.h of zoiets.
Nu heb ik toegang tot deze CP variabele die heeft al mijn functionaliteit.
>> Dus nu wat ik doe in deze reactie handler is Ik gebruik dit programma
dot slash fib 45.
Dus wat ik heb gedaan - en ik ben gewoon gaan uit te stappen van dit programma voor een
beetje -
is Ik heb een C-programma geschreven dat berekent in principe
n-de Fibonacci getal.
Dus hier is gewoon een programma dat ik heb geschreven in C dat berekent.
Ik kan het compileren, en ik kan lopen het op de opdrachtregel.
En het gaat berekenen de 45 Fibonacci getal.
>> Zo merkt het duurt slechts vrij veel zo lang.
Ik waarschijnlijk zou hebben gebruikt dash 03 tot optimaliseren of iets dergelijks,
maar ik deed gewoon als gewone compiler instellingen.
En het drukt het uit.
>> Maar nu, wat doe ik soort van doen?
Oh sorry, verkeerde bestand.
Dus ik doe hetzelfde spul met de kop als voorheen.
Dan doe ik dit cp.exec.
Dus wat dit gaat doen is dat het ga dit programma uit te voeren.
Maar de manier waarop dit werkt is dat het gaat niet om te wachten op
dat programma te voltooien.
Het zegt gewoon eigenlijk uitvoeren van dit programma.
Dit dus in principe typen in het opdrachtprompt soort.
>> En dan, als je klaar bent met het, lopen deze functie.
Dus nu we soort van krijgen geheel gerestaureerd zaak van
alsof we niet te wachten.
Betekent dat soort zinvol?
Yep?
>> PUBLIEK: [onverstaanbaar]?
>> KEVIN SCHMID: Dus dit ook daadwerkelijk het openen van een nieuw proces om het te doen.
Dus dit is eigenlijk, in sommige opzichten, kwaad, niet super kwaad, maar het is
belangrijk om te zeggen dat dit soort terug te gaan naar, enerzijds, de Apache
model waar we threads en processen doen voor elk verzoek of
werkwijzen voor elk verzoek.
Dus dit is een soort van analoog wat Apache doet.
In sommige gevallen, zal het alleen maar gebruik maken van een nieuwe draad, die een beetje meer licht
gewicht dan een proces, maar Apache kon uiteindelijk forking een nieuw proces
dat is een soort van wat we hier doen impliciet door het doen dot slash fib 45.
>> En dan in dat geval, we soort oplopen dezelfde kosten van processen.
Dus dit is slechts een ding dat je kunt doen.
Maar om dit soort lopende show.
En dit gesprek is gewoon echt gericht op presenteren van dit soort programma's als een
manier om verschillende perspectieven op tonen hoe servers zoals die ontwerpen.
Dus dit wordt uitgevoerd, en dan nu als ik dat doe dit nogmaals, ik heb twee proces-id's.
>> Laten we praten over dingen te wijzen.
Zo merken dat ze stapsgewijs.
Dat is cool.
Omdat het voor 27.122.
Maar merk nu, terug kwamen ze op ongeveer dezelfde tijd.
>> En nu, een goede vraag te stellen over waarom was dat het geval is, wiens taak
was het nu om een ​​soort van deze dingen soort van eerlijk spelen met elkaar
andere deze twee gevallen van dot slash fib 45 die ik liep
of dat Node liep?
Wie soort maakt het eerlijk dat ze beiden krijgen soort van evenwicht run time?
>> PUBLIEK: [onverstaanbaar].
>> KEVIN SCHMID: Yeah.
Dus eigenlijk, als ik dot slash fib 45 of iets dergelijks, nu is het
soort tot het besturingssysteem omgaan met de looptijd van deze programma's.
En nu kan het hen plannen op verschillende CPU of het
kan ze plannen.
Het kan snijden tot het moment dat een CPU krijgt het of dat ze
te draaien op een CPU.
Dus dat is het idee achter dat.
Is dat zinvol voor iedereen?
Dus nu Node is niet echt het spelen van een deel aan het verdelen van deze taken.
OK.
>> Dus dat is bijna het voor voorbeelden.
Ik wilde gewoon een ding laten zien omdat veel van deze is tot dusver
niet helemaal super praktische in sommige gevallen.
Ik kan me voorstellen thuiskomen na deze praten en iets en zeggen als,
Nou ik heb soort van uit dat gepraat dat Ik kan een Fibonacci-server maken
mijn afstudeerproject.
Dus hier is gewoon soort van een voorbeeld die hopelijk zal zijn -
misschien niet, maar misschien - een beetje meer soort relevant voor afstudeeropdrachten en
vooruit denken voor dat soort dingen.
>> Dus dit is chat.js.
Dus dit is een beetje zoals sommige monster server-side code die je zou kunnen gebruiken om
het opzetten van een klein praatje server zoals je misschien hebt gezien op de
Facebook Chat of wat dan ook.
Dus ik zeg niet dat dit is zoals Facebook Chat, maar dit is een soort van
als een goed - misschien niet goed, maar misschien goed - startpunt voor een praatje
server voor uw website voor een afstudeerproject.
Dus laten we eens kijken wat het doet.
>> Dus we krijgen deze bijzondere zaak aan de top, deze var SIO
gelijk vereisen Socket.IO.
Dus dit is een ander ding dat het niet eigenlijk komen gebundeld met
Node maar u kunt installeren.
Het is een Node module.
Dus het is net als sommige uitbreiding van het knooppunt in.
>> SocketIO is eigenlijk heel wel cool.
Het is een abstractie die eigenlijk wat het doet is is het u toestaat om
hebben dit communicatiestroom tussen een web
browser en een webserver.
Dus voor het grootste deel tot nu toe, hebben we gehad deze zeer snel een seconde of twee
tweede communicatie tussen een web browser en de webserver.
Dus het is eigenlijk ga naar google.com, get het spul, stuur het terug, en dan
we klaar zijn.
We zijn nooit meer praten totdat de types gebruiker in iets anders.
>> Maar wat Socket.IO en zelfde soort dingen - en SocketIO is eigenlijk een
van de dingen die is gebouwd op als WebSocket dat is een soort van beschikbare
als onderdeel van HTML5 -
waarmee u deze hebt permanente dialoog.
En dit is zeer nuttig in een chat-server soort dingen, want het is
als een soort van permanente dialoog in sommige opzichten, want als je aan het chatten bent
met iemand, kun je nu gewoon stuur bericht onderaan de pijp, en vervolgens de
server kan een bericht naar beneden het stuur pijp naar de andere persoon die je bent
chatten met.
En dan kun je deze hebt wisselen als dat.
>> Dus dat is een soort van wat SocketIO is goed voor.
De reden dat SocketIO gebruikt WebSockets als een ding dat
Naast gewoon oud WebSockets, het doet ook een aantal trucs om in principe
maken het browser compatible.
Dus browsers zoals Internet Explorer helaas geen ondersteuning voor WebSockets
recht uit de doos.
Gebruikt het dus een andere vorm van koele keurige dingen met Adobe Flash, zodat
om cross-browser ondersteuning.
Dus dat is echt nuttig.
>> En eigenlijk, ik weet dat ik ben een beetje op tijd rijden hier, maar CS50
Bespreken, heb je ooit iets gezien zoals, ik weet het niet, blanco zo en zo is
antwoord op dit bericht of iets als dat, die functie?
Dat is SocketIO.
Dus wanneer iemand begint te typen in het bespreken vak om een ​​antwoord of maken
iets, uw browser ondersteunt wat is genoemd in SocketIO zendt een soort van
geval dat zegt iemand is antwoord op dit bericht.
>> Dan zegt de server, OK, wat moet ik doen?
Nou nu moet ik die andere jongens vertellen die op CS50 Bespreek zoek
op deze post dat er iemand reageert.
Dus dat is een soort van wat SocketIO is goed voor, deze voortdurende soort
stroom van dialoog.
OK.
>> Dus wat ik hier heb - en we zijn gewoon gaan naar de aansluitingen serie negeren
voor een klein beetje -
wat ik doe is dat ik een ander luisteren.
Dus dat is gewoon de manier waarop in Socket.IO wordt zegt laten we luisteren op deze poort.
En dit doe ik op de verbinding.
Dus dat is gewoon eigenlijk Socket IO's manier om te zeggen, als we een ontvangen
verband wil ik u om deze code uit te voeren.
>> En merk op dat in plaats van rec en res doorgegeven daar heb ik Socket.
En dit Socket idee is in principe is deze ding dat je kunt schrijven en lezen
van die heeft de gebruiker berichten mogelijk.
En de berichten die u zou sturen kunnen gaan door die Socket.
Is dat logisch?
Dus het is deze voortdurende ding.
>> Dus wat ik doe is ik noem Socket.emit.
En stoten neemt vrij veel twee argumenten.
Het eerste argument is een string net vertegenwoordigen het type
wat je uitzendt.
Dus in dit geval, heb ik gebruik deze string nieuw bericht.
En dat is gewoon eigenlijk te zeggen dat de aard van dit ding, wat ik
verzenden, is een nieuw bericht.
Zo kunt u voor specifieke soorten luisteren als nieuw bericht of wat dan ook
met stip op.
>> Zo verbinding en gebruiker gestuurd daar, als je kijkt naar waar we noemen stip op,
dat zijn andere snaren die vertegenwoordigen soorten gebruikers berichten.
Het is dus in principe kun je deze uitstoten hebben een van deze boodschap typen en
dan is er iets te doen in reactie op een van deze boodschap typen
>> Dus ik ben emitting dit nieuwe bericht.
We gaan connections.push negeren voor een tweede.
Maar dan zeg ik, Socket.on gebruiker gestuurd.
Dus nu is het is net zoiets als wanneer de gebruiker stuurt me een bericht, ik wil
u deze code uitvoert.
En merk op dat die anonieme functie neemt in deze variabele
genaamd data die in feite gaat de boodschap van de gebruiker hebben.
>> Dus laten we nu soort gepraat over de aansluitingen array.
Dus dit is ontworpen voor een chat-client waar in principe iedereen is een beetje in
dezelfde chatroom.
Dus eigenlijk, wat we nodig hebben om te blijven rond is enkele array die in principe
vertegenwoordigt alle mensen chatten in sommige opzichten, als dat zinvol is.
Rechts?
Omdat we moeten weten wie die jongens zijn zo kunnen we ze de berichten te verzenden
dat andere mensen naar ons te sturen.
>> Dus wat deze code doet is wanneer de gebruiker stuurt een bericht - dat is de aard van de
het evenement -
we gaan deze code uitvoert.
En wat we doen is dat we lopen door deze array die we connecties hebben genoemd.
En vrijwel voor elke verbinding behalve degene die is van ons, dat is
wat deze code zegt, sturen we een nieuwe bericht met dat bijgevoegde bericht
gegevens.
>> Dus als je hier ziet, wat ik deed toen de gebruiker in feite maakt een nieuwe
verbinding is ik heb toegevoegd met de JavaScript.push methode, dit
eigenlijk gewoon zeggen als toe te voegen dat Socket als waarde in
onze connecties array.
Dus nu wanneer deze code wordt uitgevoerd, zal het dingen te sturen naar die bijzondere
verbindingen.
Dus dit kan een goed uitgangspunt zijn voor het maken van een praatje server
of iets dergelijks.
>> En de aard van de koele ding is dat de code die u ziet hier voor zoals op-en
uitstoten en dat soort dingen is hetzelfde soort van JavaScript-code die je zou
schrijven in de browser te interageren met de server.
Dus dat is de reden waarom SocketIO is een soort van netjes en bruikbaar op die manier.
>> Oh en nog een ding echt snel.
Er was een CS50 afstudeerproject vorig jaar dat in principe uitgevoerd een praatje
server in Node.js.
Ik denk dat het Harvardchats.org maar ik ben niet -
OK.
Ik weet niet zeker wat de URL is, maar Ik kan achteraf sturen dat uit.
Maar het is wel cool wat je kunt doen met Node.js.
>> Dus ik hoop dat, in het algemeen, hebben jullie een goed gevoel van wat Node.js is nuttig
voor en hoe je zou misschien van toepassing om je afstudeerproject.
Ik zal sturen wat meer middelen samen met deze.
En dank u voor uw komst.
Dank u.
>> [Applaus]