Node.js を使用してアプリケーションを構築する方法

Node.js は、サーバー側アプリケーションを構築するためにサーバー側で JavaScript コードを実行できるランタイム環境です。高速でスケーラブルなアプリケーションの作成に適しています。

この記事では、例として単純なイベント管理アプリを使用して、Node.js、Express.js、MongoDB を使用してアプリケーションを構築する方法を説明します。

最後には、Node.js プロジェクトのセットアップ方法、Express.js でサーバーの作成方法、埋め込み JavaScript で動的ページを表示する方法、MongoDB データベースに接続してデータを処理する方法がわかります。

学べること

• Node.js プロジェクトのセットアップ
• Express.js を使用したサーバーの作成
• ejs を使用した動的ページのレンダリング
• MongoDB データベースへの接続
• データのモデルとスキーマの作成
• HTTP リクエストとレスポンスの処理

前提条件

• Node.js がシステムにインストールされています。
• MongoDB についてよく理解していること。
• Visual Studio Code や Sublime Text など、お好みのコード エディター。

ステップ 1: 開発環境をセットアップする

Node.js と npm をインストールする

まず、Node.js をダウンロードしてインストールする必要があります。その後、node -v および npm -v を実行してインストールを確認できます。

新しいプロジェクトを初期化する

プロジェクト用に新しいディレクトリを作成します。次に、ターミナルで npm: npm init -y を使用してプロジェクトを初期化します。

mkdir event-app
cd event-app
npm init -y

npm init -y を実行すると、上に示すように package.json ファイルが作成されます。このファイルは重要です。アプリケーションに必要なすべてのサードパーティ ライブラリ (依存関係) を保存および追跡します。

ステップ 2: サーバーをセットアップする

サーバーをセットアップするには、server.js または app.js というファイルを作成します。これらは一般的な名前です。これらは説明的な性質のために使用されます。ただし、ファイルには好きな名前を付けることができます。

server.js ファイルは、アプリケーション内の必要なページの管理、制御、およびルーティングに使用されるサーバーの作成に使用されます。

ステップ 3: Express.js のインストールとセットアップ

Express.js は、Node.js の人気のある Web アプリケーション フレームワークであり、アプリケーションで使用するサードパーティ ライブラリです。

Express は、HTTP リクエストのさまざまなルートの処理と定義を簡素化します。これにより、アプリケーションのルーティングを管理し、サーバーに接続できるようになります。

エクスプレスを使用するには:

ターミナルで次のコマンドを実行して、Express.js をインストールします。

npm install express

server.js ファイルに Express が必要です。

const express = require('express')

アプリケーションで使用できるように Express を初期化します。

const app = express()

HTTP リクエストを取得するためのルーティング パスを作成します。

//routing path
app.get('/', (req, res) => {
  res.send('Hello World!');
});

最後に、サーバーへの接続が正しく設定されていることを確認する必要があります。ターミナルでサーバーを起動すると、ブラウザーで開きます。

これを行うには、listen() メソッドを使用します。

// Start the server
app.listen(3000, () => {
  console.log('Server started on port 3000');
});

このメソッドはサーバーからのリクエストを listen() します。

完全なコードプロセスは次のとおりです:

const express = require('express');


// Next initialize the application
const app = express();

// routing path
app.get('/', (req, res) => {
  res.send('Hello World!');
});

// Start the server
app.listen(3000, () => {
  console.log('Server started on port 3000');
});

注: 上記のルーティング パスは、サーバーが動作し、接続されていることを確認するためのテストのみを目的としています。作成中のイベント アプリには別のファイルを提供します。

Express.js をアプリケーションにインストールすると、すべてのルーティングと接続を処理するサーバーを作成できます。

サーバーを起動するには、ターミナルに移動します。

キーワード ノードを使用し、--watch と入力します。これは、変更を加えるたびにサーバーを起動し、自動的に再起動するためのフラグです。

