Оригинальный адрес:co's лопнул.IO/он и -только-нет...
автор:vick_onrails
Аннотация: Эта статья подойдет новичкам, которые ничего или мало знают о Node. Всесторонний, но не глубокий охват точек знаний, включая модуль http, экспресс, mongodb и RESTful API.

Если вы фронтенд-разработчик, написание веб-приложений на основе NodeJS для вас не новость. И NodeJS, и веб-программы в значительной степени зависят от языка JavaScript.

Во-первых, давайте осознаем одну вещь: Node — это не панацея. Тем не менее, это не лучшее решение для всех проектов. Любой может создать сервер на основе Node, но для этого необходимо хорошо понимать язык программирования, на котором написаны веб-программы.

В последнее время я нашел много радости в изучении Node, а также понял, что приобрел определенные знания и должен поделиться ими и получить отзывы от сообщества, чтобы улучшить себя.

Итак, приступим.

До появления Node.js

До появления Node.js веб-приложения часто основывались на модели клиент/сервер: когда клиент запрашивал ресурсы у сервера, сервер отвечал на запрос и возвращал соответствующие ресурсы. Сервер ответит только тогда, когда получит запрос клиента, и закроет соединение с клиентом после завершения ответа.

Этот шаблон проектирования должен учитывать вопросы эффективности, поскольку каждый запрос требует времени и ресурсов для обработки. Поэтому сервер должен закрывать соединение после каждой обработки запрошенного ресурса, чтобы отвечать на другие запросы.

Что произойдет с сервером, если на сервер будут отправлены тысячи запросов одновременно? Когда вы задаете этот вопрос, вы не хотите видеть ситуацию, когда запрос должен ждать ответа на другие запросы до своей очереди, потому что задержка слишком велика.

Представьте, что вы хотите открыть свой FaceBook, но вам нужно подождать 5 минут, чтобы увидеть контент, потому что тысячи людей сделали запросы на сервер до вас. Есть ли решение для обработки сотен или тысяч запросов одновременно? К счастью, у нас есть инструмент многопоточности.

Потоки — это то, как система может обрабатывать несколько задач параллельно. Каждый запрос к серверу запускает новый поток, и каждый поток получает все необходимое для запуска кода.

Это звучит странно? Давайте посмотрим на этот пример:

Представьте, что в ресторане есть только один шеф-повар, который подает еду, и все становится хуже, когда требуется все больше и больше еды. Людям пришлось долго ждать, прежде чем все предыдущие заказы были обработаны. И все, о чем мы можем думать, это добавить больше официантов, чтобы решить эту проблему, верно? Это может обрабатывать больше клиентов одновременно.

Каждый поток — это новый сервер, а клиент — браузер. Думаю, вам нетрудно это понять.

Но у этой системы есть побочный эффект, когда количество запросов достигает определенного числа, слишком много потоков будут потреблять всю системную память и ресурсы. Возвращаясь к нашему примеру, найм все большего числа людей для раздачи еды обязательно приведет к увеличению затрат на рабочую силу и займет больше места на кухне.

Конечно, для нас было бы здорово, если бы сервер сразу отключался и освобождал все ресурсы после ответа на запрос клиента.

Многопоточные системы хорошо справляются с операциями, интенсивно использующими ЦП, потому что эти операции требуют обработки большого количества логики, а вычисление этой логики занимает больше времени. Если каждый запрос обрабатывается новым потоком, основной поток может быть освобожден для выполнения некоторых важных вычислений, что также ускоряет работу всей системы.

Избавление основного потока от выполнения всех вычислений — отличный способ повысить эффективность, но можно ли сделать еще один шаг?

А вот и NodeJS

Представьте, что теперь у нас есть многопоточный сервер, работающий в среде Ruby on rails. Нам нужно, чтобы он прочитал файл и отправил его в браузер, запрашивающий файл. Первое, что нужно знать, это то, что Ruby не читает файлы напрямую, а сообщает файловой системе прочитать указанный файл и вернуть его содержимое. Как следует из названия, файловая система — это программа на компьютере, которая специально используется для доступа к файлам.

