Comment utiliser Nodejs

Node.js est un environnement d'exécution JavaScript multiplateforme open source basé sur le runtime JavaScript Chrome. Il prend non seulement en charge le développement JavaScript côté serveur, mais également le développement d'applications Web et peut même être utilisé pour développer des appareils IoT. Node.js se caractérise par un modèle d'E/S non bloquant et piloté par les événements, qui peut facilement gérer les requêtes à haute concurrence. Il s'agit de l'un des outils de développement préférés pour les applications WEB modernes.

Alors, comment utiliser Node.js ? Ce qui suit sera divisé en parties suivantes pour présenter l'installation, la syntaxe de base, les modules communs et les applications de cas de Node.js.

1. Installez Node.js

Tout d'abord, téléchargez la version correspondante du package d'installation de Node.js depuis le site officiel de Node.js https://nodejs.org et installez-le.
Une fois l'installation terminée, ouvrez l'outil de ligne de commande (cmd ou powershell sous Windows, Terminal sous Mac ou Linux) et entrez la commande "node -v" Si le numéro de version de Node.js est affiché, l'installation est réussie. .

2. Syntaxe de base de Node.js

Ensuite, jetons un coup d'œil à la syntaxe de base de Node.js.

(1) sortie console.log()

console.log() est l'une des fonctions les plus couramment utilisées dans Node.js, utilisée pour afficher les informations de la console. L'exemple suivant :

console.log('Hello, World!');

Ce code peut être exécuté en utilisant "node filename.js" dans l'outil de ligne de commande, et le résultat de sortie est : "Hello, World!"

(2) Déclaration de variable

Variables dans Node. js Vous pouvez utiliser les trois mots-clés var, let et const pour déclarer. Parmi eux, let et const sont des nouvelles fonctionnalités d'ES6.

var num = 1;
let name = 'Tom';
const PI = 3.14;

Les variables déclarées par var peuvent être écrasées, les variables déclarées par let peuvent être réaffectées, les variables déclarées par const ne peuvent pas être réaffectées.

(3) Définition et appel de fonctions

Les fonctions définies dans Node.js utilisent le mot-clé function, et il n'est pas nécessaire de spécifier le type de retour de la fonction. À titre d'exemple :

function add(a, b) {
    return a + b;
}
console.log(add(1, 2)); // 输出3

(4) Importation et exportation de modules

Dans Node.js, un module est un fichier indépendant qui contient les fonctions et variables associées à une certaine fonction. Dans un module, nous pouvons exporter les fonctions ou variables qui doivent être exposées via module.exports, et dans d'autres modules, nous pouvons les importer et les utiliser via la fonction require().

Supposons que nous ayons maintenant un fichier math.js avec le contenu suivant :

function add(a, b) {
    return a + b;
}
module.exports = add;

Nous pouvons utiliser la fonction require() dans un autre fichier pour exporter la fonction d'ajout dans le module et l'appeler :

const add = require('./math');
console.log(add(1, 2)); // 输出3

3. Node. js Modules couramment utilisés

Node.js fournit un grand nombre de modules intégrés pour gérer diverses tâches, telles que les opérations du système de fichiers, la communication réseau, le cryptage et le déchiffrement, etc. Nous pouvons appeler les modules associés via la fonction require().

(1) Module de système de fichiers (fs)

Le module fs fournit des opérations liées au système de fichiers. Celles-ci incluent la lecture et l'écriture de fichiers, les opérations de répertoire, les opérations de flux de fichiers, etc. Par exemple :

const fs = require('fs');
// 读取文件内容
fs.readFile('test.txt', function(err, data) {
    if (err) {
        console.log('读取文件失败：', err);
    } else {
        console.log('读取文件成功：', data.toString());
    }
});
// 写入文件
fs.writeFile('test.txt', 'Hello, Node.js!', function(err) {
    if (err) {
        console.log('写入文件失败：', err);
    } else {
        console.log('写入文件成功！');
    }
});

(2) Module de communication réseau (http)

Le module http est utilisé pour implémenter des programmes serveur et client liés au protocole HTTP. Nous pouvons l'utiliser pour créer des serveurs et des clients HTTP afin de gérer la communication réseau. Par exemple :

const http = require('http');
http.createServer(function(req, res) {
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Hello World!');
}).listen(8080);
console.log('服务器已经启动，请访问http://localhost:8080');

(3) Module de cryptage et de décryptage (crypto)