node --watch server.js

または、同じ目的でnodemonをインストールすることもできます。 nodemon はディレクトリ内の変更を検出し、アプリケーションを再起動します。

npm install -g nodemon

次に、次のコマンドでサーバーを実行します。

nodemon server.js

ステップ 4: 動的テンプレートを作成する

Node.js を使用してブラウザーで HTML コードをレンダリングするには、テンプレート エンジンが必要です。このチュートリアルでは ejs (Embedded JavaScript) を使用しますが、Pug (旧名 Jade) や Express Handlebar など、サーバー上で HTML をレンダリングするものもあります。

ejs を使用すると、JavaScript を HTML に埋め込んで動的な Web ページを作成できます。

ejs をインストールするには、次のコマンドを実行します。

npm install ejs

server.js で ejs をセットアップするには、テンプレート エンジンとして ejs を要求および設定します。

const express = require('express');
const app = express();
app.set('view engine', 'ejs');

この設定により、Node.js アプリケーションで HTML コードの動的レンダリングを有効にすることができます。

ステップ 5: データを MongoDB に保存する

アプリケーション用に作成したデータを保存するには、MongoDB を使用します。

MongoDB is a "Not Only SQL" (NoSQL) database that's designed for storing document collections. Traditional SQL databases organize data into tables, but MongoDB is optimised for handling large volumes of data.

To read more about this, check out this article.

Step 6: Connect to the Database

Now we need to connect to the database which will be MongoDB for this tutorial.

Using MongoDB provides you with a Uniform Resource Locator (URL) to connect to your application. This URL connect you and acts as a communicator between the database and your application.

How to get the URL

To get the URL, follow these simple steps:

1. Sign Up/Log In: Go to the MongoDB website and sign up for an account or log in if you already have one.

2. Create a Cluster: Once logged in, create a new cluster. This will set up your database.

3. Connect to Your Cluster: After your cluster is created, click the "Connect" button.

4. Choose a Connection Method: Select "Connect your application".

5. Copy the Connection String: MongoDB will provide a connection string (URL) like this:
   

mongodb+srv://<username>:<password>@cluster0.mongodb.net/<dbname>?retryWrites=true&w=majority

6.Replace the Placeholders: Replace with your actual username, password, and database name.

Now that you have the URL, you can easily connect to your database.

To make this connection easier, we will use a tool called Mongoose.

What is Mongoose?

Mongoose is a JavaScript library that makes it easier to work with MongoDB in a Node.js environment. It provides a simple way to model your data. You can also define schemas, do data validation, and build queries.

How to make a connection

MongoDB has already provided you with a URL for connection. Now you'll use Mongoose to send your documents to the database.

To use Mongoose in your project, follow these steps:

Install Mongoose using npm.

npm i mongoose

In your server.js file, you need to require Mongoose to use it as a connector to the database.

const mongoose = require('mongoose');

After you require Mongoose, you need to define the connection URL provided in your server.js file.

server.js:

const mongoose = require('mongoose');

// Replace <username>, <password>, and <dbname> with your actual credentials
const dbURL = 'mongodb+srv://<username>:<password>@cluster0.mongodb.net/<dbname>?retryWrites=true&w=majority';

mongoose
  .connect(process.env.dbURL)
  .then((result) => {
    console.log('Connected to MongoDB');
    app.listen(3000, () => {
      console.log('Server started on port 3000');
    });
  })
  .catch((err) => {
    console.error('Could not connect to MongoDB:', err);
  });

This setup ensures that Mongoose acts as the connector. It connects your application to the MongoDB database.

Step 7: Create the Model for the Document Structure

Next, we need to create a model document called a Schema so that when you post data to your database it will be saved accordingly.

To create this model:

• Create a folder named models to keep your application organized.
• Inside the model's folder, create a file called event.js.

In the event.js file, you will use Mongoose to define the schema for the event documents. You'll specify the structure and data types for the documents you will send to your database.

