>> KEVIN SCHMID: Olá a todos.
Bem-vindo ao seminário CS50 em Node.js.
Meu nome é Kevin.
Eu sou um TF CS50.
E eu sou uma espécie de como realmente animado sobre este seminário.
Acho Node.js é muito legal.
Espero que este seminário podem ser usados como uma boa, eu acho, trampolim para
alguns de seus projetos finais, se você está interessado em usar
algo como Node.js.
>> Vamos espécie de iniciar o seminário fora por falando apenas de um pouco do
tipo de escalabilidade fundo perspectivas de Node.js e, em seguida
vamos passar a alguns exemplos de código.
E eu vou ter o código em um site, e você pode olhar para o código.
E após o seminário, eu vou tipo de conversa sobre como você pode configurar o Node.js
em seu computador.
>> OK.
Então, vamos começar.
Então, eu acho que eu só quero falar sobre servidores web, de verdade, pela primeira vez.
E para começar essa discussão, têm basicamente um diagrama que é de
o livro didático utilizado para CS61, que basicamente mostra a interacção
entre um processo cliente, como o seu web browser ou como o seu cliente alvo ou
algo parecido, e um servidor web.
Portanto, este tipo de parecido com o imagem que você viu na palestra sobre
Quarta-feira, onde, basicamente, temos alguns processo do cliente, como o Google Chrome.
>> E, em seguida, o primeiro passo é a cliente envia uma solicitação.
Então isso pode ser algo como Bem, vamos visitar, eu não sei, CS50.net.
Então, nós emitir esse pedido.
E será que alguém se lembra do nome do o protocolo que especifica como que
pedido deve ser estruturada?
Yep.
>> AUDIÊNCIA: [inaudível].
>> KEVIN SCHMID: Exatamente.
Então, é como HTTP, certo?
Então, basicamente, a especificação de como esse pedido deve realmente ser estabelecidas
fora, porque no fim do dia, esse pedido é realmente apenas como um
string que basicamente diz que eu quero isso.
E a especificação para isso é HTTP.
Então, isso é como um protocolo.
>> Então o servidor recebe esse pedido.
Então, vocês têm um servidor web instalado no aparelho CS50.
É Apache.
E esta semana, quando você trabalha em problema definir sete, você vai realmente estar trabalhando
com o servidor web.
Então, o servidor recebe o pedido, e então ele tem uma espécie de arranhar sua
cabeça e dizer, como bem o que eu faço com isso?
>> Assim, com base no que ele decide fazer, em seguida, pode entrar em contato com algum tipo
de recurso.
E esse recurso pode ser um monte de coisas diferentes.
Por um lado, pode ser apenas como um arquivo HTML estático.
Assim, poderia ser como alguns HTML que é como para
seu site pessoal.
Pode ser um arquivo estático como uma imagem ou como um filme que você tem.
Poderia até ter que falar a algum tipo de banco de dados
como um banco de dados MySQL.
Por isso, nem sempre tem de se comunicar com um recurso, mas em
alguns casos, poderia.
>> Então o que ele vai fazer depois disso é que vai
enviar de volta a resposta.
E a resposta para isso é também especificado por HTTP.
Então o cliente pode receber.
Ele pode rasgá-la e processá-la.
E então você tem uma página web como o Google ou CS50.net ou
tudo o que você foi.
OK?
>> Portanto, esta é a interação básica que vamos estar lidando.
E nós estamos muito bonito vai ser focar esta parte do
interacção, o servidor.
OK.
Legal.
Alguém tem alguma pergunta?
OK.
>> Então, como dissemos, o servidor web recebe esta solicitação HTTP e, em seguida, emite o presente
Resposta HTTP.
E, como falamos antes, o Servidor web aparelho CS50 é o Apache.
Então, quando vocês trabalham em P definir sete, você vai estar trabalhando com o
Um servidor Apache.
Você nunca vai ter que realmente funcionam com Apache diretamente demais.
Você espécie de configurar o Apache um pouco quando você especificar os hosts virtuais ou
os anfitriões v, e nós vamos chegar para que, em um pouco.
>> Mas, basicamente, o servidor web Apache configurado para funcionar com o tipo PHP
de fora da caixa.
Então, o que realmente acontece é que quando você vai a um de seus sites, como, por exemplo,
index.php barra locais de acolhimento ou algo assim, é o seu navegador envia que
pedido, e, em seguida, o Apache está sentado lá e descobre que fazer com ele.
E a ação é executar esse código no index.php e
em seguida, enviá-lo de volta.
Portanto, não é isso.
Então nós meio que conversamos sobre isso.
Assim, poderia servir apenas um arquivo estático ou executar algum código PHP e, em seguida, questão
a resposta.
>> Então uma pergunta comum que pode vir se é assim, como é que vamos realmente lidam
com ter vários usuários ao mesmo tempo?
Então, imagine se você estivesse escrevendo uma web servidor, se você tivesse um servidor web que
que estava a tentar escrever em algo como C ou algo assim,
basicamente, você pode pensar sobre como lá poderia ser algum tipo de código que
iria receber o pedido, mas, em seguida, ele tem que fazer todo esse trabalho sobre ele.
Ele pode ter, por exemplo, contactar o banco de dados ou algo parecido.
Certo?
E então ele iria fazer esse tipo de processamento e, em seguida,
enviado de volta a resposta.
Então, isso é como a alta visão geral nível.
>> Mas não é imediatamente óbvio como você pode fazer isso de modo que duas pessoas ou
até 1.000 pessoas poderiam trabalhar com o seu servidor web, ao mesmo tempo.
Portanto, a solução que o Apache usa é chamado de fios ou processos.
Então você pode ter ouvido de estes termos antes.
Tudo bem se você não tem, mas só acho que cerca de threads ou processos como formas de
um sistema operacional ou um programa de usuário ou algo assim ou um servidor web
a sorte de executar múltiplas coisas ao mesmo tempo.
Assim, você pode ter ouvido o termo como fios de execução.
Então é meio como se estivesse tipo de multitarefa.
>> E se você já viu na caixa do seu laptop, ou algo parecido,
multicore, o que você pode fazer é que você pode executar duas threads diferentes em diferentes
partes do processador de modo que possam na verdade, ocorrem ao mesmo tempo.
Portanto, esta é realmente poderoso.
E este é o tipo de Apache do solução para este problema.
>> Então, há mais ou menos como qualquer questão com esta abordagem embora?
Então eu acho que eu meio que escreveu-los lá.
Mas ambos tipo de usar um monte de memória.
É muito caro para criar um fio ou um processo.
>> E parte da razão é que apenas como quando você está executando um programa C
como o seu principal e, em seguida, que as chamadas uma outra função, que tem
algum tipo de pilha.
Então tópicos também exigem um inteiramente pilha separada que
pode ser muito grande.
E se você pode imaginar ter de toneladas de usuários em seu site, você teria
um monte de diferentes threads.
Isso é um monte de pilhas para gerenciar e manter.
Por isso, é grande o consumo de memória.
>> E então, também, digamos que você só tem uma CPU, ou vamos dizer que você tem
mais segmentos do que você tem esses multicores.
Certo?
Então, digamos que você tivesse 10 tópicos e você só tinha cinco CPUs.
Você meio que tem que fazer essa coisa onde você alternar entre a corrente
aquele que está correndo, porque você não pode executar todos os 10 de uma só vez.
E isso é chamado de mudança de contexto.
E esse termo realmente tem um casal de contextos diferentes, mas vamos
pense nisso como a mudança entre dois segmentos.
Isso pode ser muito caro, porque basicamente o que você tem a fazer é você
tem que parar o que está fazendo, salve o estado desse fio condutor, e
em seguida, mudar para outro lugar.
>> Assim que todo mundo tipo de ver o motivação do porquê de tópicos e
processos pode ser um pouco volumoso?
E você tem uma pergunta?
OK.
Legal.
Alguém tem alguma dúvida?
OK.
>> Então, se tomarmos um passo para trás por um segundo, não há como uma espécie de
observação que podemos fazer sobre uma grande quantidade de aplicações web.
E isso é realmente que muitos deles realmente não faço isso muito útil
trabalhar dentro de um segmento.
Então, tem alguém começou em P definir sete em tudo?
Então você quer para descrever talvez algumas das partes?
Você já trabalhou no login ou algo parecido?
>> AUDIÊNCIA: Não.
>> KEVIN SCHMID: OK.
Nunca mente.
Desculpe.
Mas, basicamente, no conjunto P, você está vai estar fazendo um monte de tipo de
consultas a um banco de dados para obter algum informações desse banco de dados.
E o que o código está indo fazer, o que esse processo Apache ou
esse segmento Apache vai estar fazendo ao mesmo tempo que tem de contactar o
banco de dados é que é uma espécie de vai ser sentado lá e vai ser
esperando o banco de dados para responder.
>> Agora que não pode soar como que um grande lidar, porque o banco de dados está em seu
Aparelho CS50, certo?
Mas existe algum tipo de rede latência lá porque agora a web
servidor tem que emitir o seu próprio pedido de a base de dados para comunicar com o
banco de dados e, em seguida, obter esse informações de volta.
Então, agora é como bem esperar por mim, eu sou indo para ir buscar alguma coisa do
banco de dados e, em seguida, há uma muita espera acontecendo.
Será que isso faz sentido?
>> E para algumas coisas, não é tão ruim assim.
Se ele só tem que, por exemplo, memória de acesso, que não é como
horrível I / O latência.
E quando eu digo, eu O latência /, o que eu sou referindo-se é como qualquer tipo como
de entrada e saída.
Mas para acessar um arquivo no disco, como se eu queria servir o HTML estático
arquivo que foi na minha página web ou algo assim, eu meio que tenho que
parar um pouco, ler esse arquivo em a partir do disco e, na
esse processo que eu estou esperando.
Eu não estou fazendo um trabalho útil.
>> Isso não é verdade de tudo, mas é comum em aplicações como o conjunto P
sete anos e um monte de aplicativos que você não é
realmente fazendo muito pensar.
E quando eu digo pensamento, eu quero dizer como o trabalho computacional.
Assim, o trabalho computacional poderia ser algo como, por exemplo, você queria
escrever um servidor web que apenas calculado o número de Fibonacci enésima.
Isso não soa como um particularmente servidor web divertido.
Como eu não esperaria que o local a ser o próximo Facebook, mas isso é um pouco
tipo de trabalho computacional.
>> E você pode imaginar que, com a substituição algum outro tipo de interessante
trabalho computacional.
Vamos dizer que você estava escrevendo algo que calculou os graus de
separação entre duas pessoas ou algo parecido.
Assim que envolve algum tipo de cálculo, certo?
E mesmo assim, para fazer isso você ainda tem para fazer um monte de espera para talvez
você tem que consultar um banco de dados para olhar até quem é amigo de quem ou
algo parecido.
Portanto, não há esse tipo de noção trabalho de computacional.
Será que isso faz sentido?
Alguém tem alguma dúvida?
>> Ah, e eu acho que eu colocar os servidores de bate-papo lá porque os servidores de bate-papo são uma espécie de
outro bom exemplo disso.
Um servidor de bate-papo não tem fazer muito pensar.
Ele só tem que esperar para que as pessoas enviar mensagens e, em seguida, quando
eles, enviá-los.
OK?
>> Então, só para recapitular novamente, Apache e servidores web semelhantes, como que um garfo
monte de segmentos e processos que pode ser tipo de desperdício.
Então eu acho que a questão que pode vir de que é que precisamos ter
vários segmentos e processos?
E se a gente só tinha um?
>> Então vamos espécie de pintar um quadro do que esta seria semelhante.
Então, vamos usar apenas um segmento.
OK?
Então, basta imaginar isso com um segmento.
>> Vamos supor que nós não estávamos realmente fazendo que muito útil - e quando eu digo
útil, quero dizer trabalho computacional -
nos vários segmentos antes.
Então vamos tipo de consolidar tudo em um segmento.
Então, o que se tivéssemos um thread que tipo de apenas dá a volta no circuito e
constantemente cheques fez algo novo acontecer.
Assim, por exemplo, algo novo aconteceu poderia dizer que eu tenho algo de volta de
o banco de dados, ou alguém enviado me uma nova solicitação HTTP.
Portanto, estas são o tipo de eventos isso acontecer, certo?
>> E então o que posso fazer quando os novos as coisas acontecem é neste mesmo segmento
da execução, este único segmento de execução, posso chamar um código que
iria lidar com essa coisa particular.
Assim, por exemplo, se eu tenho algo de volta do banco de dados, eu poderia executar o meu
pequena parte computacional do que na verdade, apenas prepara a coisa a
mandar de volta para o usuário.
O mesmo acontece com esse tipo de faz sentido?
>> Mas o que são realmente a implicações dessa?
Certo?
Porque nós escrevemos um monte de código que -
e eu só vou passar à frente nos slides se está tudo OK.
Então, se você não se importar, eu sou apenas vai dar um passo atrás.
Portanto, este tipo de coisa é chamado um ciclo de eventos.
OK?
E isso é o tipo de básico idéia por trás Node.js.
>> Então, o que está realmente fazendo Node.js como uma web servidor é que não há um único segmento
que é, basicamente, andando em um loop como um tempo um tipo de sob
o capô do Node.js é constantemente verificação, fez recebemos coisas novas?
E então ele será executado manipuladores que você configurou.
Mas uma boa pergunta a fazer é: como podemos fazer isso acontecer
com as coisas existentes?
>> Então eu coloquei uma linha de código C aqui que basicamente parece que está abrindo uma
arquivo, certo?
Eu Ela saiu apenas com um álbum.
Então eu tive que abrir a um novo arquivo.
Assim, a forma como o nosso código C para a operação -
e eu acho que a razão pela qual eu escolhi arquivos foi porque este é o tipo de medida
do trabalho I / O que temos feito em C em uma sensação de que há saída de entrada.
Então, nós chamamos isso de código que faz isso f aberta.
E, em seguida, na linha seguinte da nossa programa, podemos agora trabalhar com f.
>> Portanto, este seria um exemplo de algo que é como síncrona ou
bloqueando porque nessa primeira linha não estamos esperando até que
obter o arquivo aberto.
Então, na segunda linha, sabemos que pode trabalhar com f, mas isso significa que
que a segunda linha não pode realmente executar até que a primeira linha é feito.
Será que isso faz sentido?
>> Então, isso seria ruim para colocar em um manipulador de eventos.
E a razão para isso é que esse tipo de espera, certo?
Portanto, este seria revertido nos de volta a mesma coisa.
E agora nós não teria sequer a benefício de vários segmentos ou
processos porque temos um segmento em Node.js.
Isso faz sentido para todo mundo?
>> AUDIÊNCIA: Espere.
Então qual é o substituto?
>> KEVIN SCHMID: Ah, então sim.
Então, eu estou indo para obter a a substituição.
OK.
Então, o que se tivéssemos algo que ficou assim?
Então, o que se agora eu editei f abrir um pouco?
Então, eu estou passando o mesmo dois argumentos como antes.
Eu ainda amo a nova música que ela saiu com.
Mas eu estou passando uma terceira coisa que é esta variável chamada código.
>> Mas o que é o código de fato Neste contexto?
É como uma variável C regular?
É uma função, certo?
E isso pode ser um pouco estranho, porque Na verdade, estou como agora passando um
funcionar em outra função.
>> Assim, um par de coisas a notar sobre isso.
Um, eu não estou realmente chamando a função de código.
Então, você não vê o código com o parêntese esquerdo, parêntese direito.
Estou só de passagem no código.
E em C, o que isso realmente fazer é me dar um ponteiro para esse real
código, e então isso poderia executá-lo.
Mas basta pensar nisso como você está passando o código a ser executado quando
que arquivo é aberto.
>> Mas o que isto significa é que agora o resto do meu programa que poderia fazer
outras coisas, pode continuar a fazer outro coisas, enquanto nós, na verdade não esperar, mas
só tem na parte de trás de nossas cabeças que quando aberta, corrida daquele arquivo que
código na parte superior.
Será que isso faz sentido?
>> E agora, a idéia por trás do Node.js é que o código do material fazer com f
parte deve ser bastante curto e simples e simples e não ser realmente
muito computacionalmente intensivas.
Ele pode ter que abrir outro arquivo, mas que também deve ser muito rápido
porque deve apenas dizer fazer outra f abrir e, em seguida, chamar isso de outro código.
>> Então, só para ser completamente claro, o f que faz abrir a nova música de Katy Perry
done mp3, que vai muito muito retornar imediatamente.
E então nós podemos apenas continuar fazendo outras coisas, porque tudo o que agora f
concurso público faz é dizer basicamente o código aberto f subjacente abrir este arquivo
e quando estiver pronto abrir este arquivo ou quando você recebe de volta,
em seguida, executar esse código.
Mas ele realmente não executar esse código.
E você tinha uma pergunta?
>> AUDIÊNCIA: Você parecia implicar alguns vezes que a adição computacionalmente
código intensivo tipo de quebrar o [Inaudível] sistema orientado.
[Inaudível]?
>> KEVIN SCHMID: Essa é uma ótima pergunta.
Então, eu realmente tenho um exemplo de como você pode integrar computacionalmente
código intensivo em um pouco.
Assim, quando chegarmos aos exemplos de código, Eu vou ter a certeza de puxar essa.
Tudo bem?
Obrigado.
>> Qual era o seu nome?
>> AUDIÊNCIA: Aaron.
>> KEVIN SCHMID: Aaron traz uma muito bom ponto, o que é que se eu tivesse
algum código computacionalmente intensivo em as coisas ver com parte f, o resto da
meu programa não pode ser executado e não pode ouvir para os novos pedidos ou qualquer coisa até que tudo
esse material está terminado.
Então, se eu estou escrevendo código Node em geral a menos que façamos algo que eu vou
sugerir mais tarde, quando olhamos para o exemplos de código, eu tenho que ter certeza de que
meu código não amarrar este ciclo de eventos.
Será que isso faz sentido?
OK.
Legal.
>> Então Node.js oferece neste quadro que você pode construir estes evento dirigido
servidores com.
Por isso, tem este tipo de assíncrono non-blocking I / O bibliotecas, enquanto
as bibliotecas padrão C que temos sido trabalhando, como se você só
usá-los da mesma forma que nós temos de usá-los com f abre e
coisas, aqueles estão bloqueando porque você realmente tem que esperar
que arquivo para abrir.
>> Mas Node.js dá-lhe isso e basicamente laços em V8 do Google
JavaScript engine que é a razão que o Chrome é tão rápido em processamento
JavaScript porque tem este motor V8.
Então, eu sei que soa como um daqueles Conferências de desenvolvedores WWDC coisa
onde eles só jogar um monte de a número carta coisas para processadores
e dizer que isso é tão legal.
Mas é legal que eles fizeram isso porque JavaScript -
ou talvez se você não estiver familiarizado com JavaScript ainda porque não tivemos
as palestras sobre ele -
mas JavaScript é uma interpretação língua.
>> E este é um ponto importante também.
Portanto, é importante para o nosso web servidores para ser rápido, certo?
E se nós estávamos correndo JavaScript código que foi interpretado com apenas
qualquer intérprete de idade, pode ser lenta.
Benefícios Então Nó de ter este intérprete V8 super rápido.
E eu não sei se ela foi batizada como porque o tapa V8 na testa
coisa, mas OK.
>> Então eu preparei alguns exemplos neste URL.
Após o seminário, eu estou meio que vai falar sobre como você pode obter conjunto Nó
, mas, por enquanto, eu apenas uma espécie de querer para percorrer alguns exemplos de código.
Então, se você quiser acompanhar, todo o código fonte está disponível lá.
OK?
>> Então, eu vou deixar essa URL se para um pouco.
E então eu só vou exibir no terminal.
Está todo mundo bem com esta URL?
Então eu vou passar para meu terminal aqui.
>> Então, aqui está o código que Eu tenho para hoje.
Por que não começamos com simpler.js arquivo?
A outra coisa é que tudo isso código vai ser escrito em
JavaScript que você pode ou pode não estar familiarizado.
Eu acho que algumas coisas é que muitas de código JavaScript é o tipo de
sintaxe e estrutura é muito semelhante à C, de modo que você pode tipo de buscá-lo como
você vá junto.
Eu tentei escrever um monte de código de partida para isso de uma maneira que é
semelhante ao C de modo que seja um pouco mais legível.
Mas à medida que progredimos, eu vou estar demonstrando algumas das adicional
características do JavaScript que são legal.
>> Mas vamos olhar para este programa de exemplo.
Eu acho que tudo é cortado lá.
Eu só vou consertar isso de verdade rápido se está tudo OK ou não.
Eu não sei o que isso vai fazer.
Isso é um pouco melhor?
Você pode ver a var e coisas assim?
OK.
>> Assim, a primeira linha é como o JavaScript versão de uma variável
declaração.
Então, só para destacar o que isso seria parecer em C. Portanto, este é apenas como
Índice me dizendo é igual a três ou algo parecido.
Então, eu não especificar o tipo.
JavaScript tem tipos, mas é muito dinamicamente digitado na natureza, assim
não fornecer qualquer tipo de tipo sobre ele.
Então ele só tem var.
É como variável.
OK?
>> E eu estou chamando este HTTP variável.
E no meu lado direito, eu tenho a expressão que eu quero colocar em HTTP.
E isso diz exigir HTTP.
Portanto, esta é uma espécie de similar para incluir.
É um pouco mais como poderoso do que incluir, no sentido de incluir
seria apenas copie e cole o cabeçalho arquivo para os protótipos de função ou
seja o que for, com as definições de tipo.
Mas exigem que realmente está acontecendo para nos levar o código.
>> Assim, você pode pensar nisso como importação de alguns códigos.
Então, em algum lugar do módulo Node.js sistema ou qualquer outra coisa, eles têm tudo isso
Código do servidor HTTP para que eu sou apenas buscar isso para o meu próprio
uso pessoal neste programa.
OK?
>> Então eu tenho essa função que eu escrevi.
E note que eu não tenho que especificar o tipo de retorno ou o tipo de
argumentos novamente.
Assim, tipo de solto digitei que tipo de sentido.
Dois argumentos que leva em, o pedido e resposta.
Então, isso é conceitualmente tipo como familiar a partir da imagem que tínhamos
na tela antes porque temos esta solicitação que nós
ter do utilizador.
E então nós temos uma resposta que podemos escrever coisas.
>> Assim, a primeira linha deste faz res.writeHead 200 e, em seguida, esta
tipo de conteúdo de texto simples.
Então, vamos remendar este apart um pouco.
Então vamos focar res.write para um pouco.
Então escrever é basicamente, e escrever cabeça, são apenas maneiras de escrever uma espécie de fora
coisas para a resposta.
OK?
Então escreva cabeça, se alguém se lembra da palestra HTTP, é que vocês
lembrar cabeçalhos no topo da coisa HTTP?
Então por que não eu só demonstração cabeçalhos rápido.
Isso seria útil?
Ou devemos apenas uma espécie de -
OK.
Claro.
>> Então, quando o navegador vai para google.com ou algo parecido,
há realmente um pouco mais -
isto é como um segredo -
não há como um pouco mais de informação que vem através do tubo do que apenas
o pouco de pesquisa e tudo mais.
Então, para mostrar isso, eu vou para usar um programa chamado Curl.
OK?
Então, isso é algo que você pode executar em sua linha de comando Mac OSX ou no
aparelho ou o que seja.
E assim se eu Enrolar HTTP google.com, Eu vou ver o HTML.
E esta é, com justiça, apenas o HTML esse tipo de conta que você
redirecionar para www se o seu navegador não tem tratar automaticamente o
redirecionamento.
>> Portanto, esta é apenas HTML, mas eu vou adicionar para ondular este hífen Eu bandeira.
OK?
E isso vai mostrar me os cabeçalhos.
Portanto, esta é também a informação que vem através quando eu chegar esta resposta.
OK?
>> Assim, no topo, você vê isso HTTP 301 mover permanentemente.
E isso é importante porque o tipo de refere-se ao código de status.
Assim, o 301 aqui é o código de status, que é, basicamente, apenas um número inteiro
que informa ao navegador ou quem quer que esteja lendo isso, se você fingir que
você é um navegador e que você está vendo isso, basicamente agora se você olhar para
isso e você ver um 301, você sabe que eu tenho para fazer algo especial com base em
301, ou aconteceu algo especial com base na 301.
Então ele diz que mudou-se permanentemente.
>> E então, basicamente, temos um monte de pares de valores-chave.
Então, nós temos o local é www.google.com.
E, em seguida, tipo de todas essas outras coisas, mas, basicamente, o que o local é
provérbio é o novo local está em www.google.com.
Portanto, agora se você vai para google.com, você vai tipo de ver o tipo de navegador piscar
por um segundo e, em seguida, redirecioná-lo de volta para www.google.com.
Assim, as respostas podem conter esses cabeçalhos.
>> E um par de coisas a apontar.
Então, vamos dizer que estávamos realmente bem sucedida em visitar uma página web.
Então deixe-me ir para -
o que é um bom site?
Eu sou ruim no pensamento do bem sites no local.
>> AUDIÊNCIA: Wikipedia.
>> KEVIN SCHMID: OK.
Vamos fazer Wikipedia.
Então, aqui eu estava emocionado.
Oh wait.
Eu estava?
Sim, eu estava.
OK.
Então, eu tenho que fazer www.
Então, eu vou fazer www.
E como você pode ver, aqui está todo o HTML que o navegador iria processar
para a Wikipédia.
>> Mas se eu continuar rolando aqui em cima, o que eu vou ver no topo -
wow, há um monte de HTML na Wikipedia -
mas o que eu posso ver no topo aqui é este código 200 status como oposta à
301 que eu vi antes.
E note que ele tem um bom OK amigável ao lado dele.
Então, isso é como o bom código de status.
>> Será que 200 número parece familiar?
Sim, porque quando eu fiz simpler.js, Eu escrevi um 200 lá.
Então, que é basicamente dizendo contar a browser ou quem está tentando chegar ao
este que foram bem sucedidos.
Ou que tipo de como nós foram bem-sucedidos também.
>> E não há este tipo de sintaxe especial em Javascript para declarar uma
mapa destas chaves, como tipo de conteúdo e esses valores como texto simples.
Então, se você olhar para a resposta que nós voltei da Wikipedia antes, -
Vou tentar rolar até um pouco mais rápido -
você tem essas chaves como servidor e estes valores Apache.
Então você tem as chaves e valores.
E você pode especificar isso em Nó o que enviar de volta.
>> Portanto, esta é, na verdade, meio que, em alguns caminhos, e em alguns aspectos, não é
realmente, mas é um pouco mais baixo nível do que o código PHP que você pode ser
escrever para P definir sete porque PHP e Apache tipo de cuidar de alguns
dessas coisas para você.
No PHP, você pode substituir o padrão comportamento escrevendo seus próprios cabeçalhos.
Mas, para os fins do presente, temos para escrever nossos próprios cabeçalhos.
>> Então, isso linha faz sentido todos, a linha da cabeça de gravação?
OK.
Incrível.
>> Então o que eu faço é acabar com a resposta dizendo Olá mundo.
OK.
Mas isso é apenas uma função chamado manipulador de solicitação.
Então, agora eu realmente tenho que tipo de fazer algo com essa função, certo?
>> Então, aqui o que eu faço é que há esta linha que faz iguais servidor var
HTTP.create servidor, e então eu passar no manipulador de solicitação.
Portanto, este é o tipo de nó forma de realização de um servidor.
E note que eu estou passando no manipulador de solicitação.
Então, isso está dizendo a createServer função que eu quero que você me faça uma
servidor, e quando esse servidor recebe uma resposta, eu preciso de você para chamar este
solicitar função de manipulador.
OK?
>> Assim que a linha praticamente termina imediatamente.
Assim, a linha de servidores var é bem feito depois você faz isso muito bem.
Quero dizer, tem que configurar algum interno estado para saber que você teria que
chamar essa função manipulador de solicitações, mas ele não vai se sentar lá e
digamos que o usuário tem enviado me um pedido ainda?
Será que o usuário me enviou um pedido ainda?
Por isso, não bloquear.
OK?
>> Então, o que isto vai fazer é, basicamente, agora armazena um ponteiro para este código,
esta função de manipulador de solicitação, e, em seguida, irá executar esse código, quando alguém
faz um pedido.
E então nós fazemos server.listen.
>> O 1337 não é muito arbitrária.
Eu não tinha nenhuma razão especial para escolher esse número.
Foi totalmente aleatório.
Mas isso só especifica a porta.
Assim, a maioria dos servidores web que você vai ver que eles usar a porta 80, pois esse é o tipo
de como a convenção.
Então, se eu for para algo como: Eu não sei, Wikipedia.org,
e eu coloquei dois pontos 8 -
oh wow, você não pode ver isso.
Sinto muito.
Mas se eu fizer Wikipedia -
Vou escrever aqui apenas para que fica claro na câmara.
Mas se eu levar isso em um navegador com dois pontos de 80, que especifica ir para
Wikipedia.org na porta 80.
Então, é como como os Estados Unidos tem várias portas, como onde você pode enviar
as coisas a meio.
Então, é como ir a este particular colocar no servidor.
OK.
>> Então, eu só escolhi 1337.
Há toda uma série de números que você pode escolher.
Isso não foi totalmente especial.
>> Mas o que eu vou fazer agora é que eu vou correr Node.
Deixe-me realmente entrar que um casal linhas para baixo para que você possa vê-lo.
Eu vou fazer Node, e estou vai executar simpler.js.
E vamos falar sobre como obter Nó criado em um pouco.
Mas agora é só executar o servidor.
>> Então, uma coisa que pode tentar o que não pode ser tão excitante é que podemos realmente
tentar acessá-lo em Curl.
Então eu posso fazer Curl, e minha máquina é host local.
Você também vai ver isso escrito assim às vezes.
Hospedeiro e 127.0.0.1 local são uma espécie de como o seu computador de casa.
Então, é como falar com seu próprio computador.
OK.
>> E então eu posso dizer que 1337.
Então, se eu executar esta linha de código, ele diz Olá mundo.
E se eu queria ver esse material que tinha texto simples ou tipo de conteúdo
seja o que for, eu poderia até mesmo colocar isso aqui.
E note que ele diz OK.
E eu tenho de texto simples.
E depois há o tipo de todas essas outras coisas que Node vai acrescentar em
lá para mim.
Isso não é super importante.
>> Quero dizer, há algum tipo de técnico aspectos em que são uma espécie
de legal para falar, mas apenas para mostrar você, eu também tenho o poder de
alterá-las por perto.
Então eu só posso adicionar um monte de coisas assim.
E então agora, se eu olhar na minha de saída, será que.
Então, esses cabeçalhos dizer certas coisas para navegadores e coisas assim.
>> E cabeçalhos pode basicamente dizer um navegador como responder a alguma coisa.
Se você já ouviu falar de cookies antes, ou se você já esteve irritado
por uma página web criação cookies, ou ligado bloco cookie ou
algo parecido.
Você pode realmente definir cookies nestes cabeçalhos.
Então, eles dizem um navegador como comportamento em alguns casos.
OK.
>> Assim que foi simpler.js.
Alguém tem alguma dúvida em que arquivo de código fonte?
OK.
Legal.
>> Portanto, vamos remover o r de que e olhar para simple.js.
Então, isso é muito bonito o mesmo programa.
Eu só escrevi um pouco diferente porque eu queria resolver de destaque
algumas características do JavaScript.
>> Então, observe que o manipulador de solicitação função tenha totalmente desaparecido.
Ah sim, se você tem alguma pergunta?
>> Audiência: Sim, os argumentos que são passadas para o
função, o que são?
>> KEVIN SCHMID: Portanto, estas são JavaScript objetos.
Na documentação do Node.js, ele basicamente diz que métodos são
disponível sobre eles.
Nós só acontecerá a ter o acesso a este método chamado de cabeça de gravação e final
e coisas assim.
Mas há um grupo inteiro mais métodos.
>> E por exemplo, como um deles em particular, sobre rec, você pode fazer
algo como rec.method que será dizer-lhe se é um HTTP GET ou
Solicitações HTTP POST e coisas assim.
Portanto, há todos os tipos de diferente propriedades, mas eles são ambos
JavaScript objetos, e eles só têm funções que lhes são inerentes que
pode escrever coisas.
OK?
>> Então percebe que manipulador de solicitações é totalmente desaparecido.
Mas o código que eu tinha em pedido manipulador ainda está lá.
Eu ainda tenho esse res.writeHead e ainda tenho este res.end.
E que este é um exemplo de em JavaScript é a idéia de um
função anônima.
e anônimo é como um nome apropriado para ele, porque, literalmente, não faz
ter um nome.
Não há solicitação de função manipulador de lá.
>> Não tem nome, mas ainda é tomar um argumento.
Então eu ainda tenho rec e res.
E eu ainda tenho o código.
Isso é perfeitamente normal O código JavaScript.
Então, eu posso declarar uma função sem explicitamente dando-lhe um nome.
É um pouco confuso no início.
Há algumas coisas úteis, como que você pode fazer com
estas funções anônimas.
Alguém tem alguma dúvida sobre isso, ou é OK apenas para, por ora,
tipo de simplesmente aceitar que ele vai fazer a mesma coisa?
Yep?
>> AUDIÊNCIA: primeiro são funções classe em JavaScript?
>> KEVIN SCHMID: Eles são os primeiros classe em JavaScript.
E só sei que estes conceitos de passando em uma função anônima como
isso se aplica ao JavaScript que você pode escrever em seu projeto final para
o navegador web também.
Assim, por exemplo, no JavaScript seu navegador, é também um pouco do evento
dirigido no sentido de que o que você vai tem é quando o usuário clica neste
botão, eu quero que você executar este código.
>> Então, é o mesmo tipo de idéias da lado do cliente quando um clique do mouse ou eles
mouse sobre alguma imagem em seu página web, executar este código.
Isso pode se aplicar a servidores.
Então, isso é mais ou menos como o emocionante razão pela qual JavaScript é realmente um
pessoas adequadas ou alguns pensam que é uma linguagem adequada para este tipo de
servidor motorista evento, porque você tem estas funções anônimas.
Você tem toda a idéia de este código assíncrono.
OK.
Alguém tem alguma dúvida?
>> OK.
Assim que foi simple.js.
Então, vamos olhar para mais uma ou mais um par.
Portanto, esta é sleep.js.
Então é alguém familiarizado com a função dormir C?
De talvez uma das palestras anteriores ou algo parecido?
>> Então, basicamente, você pode passar em Eu acho que um número de segundos ou se você estiver usando U
dormir um número de milissegundos ou nanosegundos.
E, basicamente, o programa só irá parar correndo para a mesma quantidade de tempo.
Certo?
E então ele vai acordar e, eventualmente, em seguida, ele vai apenas continuar executando
o programa.
>> Portanto, este tipo de servidor dá a impressão de dormir.
Então, observe que temos o mesmo res.writeHead 200 com o cabeçalho
antes, mas, em seguida, nós estamos chamando esta função chamada set timeout.
Definir tempo de espera também está disponível em seu navegador Google Chrome
ou o Safari ou o que seja.
E, basicamente, o que está fazendo aqui se ele está tomando em uma função.
Observe, novamente, é uma função anônima.
Então, isso é bem legal porque estamos usando uma função anônima dentro de uma
função anônima que pode ser um pouco estranho.
>> Mas ele está tomando essa função, que é basicamente dizendo - e da forma como este
obras é em 5.000 milissegundos, eu quero que você execute essa função que
apenas termina a resposta e grava hey.
Então, isso dá a impressão de como dormindo, mas a forma como isso realmente
funciona é que vamos percorrer esta linha muito rapidamente.
Nós apenas estamos escrevendo algo.
E então nós também vamos percorrer esta linha muito rapidamente.
Portanto, não estamos realmente indo esperar cinco segundos.
Nós apenas estamos indo para executar este código instantaneamente.
>> E depois há, mais uma vez, este pequeno ciclo de eventos que agora tem essa coisa
registradores que, basicamente, é apenas constantemente andando em um círculo
e olhando para o relógio em uma única fio e ditado, tem cinco segundo
passou ainda?
E então, quando ele vê que o segundo mão moveu-se uns cinco segundos ou
o que quer, então ele acorda e diz: oh, o que eu tenho que fazer?
Oh eu tenho que executar esse código.
E então ele vai executar res.end hey.
>> Então, novamente, nós nunca estamos esperando aqui.
Então não é que este código dentro de esta função vai levar cinco
segundos para ser executado.
Este código será executado praticamente instantaneamente, pelo menos em relação a
os cinco segundos que estávamos falando aproximadamente mais cedo antes.
>> Então, só para mostrar isso em ação, Eu posso fazer Node.sleep.js.
E fez eu estragar alguma coisa?
Possivelmente.
Desculpe.
Vamos ver o que podemos fazer para corrigir isso.
OK.
Então, definitivamente usar Node.js.
Eu estou apenas brincando.
OK.
Apenas um segundo.
OK.
Eu sei o que é.
>> Assim, a questão é que no meu outro guia aqui, eu estava correndo Nó já em
que mesmo endereço, 1337.
Assim, o erro que este jogou, se olharmos no-lo real de perto, é o endereço em
usar, EADDRINUSE.
Então, eu já estava usando 1337 aqui.
Então, se eu fechar esta off, e então eu agora tentar executar este, felizmente, tudo
vai ficar bem.
OK.
Então você só pode ter uma coisa tipo de ouvir em uma porta ao mesmo tempo.
Outra solução teria sido para mim apenas para editar esse programa e fazer
seja como 1338 ou algo assim assim.
>> Mas agora o sono está sendo executado.
Então, vamos realmente experimentá-lo no navegador desta vez porque é um
pouco desinteressante para ver lo num terminal.
Então, eu estou indo só para ir a esse 127 endereço novo em 1337.
E se você pode vê-lo -
Eu não sei se você pode - mas meu navegador de tomar um tempo muito, muito
tempo para carregar ou como cinco segundos.
>> E depois disso, ele finalmente acabou com a resposta.
E você não pode vê-lo porque a coisa é movido sobre um pouco, mas se eu fizer
esta um pouco menor, você pode ver que diz hey.
Então, eu tenho o hey, mas após cinco segundos.
E isso pode ser um pouco de ver aqui no terminal, por isso estou
vai fazer a -
vamos fazer aqui -
vamos fazer onda esse endereço novamente com o 1337.
E eu meio que tenho que sentar aqui por cinco segundos.
Mas note que o servidor pode aceitar novas respostas.
Então, ele imprime hey.
>> E a demonstração disso, basicamente o que Eu posso fazer neste outro guia -
então vamos dizer que eu faço isso em outra guia, Eu vou fazer Curl e ao mesmo
coisa de novo.
E eu vou tentar chutar estes caras fora ao mesmo tempo.
Então, eu vou fazer isso, e eu sou vai correr para cá e estou
vai fazê-lo novamente.
>> E vamos fazê-lo de modo que você pode ver os dois.
Aquele impresso hey e que um impresso hey todo o caminho na -
vamos fazer essa experiência novamente.
Na verdade, vamos usar este enganar, se está tudo OK.
>> Então eu vou usar uma coisa que shell me permite executar basicamente duas cópias
deste programa em paralelo.
Então, ele vai executar o primeiro programa e o segundo programa em paralelo.
Portanto, agora se eu pressionar Enter, que vai para fazer esse pedido muito bonito
instantaneamente ao mesmo tempo.
Então, vamos dar a este um tiro.
>> Então, agora ele diz notar dois processos.
E se você estiver curioso, que 27.000 número é basicamente o processo de identificação.
E, em seguida, perceber, eles imprimiram ei ao mesmo tempo.
Não foi como nós tivemos que esperar cinco segundos para uma e depois disso,
Cinco segundos depois obter o segundo.
Então, esse é o tipo de, de certa forma, é realmente não evidenciar, mas é
evidência intuitiva de que não é apenas como aguardando cinco segundos, impedindo
todo o segmento.
OK legal.
>> Então Aaron fez uma pergunta anterior que era bem o que se nós fazer alguma coisa -
Yep?
>> AUDIÊNCIA: Espere.
Como é que diferente de tampão printf, embora?
Não faz isso automaticamente fazer isso?
Por que temos que nos preocupar com isso?
>> KEVIN SCHMID: Oh, você poderia dizer que mais uma vez?
>> AUDIÊNCIA: Não gosta de tampão printf fazer exatamente a mesma coisa?
>> KEVIN SCHMID: O buffer printf?
>> AUDIÊNCIA: Yeah.
OK.
Não foi em um dos testes que eram falando sobre como se você direita printf
alguma coisa e, em seguida, tê-lo pausar uma segundo, e então você tem que circular dez
vezes, ele vai esperar dez segundos, e printf então tudo junto?
>> KEVIN SCHMID: Oh, OK.
>> AUDIÊNCIA: É fazer o mesmo coisa, então, neste caso?
>> KEVIN SCHMID: Então, a pergunta era basicamente, em um dos antigos quizzes
ou algo assim, havia uma questão que basicamente, se você diz print f 10
coisas de uma só vez e depois dormi como em o processo de imprimir os para fora,
no final, por algum motivo, seria simplesmente despejar os todos para fora na tela.
Portanto, há uma espécie de dois diferentes conceitos aqui.
>> Então eu acho que uma coisa é que, neste caso, estamos lidando com dois diferentes
tipo de pessoas perguntando o servidor para as coisas ao mesmo tempo.
E a razão que o tipo de printf espera assim e despeja tudo para fora
de uma só vez está mais relacionado com como printf tipo de -
de modo que o caminho é realmente printf implementado é que tem, basicamente, a
falar com o sistema operacional para escrever esse material para o console.
Por isso, não quero fazer tudo isso coisas imediatamente quando você diz printf
alguma corda, porque isso poderia ficar caro se tiver de
fazer isso todas as vezes.
>> Então, se você faz printf hey, seu programa não pode realmente imprimir essa
imediatamente para o console.
Ele poderia dizer, OK, eu escrevi.
E, em seguida, tipo de esperar por você para dar um pouco mais antes de realmente
escrevê-lo para o console.
>> Assim, a razão que fosse esse o caso -
e é uma espécie de não relacionado para o sono -
é que o sono era uma espécie de apenas injetado ali para demonstrar a
fato de que ele não escreve lo de forma síncrona.
Mas a razão para isso é apenas desempenho de modo que você não tem que
fazer que muitos contatos para o sistema operacional.
>> Mas aqui, o que estamos realmente tentando fazer com essa coisa de sono é apenas mostrar
que, quando temos duas pessoas que visitam Neste site, ele não está indo para colocar
los em uma linha onde ele vai dizer Eu tenho que ajudá-lo, e então quando eu estou
totalmente concluído ajudá-lo depois de estes de cinco segundos, então eu vou
avançar para a próxima pessoa.
Então pedido da primeira pessoa não amarrar esse ciclo de eventos
se isso faz sentido.
>> Mas aqui é realmente um exemplo de algo que vai amarrar
o ciclo de eventos.
Então aqui está uma função horrível calcular o Fibonacci enésima.
É literalmente a pior maneira possível calcular o número de Fibonacci enésima.
E isso é realmente apenas para reconhecer de onde veio isso,
há realmente -
Quero dizer, você pode tentar ir encontrá-lo -, mas não há como um blog muito demorado
post que alguém escreveu.
É como uma daquelas coisas Reddit.
Mas alguém criticou Node.js e eles usaram isso como um exemplo.
Então eu meio que queria apenas mostrar-lhe duas perspectivas diferentes apenas para obter
uma compreensão geral dos conceitos por trás dessas duas coisas.
>> Mas isso é escolhido como apenas um horrível, computacionalmente horrivelmente ineficiente
maneira intensiva para calcular o enésimo número de Fibonacci.
Assim como uma nota lateral, por isso é ele horrível como, de uma forma?
Yep?
>> AUDIÊNCIA: Digamos que você comece com 1.000.
1000 se divide em 999 e 998.
Cada desta divide-se em duas coisas.
>> KEVIN SCHMID: Certo.
>> AUDIÊNCIA: Todo o caminho para baixo.
>> KEVIN SCHMID: Exatamente.
Então, só para repetir para a câmera, se eu chamar fib em 1000 ou algo parecido
assim, é óbvio que não é menos do que ou igual a um, então eu vou
ir a este caso o mais, e então eu vou para chamar fib 999 mais fib 998.
E, em seguida, praticamente todos que trabalho que fib 999 faz é
tipo de, a este nível.
Se você descer, é ainda mais redundante do que isso, mas se você apenas
acho computação lorota 998 recebe nos muito perto de fib 999.
Então, nós realmente deve ser um pouco mais inteligente sobre como nós tipo de reutilização
estes, mas não estamos reutilizando essas coisas em tudo.
Então você pode imaginar este gigantesco, gigantesca árvore que é simplesmente horrível.
>> Mas de qualquer maneira, OK.
Então era lorota.
Ele só tem um tempo para ser executado.
Yep?
>> AUDIÊNCIA: [inaudível].
>> KEVIN SCHMID: Oh, você poderia repetir a pergunta?
>> AUDIÊNCIA: [inaudível].
>> KEVIN SCHMID: Ah então isso é apenas um código que vai ser uma espécie de no
lado do servidor.
Então, isso não vai ser encontrada no navegador ou nada.
É basicamente o que nós temos é que, quando o usuário aqui praticamente marcas
seu pedido de novo, quando uma espécie de fazer um pedido, vamos chamar
esta função no lado do servidor.
E então nós vamos obter o resultado de volta de chamar essa função.
E então nós vamos apenas imprimir lo para o utilizador.
Assim, o usuário não realmente lidar com esta função muito.
>> Foi essa a pergunta?
Será que isso faz sentido?
OK.
Legal.
>> Então, novamente, nós fazemos toda essa res.writeHead coisa em que imprimir
o cabeçalho.
E então eu terminar a resposta, fazendo o número mágico é 45 lorota.
Então vamos executar este servidor.
Então, eu vou fazer um nó fib.js.
Então agora meu servidor lorota está em execução.
>> E então, aqui, eu vou para fazer um desses.
OK?
Então, eu só vou dizer: Curl.
Então, ele vai demorar um pouco, mas espero que em breve ele vai terminar e
ele irá imprimir que 45 Fibonacci número.
>> AUDIÊNCIA: [inaudível].
>> KEVIN SCHMID: deve ser feito em breve.
Por isso, deve levar de cinco a seis segundos.
Eu não sei que é apenas ser super V8 rápida, mas em qualquer caso, esta é uma
muito curto exemplo e propositadamente deselegante de um não-trivial
computação.
Então, depois de um tempo, ele não conseguir isso.
>> Mas agora, o que se eu fizer o mesmo tipo de experiência como antes, onde eu faço
dois pedidos ao mesmo tempo?
Então, aqui eu estou indo para uma onda de esse endereço, e eu vou
fazer outro Curl.
E lembre-se, quando nós fizemos isso para o dormir servidor, quando estamos basicamente teve que
após cinco segundos, eles bastante muito tanto voltou direita
em torno do mesmo tempo.
Por isso, não foi particularmente amarrado.
>> Mas vamos tentar isso agora.
OK, por isso temos os nossos dois processos.
Lembre-se esses são os IDs de processo.
Este vai ser um pouco desajeitado, enquanto nós parar.
Então vamos ficar aqui e esperar.
>> Então, um deles deve vir volta depois como -
OK, então um deles voltou.
Mas, então, por que não fez o segundo um voltar apenas ainda?
Yep?
>> AUDIÊNCIA: O servidor não pode fazer nada enquanto ele está computando que grande número.
>> KEVIN SCHMID: Certo.
Então, a resposta foi apenas que o servidor realmente não pode fazer nada enquanto
ele está computando o número de Fibonacci.
Então agora eu só tenho minhas duas coisas de volta.
Mas eu acho que só de pensar sobre o código um pouco mais, como ele está trabalhando
e tudo mais.
>> Portanto, esta função aqui é o código que Eu disse a este servidor para executar quando se
recebe uma nova solicitação de entrada.
Por isso, só vai percorrer este código inteiro e, em seguida, ele vai ir
voltar para o ciclo de eventos e, em seguida, continuar verificação de novos eventos.
Então, basicamente o que temos a acontecer é o servidor está
ouvindo coisas novas.
A primeira pessoa que pede o que é 45.
Corremos esse código para calcular isso.
Este código tem cerca de cinco seis segundos para executar.
Então vamos voltar para o ciclo de eventos e verificar se há novas solicitações.
>> Portanto, este é um exemplo de como, se tem coisas que são chamados de computação
obrigado, ou usar um monte de computacional, não poder, mas como são
computacionalmente intensivo -
Eu acho que uma coisa a dizer sobre isso é que esta função está fazendo totalmente,
em sua maior parte, bastante direito trabalho útil.
O tempo todo de que essa chamada de retorno função estava funcionando, foi muito
muito passar a maior parte de seu tempo apenas computação número que Fibonacci enésima.
>> Mas nós só tinha um fio para lidar com eles.
No modelo Apache, quando duas pessoas fez o pedido para obter fib 45, nós
teria dois segmentos diferentes.
E então o trabalho do sistema operacional teria sido, ou o nível de usuário
código que gerencia os threads, teria foi a fatia que em cima da
CPU, ou mesmo se você tivesse várias CPUs, distribuí-las uniformemente em todo o CPUs
de modo a que ambos foram acabamento praticamente ao mesmo tempo.
>> Então, só para mostrar como podemos classificar de - e este não é um perfeito total de
solução, mas uma espécie de como podemos fazer uma volta aqui e fazer
um pouco melhor.
Então, o que eu tenho aqui é um programa chamado Fib C. E este usa basicamente
mais um dos módulos do nó chamado O Módulo de processo filho.
Então eu tenho que incluiu no topo tipo de como eu faria um quilo incluem
PROCESS.H criança ou algo assim.
Agora eu tenho acesso a esta variável CP que tem todo o meu funcionalidade.
>> Então agora o que estou fazendo nesta resposta manipulador é que eu estou a execução deste programa
dot cortar fib 45.
Então o que eu fiz - e eu só vou para sair deste programa para um
pouco -
é que eu escrevi um programa em C que basicamente, calcula o
enésimo número de Fibonacci.
Então, aqui é apenas um programa que eu escrevi em C, que calcula este.
Eu posso compilá-lo, e eu posso correr lo na linha de comando.
E está indo para calcular a Número 45 Fibonacci.
>> Então, observe ele só leva praticamente o mesmo tempo.
Eu provavelmente poderia ter usado traço 03 a otimizá-lo ou algo assim,
mas eu só fiz como regulares configurações do compilador.
E ele imprime-lo.
>> Mas agora, o que estou fazendo uma espécie de?
Oh, desculpe, arquivo errado.
Então eu faço a mesma coisa com o cabeçalho como antes.
Então eu faço este cp.exec.
Então o que é que isto vai fazer é que é indo para executar este programa.
Mas a maneira como isso funciona é que ele não vai esperar por
que o programa termine.
Diz apenas, basicamente, executar este programa.
Então, basicamente, digite isso no prompt de comando tipo de.
>> E então, quando você é feito com -lo, execute esta função.
Então, agora nós tipo de obter este coisa toda restaurada de
como não estamos à espera.
Será que esse tipo de faz sentido?
Yep?
>> AUDIÊNCIA: [inaudível]?
>> KEVIN SCHMID: Então, isso vai realmente abrir um novo processo para fazê-lo.
Portanto, este é, na verdade, em alguns aspectos, mal, não super mal, mas é
importante dizer que esta é uma espécie de voltar para, por um lado, o Apache
modelo onde fazemos segmentos e processos para cada solicitação ou
processos para cada solicitação.
Portanto, esta é uma espécie de análogo para o que faz Apache.
Em alguns casos, apenas irá utilizar um novo segmento, que é um pouco mais de luz
peso do que um processo, mas poderia Apache acabam se bifurcar um novo processo
que é uma espécie do que fazemos aqui implicitamente, fazendo ponto barra fib 45.
>> E então, nesse caso, nós meio que incorrem as mesmas despesas de processos.
Portanto, esta é apenas uma coisa que você pode fazer.
Mas só para mostrar esse tipo de execução.
E essa conversa é apenas realmente destinado a apresentar este tipo de programas como
maneira de mostrar diferentes perspectivas sobre como criar servidores assim.
Portanto, este está em execução e, em seguida, agora se eu fizer isso de novo, eu tenho duas IDs de processo.
>> Vamos falar sobre coisas a apontar.
Então, percebe que eles são poucos.
Isso é legal.
Porque era 27.122 antes.
Mas observe agora, eles voltaram mais ou menos ao mesmo tempo.
>> E agora, uma boa pergunta para perguntar sobre por que foi que o caso é, cujo trabalho
era agora a sorte de fazer essas coisas tipo de fair play com cada
outras, essas duas instâncias da dot barra fib 45 que eu corri
ou que correu Node?
Quem tipo de torna justo que ambos se o tipo de tempo de execução equilibrada?
>> AUDIÊNCIA: [inaudível].
>> KEVIN SCHMID: Yeah.
Então, basicamente, quando eu faço ponto lorota barra 45 ou algo assim, agora é
tipo de cima para que o sistema operacional lidar com o tempo de execução desses programas.
E agora ele pode programá-los em diferentes CPUs ou
pode programá-los.
Pode cortar-se o tempo em que um CPU recebe-lo ou que obtenham
para ser executado em uma CPU.
Então essa é a idéia por trás disso.
Isso faz sentido para todo mundo?
Então agora Node não é realmente jogando um parte em dividir essas tarefas.
OK.
>> Então, isso é quase que para exemplos.
Eu só queria mostrar mais uma coisa porque um monte de presente até agora tem sido
não totalmente super-prático em alguns casos.
Eu posso imaginar voltando para casa após este falar e algo e dizendo como,
bem, eu meio que tenho de que a conversa que Eu posso fazer um servidor de Fibonacci para
meu projeto final.
Então aqui está apenas uma espécie de mais um exemplo que espero venha a ser -
talvez não, mas talvez - um pouco mais tipo de relevante para projetos finais e
pensando no futuro para coisas assim.
>> Portanto, esta é chat.js.
Portanto, esta é uma espécie de um pouco de amostra código do lado do servidor que você pode usar para
configurar um servidor de bate-papo pequeno como você pode ter visto no
Facebook Chat ou o que seja.
Então eu não estou dizendo que isso é como o Facebook Bate-papo, mas este é o tipo de
como uma boa - talvez não é bom, mas talvez ponto de partida para um bate-papo - bom
servidor para o seu site para um projeto final.
Então, vamos olhar para o que está fazendo.
>> Então, nós estamos recebendo essa coisa especial , na parte superior, este var SIO
é igual a exigir Socket.IO.
Então, isso é outra coisa que não faz realmente vir junto com
Node mas você pode instalá-lo.
É um módulo Node.
Então, é como alguns extensão para o nó.
>> SocketIO é realmente muito legal.
É uma abstração que, basicamente, o que que ele faz é se ele permite que você
tem esse fluxo de comunicação entre uma web
navegador e um servidor web.
Então, em sua maior parte, até agora, nós tivemos estes muito rápida um segundo ou dois
segundo as comunicações entre um web navegador eo servidor web.
Então, é basicamente ir para google.com, get o material, enviá-lo de volta, e, em seguida,
estamos a fazer.
Nós nunca estamos falando de novo até que o tipos de usuário em outra coisa.
>> Mas o que Socket.IO e mesmo tipo de coisas - e SocketIO é realmente um
das coisas que é construído sobre como WebSocket que é uma espécie de disponível
como parte do HTML5 -
que permite que você tenha esta diálogo contínuo.
E isto é muito útil para um servidor de chat tipo de coisa, porque é
como uma espécie de diálogo contínuo em certa forma, porque se você está conversando
com alguém, agora você pode apenas enviar um mensagem para dentro do cano, e, em seguida, o
servidor pode enviar uma mensagem para baixo a tubulação para a outra pessoa que você é
conversando.
E então você pode ter este trocar assim.
>> Então, isso é o tipo do que SocketIO é bom para.
A razão que SocketIO usa WebSockets como uma coisa é que em
Além de WebSockets simplesmente velhos, ele também faz alguns truques para, basicamente,
compatibilizar isso browser.
Assim, navegadores como o Internet Explorer infelizmente não suportam WebSockets
direito fora da caixa.
Então, ele usa algum outro tipo de puro legal coisas com Adobe Flash para permitir
você ter o suporte ao navegador cruz.
Então, isso é realmente útil.
>> E na verdade, eu sei que eu sou o tipo de execução em tempo aqui, mas CS50
Discutir, você já viu algo como, eu não sei, em branco assim e assim é
responder a este post ou algo assim, essa característica?
Isso é SocketIO.
Então, quando alguém começa a digitar no caixa de discutir a dar uma resposta ou
alguma coisa, o seu navegador não tem o que há de chamado SocketIO emite algum tipo de
caso em que diz que alguém é responder a este post.
>> Em seguida, o servidor diz: OK, o que eu tenho que fazer?
Bem, agora eu tenho que dizer a esses outros caras que estão no CS50 Discutir procurando
neste post que alguém está respondendo.
Então, isso é o tipo do que é SocketIO bom para, este tipo contínuo de
fluxo de diálogo.
OK.
>> Então, o que eu tenho aqui - e estamos apenas vai ignorar a matriz conexões
para um pouco -
o que eu faço é que eu ouvir outra.
Então, isso é apenas a forma como é Socket.IO dizendo vamos ouvir nesta porta.
E então eu faço isso na conexão.
Então, isso é basicamente só soquete IO de maneira de dizer, quando recebemos uma
conexão, eu quero que você para executar este código.
>> E note que em vez de ter rec e res passaram lá tenho Socket.
E essa idéia de soquete é basicamente isso coisa que você pode gravar e ler
de que tem o usuário do mensagens possivelmente.
E as mensagens que você enviar pode passar por isso Socket.
Será que isso faz sentido?
Então é essa coisa de continuar.
>> Então, o que eu faço é chamar Socket.emit.
E emitem leva muito muito dois argumentos.
O primeiro argumento é uma string apenas representando o tipo de
coisa que você está emitindo.
Portanto, para este caso, eu tenho uso esta nova mensagem string.
E isso é só basicamente dizendo que o tipo de tal coisa, o que eu sou
enviando, é uma nova mensagem.
Assim, você pode ouvir para tipos específicos como nova mensagem ou qualquer outra coisa
usando ponto em.
>> Então conexão eo usuário enviado para lá, se você olha para onde chamamos ponto em diante,
essas são outras cordas que representam tipos de mensagens do usuário.
Então, é basicamente você pode ter este emitem um destes tipos de mensagens, e
em seguida, fazer algo em resposta a um destes tipos de mensagens
>> Então, eu estou emitindo esta mensagem nova.
Vamos ignorar connections.push por um segundo.
Mas, então, eu digo, usuário Socket.on enviada.
Então, agora é uma espécie de gosto quando o user me envia uma mensagem, eu quero
você executar este código.
E note que essa função anônima está tomando nesta variável
chamada de dados que vai basicamente para ter a mensagem do usuário.
>> Tipo Então, agora vamos de falar sobre a matriz ligações.
Portanto, este é projetado para um cliente de chat onde basicamente todo mundo é meio em
mesma sala de bate-papo.
Então, basicamente, o que precisamos para manter em torno de uma certa matriz que, basicamente,
representa todas as pessoas conversando em certa forma, se isso faz sentido.
Certo?
Porque nós precisamos de saber quem são esses caras são para que possamos enviar-lhes as mensagens
que outras pessoas enviam para nós.
>> Então, o que este código faz é quando o usuário envia uma mensagem - que é o tipo de
o evento -
vamos executar este código.
E o que nós fazemos é percorrer este matriz que temos chamado de conexões.
E praticamente para cada conexão exceto o que é nosso, que é
o que esse código diz, nós enviar uma nova mensagem com que anexado mensagem
informações.
>> Então, se você observar aqui, o que eu fiz quando o usuário realmente faz uma nova
conexão é que eu adicionei com o JavaScript.push método, isto é
basicamente, apenas dizendo como adicionar que soquete como um valor em
nossa disposição conexões.
Agora, quando esse código é executado, ele será enviar as coisas para aqueles especial
ligações.
Portanto, este pode ser um bom ponto de partida para fazer um servidor de chat
ou algo semelhante.
>> E o tipo de coisa legal é que o código que você vê aqui para como em e
emitir e coisas assim é o mesmo tipo de código JavaScript que você faria
escrever no navegador para interagir com o servidor.
Então é por isso SocketIO é uma espécie de puro e útil na medida em que forma.
>> Ah, e só mais uma coisa rapidinho.
Havia um projeto final CS50 ano passado que, basicamente, implementou um bate-papo
servidor em Node.js.
Eu acho que é Harvardchats.org mas eu não sou -
OK.
Eu não tenho certeza o que a URL é, mas Eu posso enviar isso depois.
Mas é legal o que você pode fazer com Node.js.
>> Então eu espero que, em geral, vocês têm um boa noção do que Node.js é útil
e como você poderia talvez aplicar ao seu projeto final.
Eu vou estar enviando um pouco mais recursos juntamente com este.
E obrigado por terem vindo.
Obrigado.
>> [Aplausos]