Le module crypto est utilisé pour fournir des fonctions de cryptage et de décryptage. Il peut être utilisé pour générer des nombres aléatoires, des algorithmes de hachage, un cryptage symétrique, un cryptage asymétrique, etc. À titre d'exemple :

const crypto = require('crypto');
const hash = crypto.createHash('md5');
hash.update('Hello World!');
console.log(hash.digest('hex')); // 输出27d64f37a0f7fca3a63f6ddc39135c01

4. Application de cas Node.js

Enfin, examinons les scénarios d'application spécifiques de Node.js, notamment les serveurs Web, les outils de ligne de commande, les tâches automatisées et les applications de bureau.

(1) Serveur Web

Node.js peut facilement créer un serveur Web et est adapté au traitement de requêtes simultanées élevées, il est donc très approprié pour le développement de serveurs Web.

Par exemple, nous pouvons utiliser Node.js pour créer un site de blog basé sur le framework Express. Le code est le suivant :

const express = require('express');
const path = require('path');
const app = express();
// 设置模板引擎
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'ejs');
// 处理静态资源
app.use(express.static(path.join(__dirname, 'public')));
// 首页
app.get('/', function (req, res) {
    res.render('index', { title: '首页', message: '欢迎来到我的博客！' });
});
// 关于我
app.get('/about', function (req, res) {
    res.render('about', { title: '关于我', message: '我是一名Web前端开发工程师。' });
});
// 联系我
app.get('/contact', function (req, res) {
    res.render('contact', { title: '联系我', message: '欢迎联系我。' });
});
// 启动服务器
app.listen(3000, function () {
    console.log('服务器已经启动，请访问http://localhost:3000');
});

(2) Outils de ligne de commande

Node.js peut facilement développer des outils de ligne de commande, notamment des générateurs de code, des robots d'exploration de données, des outils de surveillance de serveur, etc.

Par exemple, nous pouvons utiliser Node.js pour développer un outil de traduction en ligne de commande. Le code est le suivant :

const request = require('request');
const qs = require('querystring');
const API_URL = 'http://fanyi.baidu.com/v2transapi';
// 命令行输入参数
const word = process.argv[2];
// 发送翻译请求
request.post(API_URL, {
    form: {
        from: 'en', // 翻译源语言为英语
        to: 'zh', // 翻译目标语言为中文
        query: word,
        simple_means_flag: 3, // 返回详细翻译结果
        sign: ''
    }
}, function(err, res, body) {
    const data = JSON.parse(body);
    console.log(data.trans_result.data[0].dst);
});

(3) Tâches automatisées

Node.js est très approprié pour développer des tâches automatisées, telles que des outils de construction, des outils d'inspection de code, des outils de tests unitaires, etc.

Par exemple, nous pouvons utiliser Node.js et Gulp pour créer un outil de construction automatisé permettant de réduire le code JS et CSS. Le code est le suivant :

const gulp = require('gulp');
const uglify = require('gulp-uglify');
const minifyCss = require('gulp-minify-css');
// 压缩JS文件
gulp.task('uglify-js', function () {
    return gulp.src('src/**/*.js')
        .pipe(uglify())
        .pipe(gulp.dest('public'));
});
// 压缩CSS文件
gulp.task('minify-css', function () {
    return gulp.src('src/**/*.css')
        .pipe(minifyCss())
        .pipe(gulp.dest('public'));
});
// 默认任务
gulp.task('default', ['uglify-js', 'minify-css']);

(4) Application de bureau

Node.js convient également au développement d'applications de bureau, en particulier d'applications multiplateformes. Par exemple, Electron est une plate-forme de développement d'applications de bureau multiplateforme basée sur Node. js et Chrome.

Par exemple, nous pouvons développer une simple application de bloc-notes de bureau en utilisant Node.js et Electron. Le code est le suivant :

const electron = require('electron');
const {app, BrowserWindow} = electron; // 控件和事件句柄
let mainWindow; // 主窗口
app.on('ready', function() {
    // 创建主窗口
    mainWindow = new BrowserWindow({ width: 800, height: 600 });
    mainWindow.loadURL(`file://${__dirname}/index.html`);
    // 打开开发者工具
    mainWindow.webContents.openDevTools();
    // 处理窗口关闭事件
    mainWindow.on('closed', function() {
        mainWindow = null;
    });
});

Ce qui précède est l'introduction de base et les scénarios d'application de Node.js. Si vous souhaitez en savoir plus sur Node.js, vous pouvez vous référer à la documentation officielle de Node.js et à divers didacticiels Node.js. .

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!