| title | date | description | author | category | bannerImage | tags | |||
|---|---|---|---|---|---|---|---|---|---|
ExpressJS Cheatsheet 2022 |
2022-04-09 |
Easy reference for using express |
Alex Merced |
javascript |
/images/postbanner/2022/batch-streaming.png |
|
This article assumes basic knowledge of ExpressJS, if your new to Express I recommend starting with the following Video Playlist:
Assuming you have NodeJS installed just open up your IDE to an empty folder and do the following in terminal:
-
Create a new node project
npm init -y -
install dependencies
npm install express morgan dotenv -
if you don't have nodemon installed globally, do so
npm install -g nodemon -
create your initial server file, gitignore and env file
touch server.js .env .gitignore -
put the following in the .gitignore file
.env
/node_modules
- put the following in the .env file, this file is for defining variables you don't want in your code and not in public view (api keys, database credentials, sensitive stuff) or variables that should change depending on the context.
PORT=5000
Could of useful things we can do in the package.json:
- We can add scripts, you can add as many as you like but here is basics I'd recommend.
"scripts: {
"start": "node server.js",
"dev": "nodemon server.js"
}scripts can be run using the commands npm run <command name> for example we can run the dev script with npm run dev.
- We can also choose whether we will use commonjs or module syntax, commonjs will be the default if we do nothing, but if we add
"type":"module"to the package.json then we can use module syntax. This effects how we import and export things.
| Task | CommonJS | ES Module |
|---|---|---|
| Importing Dependency/File | const something = require("something") |
import something from "something" |
| Exporting from a file | module.exports = something |
export default something |
Which you prefer is your own preference, just be aware you may not be able to import JSON files with ES Modules in older versions (or use ES Modules at all in really old versions) of node and use an experimental flag to do so in newer versions.
CommonJS Version
// bring in environment variables from a .env file
require("dotenv").config()
// import express and morgan
const express = require("express")
const express = require("morgan")
// create an application object
const app = express()
// define a PORT variable from the environment with a default value
const PORT = process.env.PORT || 4000
/////////////////////////////////////
// ALL YOUR MIDDLEWARE AND ROUTES GO HERE
app.use(morgan("tiny")) // middleware for logging
app.use(express.urlencoded({extended: true})) //middleware for parsing urlencoded data
app.use(express.json()) // middleware for parsing incoming json
app.use("/static", express.static("static")) // to set a folder for static file serving
/////////////////////////////////////
// Server Listener
app.listen(PORT, () => console.log(`Listening on port ${PORT}`))ES Module Version
// Bring in environmental variables
import dotenv from "dotenv"
dotenv.config()
// import express and morgan
import express from "express"
import morgan from "morgan"
// create an application object
const app = express()
// define a PORT variable from the environment with a default value
const PORT = process.env.PORT || 4000
/////////////////////////////////////
// ALL YOUR MIDDLEWARE AND ROUTES GO HERE
app.use(morgan("tiny")) // middleware for logging
app.use(express.urlencoded({extended: true})) //middleware for parsing urlencoded data
app.use(express.json()) // middleware for parsing incoming json
app.use("/static", express.static("static")) // to set a folder for static file serving
/////////////////////////////////////
// Server Listener
app.listen(PORT, () => console.log(`Listening on port ${PORT}`))Middleware are just functions that receive three arguments:
reqthe request object, more on this laterresthe response object, more on this laternexta function that passes the req/res objects to the next middleware or route.
Here is an example of the simplest middleware
const middlewareFunction = (req, res, next) => {
console.log("This is middleware")
}The middleware functions can be registered using the .use method of the application object or routers.
// using the middleware on all requests
app.use(middlewareFunction)
// using the middleware on certain urls
app.use("/endpoint", middlewareFunction)Other popular middleware not in the previous code snippets include:
- CORS For setting cors settings for API's
- Method Override To override the request method on form submissions
- express-session For setting up session cookies
And many others...
Routes determine what is the servers response to in an incoming request. A route is created by using one of the following methods on the application object or a router:
.allfor requests of any method.getfor GET requests.postfor POST requests.putfor PUT requests.deletefor DELETE requests
All of these functions take two arguments:
- the endpoint
- a "action", "Controller" or "Route Handler" function that takes
reqandresas arguments
Here is an example:
// writing pass an anonymous function
app.get("/endpoint", (req, res) => {
res.send("The Response")
})
// using a named function
function routeHandler(req, res){
res.send("the response")
}
app.get("/endpoint", routeHandler)The request object represents the data from the incoming request and is passed to all middleware and route handlers.
-req.headers object with the headers of the incoming request
-req.params object with any route params
-req.query object with any key/values from a url query string
-req.body object key/values of the request body (parsed by the express.urlencoded or express.json middleware)
-req.method the method of the request as string
plus much more
The response object is an object that is used to help author the response to the request. Primarily made up of helper functions for different types of responses.
-res.send will send a text, html or json request depending on what is passed to it
-res.json send a javascript object or array as a json response
-res.renderrenders an html response from a template
Templates allow you to generate html responses dynamically, there are several templating engines that can be used, here are few articles to see how to use them.
To render a template we use the res.render function which takes two arguments:
- the name of the the file to locate in the views folder
- javascript object with data that can be used in the rendering of the template (each templating language should have its own way of using the data from the object in the template)
You can group routes together using routers which can be used for organization and to apply middleware to a specific group of routes.
Creating a Router
// create the router object
const router = express.Router()
// register it with the application for routes with a certain prefix
app.use("/prefex", router)Just like the application object you can register middlewares routes with the router
// router specific middleware
router.use(middlewareFunction)
// registering routes
router.get("/endpoint", routerHandler) // url is /prefix/endpointThe following libraries can help you connect to different databases.
- mongoose for connecting to a mongo database mongoose blog
- sequalize ORM for SQL databases (postgres, mysql, etc.)
- objection ORM for SQL databases (postgres, mysql, etc.)
- waterline ORM for SQL databases (postgres, mysql, etc.)
Keep in mind you can't use fetch natively in node, and jQuery is only a frontend library. But you have some options.
- node-fetch A library that replicates the browsers fetch function
- Axios A library for making API Calls
- GOT a library for making api calls
- needle another http client library