Here's the event.js file created inside the model folder:

const mongoose = require('mongoose');

// Schema
const EventSchema = new mongoose.Schema(
  {
    title: {
      type: String,
      required: true,
    },
    date: {
      type: Date,
      required: true,
    },
    organizer: {
      type: String,
      required: true,
    },
    price: {
      type: String,
      required: true,
    },
    time: {
      type: String,
      required: true,
    },
    location: {
      type: String,
      required: true,
    },
    description: {
      type: String,
      required: true,
    },
  },
  { timestamps: true }
);

const Event = mongoose.model('event', EventSchema);

module.exports = Event;

When this is done, export so you can use it in your server.js file by simply using the require keyword.

With the schema created, it can now be exported to the server.js file.

Your server.js will look like this:

const express = require('express');
const ejs = require('ejs');
const mongoose = require('mongoose');
const Event = require('../models/Events');// the event.js file

Step 8: Create HTML Pages

As we talked about earlier, we're using ejs in step 4 to render HTML code, allowing us to view the code in the browser.

Form Page
First, let's create a form page. With the form page created, you'll be able to make POST requests which will enable you to send data to your MongoDB database.

To create a basic form, ensure it includes:

• An action attribute which specifies the route to send the data.

• A method attribute which specifies the HTTP request method – in this case, the POST request.

A basic form:

<form action="/submit-event" method="POST">
    <h2>Event Creation Form</h2>
  <label for="title">Title</label>
  <input type="text" id="title" name="title" required>

  <label for="date">Date</label>
  <input type="date" id="date" name="date" required>

  <label for="organizer">Organizer</label>
  <input type="text" id="organizer" name="organizer" required>

  <label for="price">Price</label>
  <input type="text" id="price" name="price" required>

  <label for="time">Time</label>
  <input type="text" id="time" name="time" required>

  <label for="location">Location</label>
  <input type="text" id="location" name="location" required>

  <label for="description">Description</label>
  <textarea id="description" name="description" rows="4" required></textarea>

  <button type="submit">Submit</button>
</form>

NB: Make sure to add the name attribute to each input, or it won't post.

The form created above will let you post data to the specified route. You will then process and store it in your database.

Here's the result:

After creating the form page, we need to go back to the server.js file and create a POST request to handle the form submission.

server.js file:

// posting a data

app.post('/submit-event', (req, res) => {
  const event = new Event(req.body);
  event.save()
    .then((result) => {
      res.redirect('/');
    })
    .catch((err) => {
      console.error(err);
    });
});

The Homepage

Now that the form can post data to the database, we can create the homepage to display the created events in the browser.

First, in your server.js file, you need to create a function. It will fetch all the events posted from the form and stored in the database.

Here’s how to set it up:

This is a function created at server.js to fetch all data from the database:

// To get all the event

router.get('/', (req, res) => {
  Event.find()
    .then((result) => {
      res.render('index', { title: 'All event', events: result })
    })
    .catch((err) => {
      console.error(err); 
  })
})

Next, we will dynamically loop through each part using a forEach loop in the homepage file. Since we are using ejs, the HTML file extension will be .ejs.

<div>
  <h2>All events</h2>
  <div>
    <% if (events.length > 0) { %>
      <% events.forEach(event => { %>
        <div>
          <h3><%= event.title %></h3>
          <p><%= event.description %></p>
          <a href="/event/<%= event.id %>">
            Read More
          </a>
        </div>
      <% }) %>
    <% } else { %>
      <p>No events are available at the moment.</p>
    <% } %>
  </div>
</div>

Step 9: Create Partials

Remember that you installed ejs into your application to facilitate more dynamic components. It allows you to break your code down further to be more dynamic.

To further organize your code, you'll use something called Partials.

Partials let you break down your code into scalable, modular, and manageable parts, keeping your HTML organized.

First, let's create a partial for the navbar.