После того, как Ruby уведомляет файловую систему, он ждет, пока она закончит чтение файла, вместо того, чтобы переходить к другим задачам. Когда задача обработки файловой системы завершена, Ruby перезапускается, чтобы собрать содержимое файла и отправить его в браузер.

Этот метод, очевидно, вызовет блокировку, и NodeJS был создан, чтобы решить эту проблему. Если мы используем Node для уведомления файловой системы, пока файловая система читает файл, Node будет обрабатывать другие запросы. После завершения задачи чтения файла файловая система уведомит Node о необходимости чтения ресурса и вернет его в браузер. Фактически, внутренняя реализация здесь опирается на цикл обработки событий Node.

В основе Node лежит JavaScript и цикл обработки событий.

Проще говоря, цикл событий — это программа, которая ожидает событий, а затем запускает их, когда это необходимо. Также важно отметить, что Node, как и JavaScript, является однопоточным.

Помните пример с рестораном, который мы привели? Независимо от количества посетителей, в ресторане Node всегда будет только один повар, готовящий еду.

В отличие от других языков, NodeJS не нужно запускать новый поток для каждого запроса, он будет получать все запросы, а затем делегировать большинство задач другим системам.LibuvЭто библиотека, которая использует ядро ​​ОС для эффективного решения этих задач. Когда эти скрытые рабочие процессы завершают обработку делегированных им событий, они запускают обратные вызовы, привязанные к этим событиям, для уведомления NodeJS.

Здесь мы соприкасаемся с концепцией обратных вызовов. Обратный вызов несложно понять, это функция, которая передается в качестве аргумента другим функциям и будет вызываться при определенных обстоятельствах.

Большинство разработчиков NodeJS пишут обработчики событий, которые вызываются, когда происходит определенное событие NodeJS.

Хотя NodeJS является однопоточным, он намного быстрее, чем многопоточные системы. Это связано с тем, что программы часто представляют собой не просто трудоемкие математические операции и логические вычисления, а большую часть времени они просто записывают файлы, обрабатывают сетевые запросы или запрашивают разрешения с консолей и внешних устройств. Это те вещи, в которых NodeJS преуспевает: когда NodeJS работает над этими вещами, он быстро делегирует эти события специализированным системам и переходит к следующему событию.

Если вы продолжите копать дальше, вы можете обнаружить, что NodeJS не очень хорошо справляется с операциями, потребляющими ресурсы ЦП. Поскольку операции с интенсивным использованием ЦП потребляют много ресурсов основного потока. Для однопоточной системы идеальная ситуация — избегать этих операций, чтобы освободить основной поток для других задач.

Еще один ключевой момент заключается в том, что в JavaScript только тот код, который вы пишете, не выполняется одновременно. То есть ваш код может обрабатывать только одну вещь за раз, в то время как другие рабочие процессы, такие как файловая система, могут выполнять текущую работу параллельно.

Если вы все еще не можете понять, вы можете взглянуть на следующий пример:

Давным-давно жил-был король, у которого была тысяча чиновников. Король составил список задач для чиновников, и список был очень, очень, очень длинным. Есть канцлер, который делегирует задачи всем остальным чиновникам согласно списку. Каждый раз, когда он выполнял задание, он сообщал о результатах королю, который затем давал ему новый список. Потому что, пока чиновники работали, король был занят составлением других списков.

Этот пример говорит о том, что король может делать только одно дело за раз, даже несмотря на то, что многие чиновники работают над задачами параллельно. Здесь король — это ваш код, а офицер — системный работник за кулисами NodeJS. Итак, кроме вашего кода, все происходит параллельно.

Хорошо, давайте продолжим это путешествие по NodeJS.

Написать веб-приложение с NodeJS

Написание веб-приложения с помощью NodeJS эквивалентно написанию обратных вызовов событий. Давайте посмотрим на следующий пример:

1. Создать и войти в папку
2. воплощать в жизньnpm initнажимайте Enter, пока не создадите файл package.json в корне папки.
3. Создайте новый файл с именем server.js, скопируйте и вставьте следующий код:

   //server.js
   const http = require('http'),
         server = http.createServer();
   
   server.on('request',(request,response)=>{
      response.writeHead(200,{'Content-Type':'text/plain'});
      response.write('Hello world');
      response.end();
   });
   
   server.listen(3000,()=>{
     console.log('Node server created at port 3000');
   });
   

4. В командной строке введитеnode server.js, вы увидите следующий вывод:

   node server.js
   //Node server started at port 3000
   

Откройте браузер и перейдите наlocalhost:3000, вы должны увидетьHello worldИнформация.

Во-первых, мы представили модуль http. Этот модуль предоставляет интерфейс для обработки http-операций, который мы называемcreateServer()метод создания сервера.

После этого мы привязываем callback к событию запроса, которое передается во второй параметр метода on. Эта функция обратного вызова имеет 2 объекта параметров, запрос представляет полученный запрос, а ответ представляет данные ответа.

Вместо того, чтобы просто обрабатывать событие запроса, мы также можем позволить Node делать другие вещи.

//server.js
const http = require('http'),
server = http.createServer((request,response)=>{
    response.writeHead(200,{'Content-Type':'text/plain'});
    response.write('Hello world');
    response.end();
});
server.listen(3000,()=>{
    console.log('Node server created at port 3000');
});

В коде лицом к лицу мы передаем createServer() функцию обратного вызова, которую Node привязывает к событию запроса. Таким образом, нам нужно заботиться только об объектах запроса и ответа.

Мы используемresponse.writeHead()для установки полей заголовка возвращаемого сообщения, таких как код состояния и тип содержимого. а такжеresponse.write()Это операция записи на веб-страницу. последнее использованиеresponse.end()чтобы закончить этот ответ.

Наконец, мы указываем серверу прослушивать порт 3000, чтобы мы могли просматривать демонстрацию нашего веб-приложения при локальной разработке. Метод listen требует, чтобы вторым параметром была функция обратного вызова, которая будет выполняться, как только сервер запустится.

Привыкайте к обратному звонку

Node — это однопоточная среда выполнения, управляемая событиями, то есть в Node все является реакцией на события.

Предыдущий пример можно переписать следующим образом:

//server.js
const http = require('http'),
      
makeServer = function (request,response){
   response.writeHead(200,{'Content-Type':'text/plain'});
   response.write('Hello world');
   response.end();
},
      
server = http.createServer(makeServer);

server.listen(3000,()=>{
  console.log('Node server created at port 3000');

makeServerявляется функцией обратного вызова, и, поскольку JavaScript рассматривает функции как граждан первого класса, их можно передать любой переменной или функции. Если вы еще не знаете JavaScript, вам следует уделить немного времени тому, чтобы понять, что такое программирование, управляемое событиями.

Когда вы начинаете писать какой-то важный код JavaScript, вы можете столкнуться с «адом обратных вызовов». Ваш код становится трудно читать из-за большого количества переплетенных и сложных функций. На данный момент вы хотите найти более продвинутый и эффективный способ замены обратных вызовов. Посмотрите на Обещания,Eric Elliott написал статьюОбъясните, что такое обещание, который является хорошим вводным руководством.

Маршрутизация NodeJS

Сервер будет хранить большое количество файлов. Когда браузеры отправляют запрос, они сообщают серверу, какой файл им нужен, и сервер возвращает соответствующий файл клиенту. Это называется маршрутизацией.

В NodeJS нам нужно определить наши собственные маршруты вручную. Это не слишком сложно, взгляните на этот простой пример:

//server.js
const http = require('http'),
      url = require('url'),
 
makeServer = function (request,response){
   let path = url.parse(request.url).pathname;
   console.log(path);
   if(path === '/'){
      response.writeHead(200,{'Content-Type':'text/plain'});
      response.write('Hello world');
   }
   else if(path === '/about'){
     response.writeHead(200,{'Content-Type':'text/plain'});
     response.write('About page');
   }
   else if(path === '/blog'){
     response.writeHead(200,{'Content-Type':'text/plain'});
     response.write('Blog page');
   }
   else{
     response.writeHead(404,{'Content-Type':'text/plain'});
     response.write('Error page');
   }
   response.end();
 },
server = http.createServer(makeServer);
server.listen(3000,()=>{
 console.log('Node server created at port 3000');
});

Вставьте этот код, введитеnode server.jsКоманда выполняется. Открыть в браузереlocalhost:3000а такжеlocalhost:3000/abou, затем попробуйте открытьlocalhost:3000/somethingelse, вы перешли на нашу страницу с ошибкой?

Хотя это удовлетворяет нашим основным требованиям для запуска сервера, было бы безумием писать код для каждой страницы на сервере. На самом деле этим никто не занимается, этот пример просто дает вам представление о том, как работает маршрутизация.

Если вы заметили, мы ввели модуль url, который упрощает работу с URL-адресами.

Передайте параметр строки URL-адреса методу parse(), этот метод разделит URL-адрес наprotocol,host,pathа такжеquerystringи так далее. Если вы плохо знаете эти слова, взгляните на картинку ниже:

Итак, когда мы выполняемurl.parse(request.url).pathnameоператор, мы получаем путь к URL-адресу или сам URL-адрес. Это все необходимые условия, которые мы используем для маршрутизации запросов. Но есть более простой способ сделать это.

Маршрутизация с помощью Express

Если вы делали домашнюю работу раньше, вы, должно быть, слышали об Express. Это платформа NodeJS для создания веб-приложений и API, которую также можно использовать для написания приложений NodeJS. Читайте дальше, и вы поймете, почему я говорю, что это все упрощает.

В терминале или командной строке перейдите в корневой каталог вашего компьютера и введитеnpm install express --saveдля установки пакета экспресс-модуля. Чтобы использовать Express в нашем проекте, нам нужно его импортировать.

const express = require('express');

Ура, жизнь наладится.

Теперь давайте сделаем базовую маршрутизацию с экспрессом.

//server.js
const express = require('express'),
      server = express();

server.set('port', process.env.PORT || 3000);

//Basic routes
server.get('/', (request,response)=>{
   response.send('Home page');
});

server.get('/about',(request,response)=>{
   response.send('About page');
});

//Express error handling middleware
server.use((request,response)=>{
   response.type('text/plain');
   response.status(505);
   response.send('Error page');
});

//Binding to a port
server.listen(3000, ()=>{
  console.log('Express server started at port 3000');
});

Примечание переводчика: я не совсем понимаю, почему в коде код ошибки 505.

Теперь код выглядит чище? Я верю, что вы можете легко понять это.

Во-первых, когда мы вводим экспресс-модуль, мы получаем функцию. После вызова этой функции мы можем запустить наш сервер.

Далее мы используемserver.set()для установки порта прослушивания. а такжеprocess.env.PORTОн задается средой, в которой работает программа. Без этого параметра мы по умолчанию используем его значение 3000.

Затем, наблюдая за приведенным выше кодом, вы обнаружите, что маршруты в Express имеют формат:

server.VERB('route',callback);

ГЛАГОЛ здесь может быть таким действием, как GET, POST, а имя пути — это строка, следующая за именем домена. При этом callback — это функция, которую мы хотим вызвать после получения запроса.

Наконец мы звонимserver.listen()Я до сих пор помню его роль, верно?

Выше показана маршрутизация в программе Node Давайте рассмотрим, как Node вызывает базу данных.

База данных в NodeJS

Многим нравится делать все на JavaScript. Этому требованию удовлетворяют только некоторые базы данных, такие как MongoDB, CouchDB и т. д. Все эти базы данных являются базами данных NoSQL.

База данных NoSQL представляет собой структуру данных в виде пар ключ-значение, она основана на документах, а данные не хранятся в табличном виде.

Давайте взглянем на MongoDB, базу данных NoSQL. Если вы использовали реляционные базы данных, такие как MySQL, SQLserver и т. д., вы должны быть знакомы с такими понятиями, как база данных, таблица, строка и столбец. MongoDB особо от них не отличается, но давайте сравним.

Примечание переводчика: должна быть таблица, показывающая разницу между MongoDB и MySQL, но она не показана в исходном тексте.

Чтобы сделать данные более организованными, мы можем использовать Mongoose для проверки типов данных и добавления правил проверки в документы перед вставкой данных в MongoDB. Похоже на посредника между Mongo и Node.

Из-за длины этой статьи, чтобы каждый раздел был как можно короче, прочитайте официальныйРуководство по установке MongoDB.

также,Chris SevillejaнаписалEasily Develop Node.js and MongoDB Apps with Mongoose, я думаю, что это хороший базовый учебник для начала работы.

Написание RESTful API с помощью Node и Express

API — это канал, по которому приложение отправляет данные другим программам. Вы когда-нибудь попадали на определенные страницы, которые требуют входа в систему с вашей учетной записью Facebook? Facebook предоставляет этим сайтам определенные функции, это API.

RESTful API не должен меняться при изменении состояния сервера/клиента. Используя интерфейс REST, разные клиенты, даже если они находятся в разных состояниях, должны выполнять одни и те же действия и получать одни и те же данные при доступе к одной и той же конечной точке REST.

Конечная точка API — это функция в API, которая возвращает данные.

Написание RESTful API предполагает передачу данных в формате JSON или XML. Давайте попробуем это в NodeJS. Далее мы напишем API, который будет возвращать поддельные данные JSON после того, как клиент сделает запрос через AJAX. Это не идеальный API, но он помогает нам понять, как он работает в среде Node.

1. Создайте папку с именем node-api;
2. Заходим в эту папку через командную строку, вводимnpm init. Это создаст файл, который собирает зависимости;
3. войтиnpm install --save expressустановить экспресс;
4. Создайте три новых файла в корневом каталоге:server.js,index.htmlа такжеusers.js;
5. Скопируйте следующий код в соответствующий файл:

//users.js
module.exports.users = [
 {
  name: 'Mark',
  age : 19,
  occupation: 'Lawyer',
  married : true,
  children : ['John','Edson','ruby']
 },
  
 {
  name: 'Richard',
  age : 27,
  occupation: 'Pilot',
  married : false,
  children : ['Abel']
 },
  
 {
  name: 'Levine',
  age : 34,
  occupation: 'Singer',
  married : false,
  children : ['John','Promise']
 },
  
 {
  name: 'Endurance',
  age : 45,
  occupation: 'Business man',
  married : true,
  children : ['Mary']
 },
]

Это данные, которые мы передаем другим приложениям, и мы экспортируем эти данные, чтобы все программы могли их использовать. То есть мы сохраняем массив пользователей вmodules.exportsОбъект.

//server.js
const express = require('express'),
      server = express(),
      users = require('./users');

//setting the port.
server.set('port', process.env.PORT || 3000);

//Adding routes
server.get('/',(request,response)=>{
 response.sendFile(__dirname + '/index.html');
});

server.get('/users',(request,response)=>{
 response.json(users);
});

//Binding to localhost://3000
server.listen(3000,()=>{
 console.log('Express server started at port 3000');
});

мы выступаемrequire('express')заявление, а затем использоватьexpress()Создается служебная переменная. Если вы внимательно посмотрите, вы также увидите, что мы представили кое-что еще, а именноusers.js. Помните, куда мы помещаем наши данные? Это необходимо для работы программы.

У Express есть много способов помочь нам доставить определенные типы контента в браузер.response.sendFile()Файл будет найден и отправлен на сервер. Мы используем__dirnameчтобы получить путь к корневому каталогу, в котором работает сервер, мы помещаем строкуindex.jsДобавление к пути гарантирует, что мы сможем найти правильный файл.

response.json()Отправка содержимого в формате JSON на веб-страницу. Мы передаем ему массив пользователей, которым мы хотим поделиться, в качестве параметра. Остальной код, думаю, вы уже знакомы из предыдущих статей.

//index.html

<!DOCTYPE html>
<html>
<head>
 <meta charset="utf-8">
 <title>Home page</title>
</head>
<body>
 <button>Get data</button>
<script src="https://code.jquery.com/jquery-3.2.1.min.js" integrity="sha256-hwg4gsxgFZhOsEEamdOYGBf13FyQuiTwlAQgxVSNgt4=" crossorigin="anonymous"></script>
 
  <script type="text/javascript">
  
    const btn = document.querySelector('button');
    btn.addEventListener('click',getData);
    function getData(e){
        $.ajax({
        url : '/users',
        method : 'GET',
        success : function(data){
           console.log(data);
        },
      
        error: function(err){
          console.log('Failed');
        }
   });
  } 
 </script>
</body>
</html>

Выполнить в корне папкиnode server.js, теперь откройте браузер, чтобы посетитьlocalhost:3000, нажмите кнопку и откройте консоль браузера.

существуетbtn.addEventListent('click',getData);В этой строке кода getData делает запрос GET через AJAX, который использует$.ajax({properties})функция для установкиurl,successа такжеerrorи другие параметры.

В реальной производственной среде вы будете делать больше, чем просто читать файлы JSON. Вы также можете выполнять такие операции, как добавление, удаление, изменение и запрос данных. Платформа Express связывает эти операции с конкретными HTTP-глаголами, такими как ключевые слова, такие как POST, GET, PUT и DELETE.

Чтобы узнать больше о том, как писать API с экспрессом, вы можете прочитатьChris SevillejaнаписаноBuild a RESTful API with Express 4.

использовать сокет для сетевого подключения

Компьютерная сеть — это соединение между компьютерами для обмена и получения данных. Чтобы выполнять сетевые операции в NodeJS, нам нужно ввестиnetмодуль.

const net = require('net');

В TCP должно быть два терминала, один терминал привязан к указанному порту, а другому нужен доступ к указанному порту.

Если у вас все еще есть сомнения, взгляните на этот пример:

К вашему телефону, например, после того, как вы купили сим-карту, ваш номер телефона и привязка симки. Когда ваш друг хочет позвонить вам, он должен позвонить по этому номеру. Таким образом, вы делаете эквивалент TCP-терминала, а другой терминал — ваш друг.

Вы понимаете теперь?

Чтобы лучше усвоить эти знания, давайте напишем программу, которая слушает файл и уведомляет подключенных к нему клиентов, когда файл изменяется.

1. Создайте папку с именемnode-network;
2. Создайте 3 файла:filewatcher.js,subject.txtа такжеclient.js. Скопируйте следующий код вfilewatcher.js.

   //filewatcher.js
   
   const net = require('net'),
      fs = require('fs'),
      filename = process.argv[2],
         
   server = net.createServer((connection)=>{
    console.log('Subscriber connected');
    connection.write(`watching ${filename} for changes`);
     
   let watcher = fs.watch(filename,(err,data)=>{
     connection.write(`${filename} has changed`);
    });
     
   connection.on('close',()=>{
     console.log('Subscriber disconnected');
     watcher.close();
    });
     
   });
   server.listen(3000,()=>console.log('listening for subscribers'));
   

3. Затем мы предоставляем отслеживаемый файл, вsubject.txtНапишите следующий абзац:

   Hello world, I'm gonna change
   

4. Затем создайте нового клиента. Скопируйте приведенный ниже код вclient.js.

   const net = require('net');
   let client = net.connect({port:3000});
   client.on('data',(data)=>{
    console.log(data.toString());
   });
   

5. Наконец, нам нужны еще два терминала. В первом терминале запускаемfilename.js, за которым следует имя файла, который мы хотим прослушать.

   //subject.txt会保存在filename变量中
   node filewatcher.js subject.txt
   //监听订阅者
   

В другом терминале, на стороне клиента, запускаемclient.js.node client.jsТеперь изменитеsubject.txt, затем посмотрите на командную строку клиента и обратите внимание на дополнительную информацию:

//subject.txt has changed.

Основная особенность сети заключается в том, что многие клиенты могут получить доступ к сети одновременно. Откройте другое окно командной строки и введитеnode client.jsзапустить другой клиент, а затем изменитьsubject.txtдокумент. Видишь, что на выходе?

что мы наделали?

Если вы не понимаете, не волнуйтесь, давайте пройдемся еще раз.

нашfilewatcher.jsсделал три вещи:

1. net.createServer()Создайте сервер и отправьте информацию многим клиентам.
2. Уведомляет сервер о том, что клиент подключен, и информирует клиента о прослушивании файла.
3. Наконец, используйте wactherbianl для прослушивания файла и закрытия его при подключении клиентского порта.

увидеть сноваfilewatcher.js.

//filewatcher.js

const net = require('net'),
   fs = require('fs'),
   filename = process.argv[2],
      
server = net.createServer((connection)=>{
 console.log('Subscriber connected');
 connection.write(`watching ${filename} for changes`);
  
let watcher = fs.watch(filename,(err,data)=>{
  connection.write(`${filename} has changed`);
 });
  
connection.on('close',()=>{
  console.log('Subscriber disconnected');
  watcher.close();
 });
  
});
server.listen(3000,()=>console.log('listening for subscribers'));

Мы представляем два модуля: fs и net для чтения и записи файлов и выполнения сетевых подключений. ты заметилprocess.argv[2]? process — это глобальная переменная, которая предоставляет важную информацию о выполнении кода NodeJS.argv[]представляет собой массив параметров, когда мы получаемargv[2]Когда вы хотите получить третий параметр работающего кода. Помните, в командной строке мы вводили имя файла в качестве третьего аргумента?

node filewatcher.js subject.txt

Кроме того, мы видим очень знакомый код, напримерnet.createServer(), который получает функцию обратного вызова, которая срабатывает, когда клиент подключается к порту. Эта функция обратного вызова получает только параметр объекта, который используется для взаимодействия с клиентом.

connection.write()способ отправки данных любому клиенту, подключенному к порту 3000. Таким образом, нашconnetionОбъект приступает к работе, уведомляя клиента о прослушивании файла.

wactcher включает метод, который отправляет информацию клиенту после изменения файла. И после того, как клиент отключается, запускается событие закрытия, а затем обработчик событий отправляет сообщение на сервер, чтобы позволить ему закрыть наблюдателя и прекратить прослушивание.

//client.js
const net = require('net'),
      client = net.connect({port:3000});
client.on('data',(data)=>{
  console.log(data.toString());
});

client.jsОчень просто, мы вводим модуль net и вызываем метод подключения для доступа к порту 3000, затем прослушиваем каждое событие данных и распечатываем данные.

когда нашfilewatcher.jsкаждое исполнениеconnection.write(), наш клиент вызовет событие данных.

Вышеупомянутое — всего лишь небольшая часть того, как работает сеть. Главное, что когда конечная точка транслирует информацию, она вызовет событие данных на всех клиентах, подключенных к этой конечной точке.

Если вы хотите узнать больше о сетевых знаниях Node, вы можете взглянуть на официальную документацию NodeJS:сетевой модуль. вы также можете прочитатьBuilding a Tcp service using Node.

Резюме автора

Хорошо, это все, о чем я собираюсь поговорить. Если вы хотите использовать NodeJS для написания веб-приложений, вам нужно знать больше, чем просто написать сервер и использовать экспресс для маршрутизации.

Вот несколько книг, которые я рекомендую:
NodeJs the right way
Web Development With Node and Express

Если у вас есть какие-либо дополнительные идеи, вы можете оставить комментарий ниже.

Примечание переводчика: этот переводческий проект только начался, и в будущем будет переведено все больше и больше работ. Я постараюсь выстоять.
адрес проекта:GitHub.com/белый инь/внезапно…