How to Create a Partial:

Inside your views folder, create a new folder named Partials
Inside the partials folder, create a new file called nav.ejs.
Cut out the navbar code from your homepage file and paste it into nav.ejs.

Example:
First, create the Partials folder and file:

Use the <%- include() %> syntax from ejs to include the nav.ejs partial across pages in your application where you want the navbar to appear.

Here's the code:

<!DOCTYPE html>
<html lang="en">
    <%- include('./partial/head.ejs') %>

<body>
    <%- include('./partial/nav.ejs') %>
    <main>
      hello
    </main>
      <%- include('./partial/footer.ejs') %>
</body>
</html>

With this setup, your HTML code will be organized. It will be easy to manage and update components like the navbar across different pages. You can use this approach on other parts of your application. For example, the head tag, footer tag, and other reusable components.

Step 10: Create an Environment Variable File (.Env)

In this tutorial, we'll upload the project to GitHub. You'll protect your port number and MongoDB URL with secure storage. You'll also use an environment variable file, a configuration file known as .env. This file keeps sensitive information safe. It includes passwords and API URLs and prevents exposure.

Here's how to set it up using Node.js:

First, install the dotenv package.

npm i dotenv

Then create a .env file. Inside it, add your PORT number and MongoDB URL. It should look something like this:

PORT=3000
dbURl='mongodb+srv://<username>:<password>@cluster0.mongodb.net/<dbname>?retryWrites=true&w=majority';

Then update your .gitignore file:

/node_modules
.env

Adding .env to your .gitignore ensures that it is not included in your GitHub repository. This tells Git to ignore the .env file when uploading your code.

Then in your server.js file, require the dotenv package. Load the variables with this line at the top of the file:

To require it, simply type:

require('dotenv').config();

This way, you don't need to hardcode the PORT number and MongoDB URL in your server.js file. Instead, you can access them using process.env.PORT and process.env.dbURl.

So your server.js file will be cleaner and not messy ?‍?

require('dotenv').config();
const express = require('express');
const ejs = require('ejs');
const mongoose = require('mongoose');

mongoose
  .connect(process.env.dbURL)
  .then((result) => {
    console.log('Connected to MongoDB');
    app.listen(3000, () => {
      console.log('Server started on port 3000');
    });
  })
  .catch((err) => {
    console.error('Could not connect to MongoDB:', err);
  });

Further Steps

To expand on this basic application, consider adding features such as:

• User authentication

• Event search and filter functionality

• Event editing and deletion

• Notifications for upcoming events

How to Style the Application

If you want to add some styling to your application, follow these steps:

First, create a public folder. Inside this folder, create a style.css file where you will write your custom CSS.

Then in your HTML file, link the style.css file in the

tag as you normally would:

<link rel="stylesheet" href="/style.css">

To ensure your CSS file is served correctly, add the following line to your server.js file:

app.use(express.static('public'));

This application uses Tailwind CSS for styling. But using Tailwind is optional. You can use any CSS framework or write custom CSS to achieve your desired layout.

How to Include Images

All images should be stored in the public folder and referenced in your HTML files. You should also ensure that the public folder is correctly set up in your server.js file to serve static files.

Here's an example of how to serve static files in server.js:

const express = require('express');
const app = express();


// Serve static files from the 'public' folder
app.use(express.static('public'));

Conclusion

Congratulations! You've built a simple application using Node.js, Express.js, ejs, and MongoDB. With these fundamentals, you can expand and enhance your application to meet more specific needs and features.

Feel free to share your progress or ask questions if you encounter any issues.

この記事が役立つと思われた場合は、同様に興味深いと思われる他の人と共有してください。

Twitter、LinkedIn、GitHub で私をフォローして、プロジェクトの最新情報を入手してください

読んでいただきありがとうございます?.

コーディングを楽しんでください!

以上がNode.js を使用してアプリケーションを構築する方法の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。