Category: expressjs

ExpressJS – Sessions ”; Previous Next HTTP is stateless; in order to associate a request to any other request, you need a way to store user data between HTTP requests. Cookies and URL parameters are both suitable ways to transport data between the client and the server. But they are both readable and on the client side. Sessions solve exactly this problem. You assign the client an ID and it makes all further requests using that ID. Information associated with the client is stored on the server linked to this ID. We will need the Express-session, so install it using the following code. npm install –save express-session We will put the session and cookie-parser middleware in place. In this example, we will use the default store for storing sessions, i.e., MemoryStore. Never use this in production environments. The session middleware handles all things for us, i.e., creating the session, setting the session cookie and creating the session object in req object. Whenever we make a request from the same client again, we will have their session information stored with us (given that the server was not restarted). We can add more properties to the session object. In the following example, we will create a view counter for a client. var express = require(”express”); var cookieParser = require(”cookie-parser”); var session = require(”express-session”); var app = express(); app.use(cookieParser()); app.use(session({secret: “Shh, its a secret!”})); app.get(”/”, function(req, res){ if(req.session.page_views){ req.session.page_views++; res.send(“You visited this page ” + req.session.page_views + ” times”); } else { req.session.page_views = 1; res.send(“Welcome to this page for the first time!”); } }); app.listen(3000); What the above code does is, when a user visits the site, it creates a new session for the user and assigns them a cookie. Next time the user comes, the cookie is checked and the page_view session variable is updated accordingly. Now if you run the app and go to localhost:3000, the following output will be displayed. If you revisit the page, the page counter will increase. The page in the following screenshot was refreshed 42 times. Print Page Previous Next Advertisements ”;

ExpressJS – Form data ”; Previous Next Forms are an integral part of the web. Almost every website we visit offers us forms that submit or fetch some information for us. To get started with forms, we will first install the body-parser(for parsing JSON and url-encoded data) and multer(for parsing multipart/form data) middleware. To install the body-parser and multer, go to your terminal and use − npm install –save body-parser multer Replace your index.js file contents with the following code − var express = require(”express”); var bodyParser = require(”body-parser”); var multer = require(”multer”); var upload = multer(); var app = express(); app.get(”/”, function(req, res){ res.render(”form”); }); app.set(”view engine”, ”pug”); app.set(”views”, ”./views”); // for parsing application/json app.use(bodyParser.json()); // for parsing application/xwww- app.use(bodyParser.urlencoded({ extended: true })); //form-urlencoded // for parsing multipart/form-data app.use(upload.array()); app.use(express.static(”public”)); app.post(”/”, function(req, res){ console.log(req.body); res.send(“recieved your request!”); }); app.listen(3000); After importing the body parser and multer, we will use the body-parser for parsing json and x-www-form-urlencoded header requests, while we will use multer for parsing multipart/form-data. Let us create an html form to test this out. Create a new view called form.pug with the following code − html html head title Form Tester body form(action = “/”, method = “POST”) div label(for = “say”) Say: input(name = “say” value = “Hi”) br div label(for = “to”) To: input(name = “to” value = “Express forms”) br button(type = “submit”) Send my greetings Run your server using the following. nodemon index.js Now go to localhost:3000/ and fill the form as you like, and submit it. The following response will be displayed − Have a look at your console; it will show you the body of your request as a JavaScript object as in the following screenshot − The req.body object contains your parsed request body. To use fields from that object, just use them like normal JS objects. This is the most recommended way to send a request. There are many other ways, but those are irrelevant to cover here, because our Express app will handle all those requests in the same way. To read more about different ways to make a request, have a look at this page. Print Page Previous Next Advertisements ”;

ExpressJS – Authentication ”; Previous Next Authentication is a process in which the credentials provided are compared to those on file in a database of authorized users” information on a local operating system or within an authentication server. If the credentials match, the process is completed and the user is granted authorization for access. For us to create an authentication system, we will need to create a sign up page and a user-password store. The following code creates an account for us and stores it in memory. This is just for the purpose of demo; it is recommended that a persistent storage (database or files) is always used to store user information. var express = require(”express”); var app = express(); var bodyParser = require(”body-parser”); var multer = require(”multer”); var upload = multer(); var session = require(”express-session”); var cookieParser = require(”cookie-parser”); app.set(”view engine”, ”pug”); app.set(”views”,”./views”); app.use(bodyParser.json()); app.use(bodyParser.urlencoded({ extended: true })); app.use(upload.array()); app.use(cookieParser()); app.use(session({secret: “Your secret key”})); var Users = []; app.get(”/signup”, function(req, res){ res.render(”signup”); }); app.post(”/signup”, function(req, res){ if(!req.body.id || !req.body.password){ res.status(“400”); res.send(“Invalid details!”); } else { Users.filter(function(user){ if(user.id === req.body.id){ res.render(”signup”, { message: “User Already Exists! Login or choose another user id”}); } }); var newUser = {id: req.body.id, password: req.body.password}; Users.push(newUser); req.session.user = newUser; res.redirect(”/protected_page”); } }); app.listen(3000); Now for the signup form, create a new view called signup.jade. SIGNUP.JADE html head title Signup body if(message) h4 #{message} form(action = “/signup” method = “POST”) input(name = “id” type = “text” required placeholder = “User ID”) input(name = “password” type = “password” required placeholder = “Password”) button(type = “Submit”) Sign me up! Check if this page loads by visiting localhost:3000/signup. We have set the required attribute for both fields, so HTML5 enabled browsers will not let us submit this form until we provide both id and password. If someone tries to register using a curl request without a User ID or Password, an error will be displayed. Create a new file called protected_page.pug in views with the following content − html head title Protected page body div Hey #{id}, How are you doing today? div Want to log out? div Logout This page should only be visible if the user has just signed up or logged in. Let us now define its route and also routes to log in and log out − var express = require(”express”); var app = express(); var bodyParser = require(”body-parser”); var multer = require(”multer”); var upload = multer(); var session = require(”express-session”); var cookieParser = require(”cookie-parser”); app.set(”view engine”, ”pug”); app.set(”views”,”./views”); app.use(bodyParser.json()); app.use(bodyParser.urlencoded({ extended: true })); app.use(upload.array()); app.use(cookieParser()); app.use(session({secret: “Your secret key”})); var Users = []; app.get(”/signup”, function(req, res){ res.render(”signup”); }); app.post(”/signup”, function(req, res){ if(!req.body.id || !req.body.password){ res.status(“400”); res.send(“Invalid details!”); } else { Users.filter(function(user){ if(user.id === req.body.id){ res.render(”signup”, { message: “User Already Exists! Login or choose another user id”}); } }); var newUser = {id: req.body.id, password: req.body.password}; Users.push(newUser); req.session.user = newUser; res.redirect(”/protected_page”); } }); function checkSignIn(req, res){ if(req.session.user){ next(); //If session exists, proceed to page } else { var err = new Error(“Not logged in!”); console.log(req.session.user); next(err); //Error, trying to access unauthorized page! } } app.get(”/protected_page”, checkSignIn, function(req, res){ res.render(”protected_page”, {id: req.session.user.id}) }); app.get(”/login”, function(req, res){ res.render(”login”); }); app.post(”/login”, function(req, res){ console.log(Users); if(!req.body.id || !req.body.password){ res.render(”login”, {message: “Please enter both id and password”}); } else { Users.filter(function(user){ if(user.id === req.body.id && user.password === req.body.password){ req.session.user = user; res.redirect(”/protected_page”); } }); res.render(”login”, {message: “Invalid credentials!”}); } }); app.get(”/logout”, function(req, res){ req.session.destroy(function(){ console.log(“user logged out.”) }); res.redirect(”/login”); }); app.use(”/protected_page”, function(err, req, res, next){ console.log(err); //User should be authenticated! Redirect him to log in. res.redirect(”/login”); }); app.listen(3000); We have created a middleware function checkSignIn to check if the user is signed in. The protected_page uses this function. To log the user out, we destroy the session. Let us now create the login page. Name the view as login.pug and enter the contents − html head title Signup body if(message) h4 #{message} form(action = “/login” method = “POST”) input(name = “id” type = “text” required placeholder = “User ID”) input(name = “password” type = “password” required placeholder = “Password”) button(type = “Submit”) Log in Our simple authentication application is now complete; let us now test the application. Run the app using nodemon index.js, and proceed to localhost:3000/signup. Enter a Username and a password and click sign up. You will be redirected to the protected_page if details are valid/unique − Now log out of the app. This will redirect us to the login page − This route is protected such that if an unauthenticated person tries to visit it, he will be redirected to our login page. This was all about basic user authentication. It is always recommended that we use a persistent session system and use hashes for password transport. There are much better ways to authenticate users now, leveraging JSON tokens. Print Page Previous Next Advertisements ”;

ExpressJS – RESTFul APIs ”; Previous Next An API is always needed to create mobile applications, single page applications, use AJAX calls and provide data to clients. An popular architectural style of how to structure and name these APIs and the endpoints is called REST(Representational Transfer State). HTTP 1.1 was designed keeping REST principles in mind. REST was introduced by Roy Fielding in 2000 in his Paper Fielding Dissertations. RESTful URIs and methods provide us with almost all information we need to process a request. The table given below summarizes how the various verbs should be used and how URIs should be named. We will be creating a movies API towards the end; let us now discuss how it will be structured. Method URI Details Function GET /movies Safe, cachable Gets the list of all movies and their details GET /movies/1234 Safe, cachable Gets the details of Movie id 1234 POST /movies N/A Creates a new movie with the details provided. Response contains the URI for this newly created resource. PUT /movies/1234 Idempotent Modifies movie id 1234(creates one if it doesn”t already exist). Response contains the URI for this newly created resource. DELETE /movies/1234 Idempotent Movie id 1234 should be deleted, if it exists. Response should contain the status of the request. DELETE or PUT /movies Invalid Should be invalid. DELETE and PUT should specify which resource they are working on. Let us now create this API in Express. We will be using JSON as our transport data format as it is easy to work with in JavaScript and has other benefits. Replace your index.js file with the movies.js file as in the following program. index.js var express = require(”express”); var bodyParser = require(”body-parser”); var multer = require(”multer”); var upload = multer(); var app = express(); app.use(cookieParser()); app.use(bodyParser.json()); app.use(bodyParser.urlencoded({ extended: true })); app.use(upload.array()); //Require the Router we defined in movies.js var movies = require(”./movies.js”); //Use the Router on the sub route /movies app.use(”/movies”, movies); app.listen(3000); Now that we have our application set up, let us concentrate on creating the API. Start by setting up the movies.js file. We are not using a database to store the movies but are storing them in memory; so every time the server restarts, the movies added by us will vanish. This can easily be mimicked using a database or a file (using node fs module). Once you import Express then, create a Router and export it using module.exports − var express = require(”express”); var router = express.Router(); var movies = [ {id: 101, name: “Fight Club”, year: 1999, rating: 8.1}, {id: 102, name: “Inception”, year: 2010, rating: 8.7}, {id: 103, name: “The Dark Knight”, year: 2008, rating: 9}, {id: 104, name: “12 Angry Men”, year: 1957, rating: 8.9} ]; //Routes will go here module.exports = router; GET routes Let us define the GET route for getting all the movies − router.get(”/”, function(req, res){ res.json(movies); }); To test out if this is working fine, run your app, then open your terminal and enter − curl -i -H “Accept: application/json” -H “Content-Type: application/json” -X GET localhost:3000/movies The following response will be displayed − [{“id”:101,”name”:”Fight Club”,”year”:1999,”rating”:8.1}, {“id”:102,”name”:”Inception”,”year”:2010,”rating”:8.7}, {“id”:103,”name”:”The Dark Knight”,”year”:2008,”rating”:9}, {“id”:104,”name”:”12 Angry Men”,”year”:1957,”rating”:8.9}] We have a route to get all the movies. Let us now create a route to get a specific movie by its id. router.get(”/:id([0-9]{3,})”, function(req, res){ var currMovie = movies.filter(function(movie){ if(movie.id == req.params.id){ return true; } }); if(currMovie.length == 1){ res.json(currMovie[0]) } else { res.status(404);//Set status to 404 as movie was not found res.json({message: “Not Found”}); } }); This will get us the movies according to the id that we provided. To check the output, use the following command in your terminal − curl -i -H “Accept: application/json” -H “Content-Type: application/json” -X GET localhost:3000/movies/101 You”ll get the following response − {“id”:101,”name”:”Fight Club”,”year”:1999,”rating”:8.1} If you visit an invalid route, it will produce a cannot GET error while if you visit a valid route with an id that doesn’t exist, it will produce a 404 error. We are done with the GET routes, let us now move on to the POST route. POST route Use the following route to handle the POSTed data − router.post(”/”, function(req, res){ //Check if all fields are provided and are valid: if(!req.body.name || !req.body.year.toString().match(/^[0-9]{4}$/g) || !req.body.rating.toString().match(/^[0-9].[0-9]$/g)){ res.status(400); res.json({message: “Bad Request”}); } else { var newId = movies[movies.length-1].id+1; movies.push({ id: newId, name: req.body.name, year: req.body.year, rating: req.body.rating }); res.json({message: “New movie created.”, location: “/movies/” + newId}); } }); This will create a new movie and store it in the movies variable. To check this route, enter the following code in your terminal − curl -X POST –data “name = Toy%20story&year = 1995&rating = 8.5” http://localhost:3000/movies The following response will be displayed − {“message”:”New movie created.”,”location”:”/movies/105″} To test if this was added to the movies object, Run the get request for /movies/105 again. The following response will be displayed − {“id”:105,”name”:”Toy story”,”year”:”1995″,”rating”:”8.5″} Let us move on to create the PUT and DELETE routes. PUT route The PUT route is almost the same as the POST route. We will be specifying the id for the object that”ll be updated/created. Create the route in the following way. router.put(”/:id”, function(req, res){ //Check if all fields are provided and are valid: if(!req.body.name || !req.body.year.toString().match(/^[0-9]{4}$/g) || !req.body.rating.toString().match(/^[0-9].[0-9]$/g) || !req.params.id.toString().match(/^[0-9]{3,}$/g)){ res.status(400); res.json({message: “Bad Request”}); } else { //Gets us the index of movie with given id. var updateIndex = movies.map(function(movie){ return movie.id; }).indexOf(parseInt(req.params.id)); if(updateIndex === -1){ //Movie not found, create new movies.push({ id: req.params.id, name: req.body.name, year: req.body.year, rating: req.body.rating }); res.json({message: “New movie created.”, location: “/movies/” + req.params.id}); } else { //Update existing movie movies[updateIndex] = { id: req.params.id, name: req.body.name, year: req.body.year, rating: req.body.rating }; res.json({message: “Movie id ” + req.params.id + ” updated.”, location: “/movies/” + req.params.id}); } } }); This route will perform the function specified in the above table. It will update the object with new details if it exists. If it doesn”t exist, it will create a new object. To check the route, use the following curl command. This

ExpressJS – Resources ”; Previous Next This chapter lists down the various resources we used for this tutorial. The most important link is of course the Express API docs − https://expressjs.com/en/4x/api.html The guides provided on the Express website on different aspects are also quite helpful − Routing Middleware Error Handling Debugging A list of mostly used middleware with Express is available at https://expressjs.com/en/resources/middleware.html These blogs with Express tips and tricks may prove helpful − https://derickbailey.com/categories/tips-and-tricks/ https://scotch.io/tutorials/learn-to-use-the-new-router-in+-expressjs-4 Application structure − https://www.terlici.com/2014/08/25/best-practices-express-structure.html RESTful APIs − https://www.thepolyglotdeveloper.com/2015/10/create-a-simple-restful-api-with-node-js/ https://scotch.io/tutorials/build-a-restful-api-using-node-and-express-4 https://devcenter.heroku.com/articles/mean-apps-restful-api https://pixelhandler.com/posts/develop-a-restful-api-using-nodejs-with-express-and-mongoose http://cwbuecheler.com/web/tutorials/2014/restful-web-app-node-express-mongodb/ For advanced authentication, use PassportJS − http://passportjs.org Print Page Previous Next Advertisements ”;

ExpressJS – Templating ”; Previous Next Pug is a templating engine for Express. Templating engines are used to remove the cluttering of our server code with HTML, concatenating strings wildly to existing HTML templates. Pug is a very powerful templating engine which has a variety of features including filters, includes, inheritance, interpolation, etc. There is a lot of ground to cover on this. To use Pug with Express, we need to install it, npm install –save pug Now that Pug is installed, set it as the templating engine for your app. You don”t need to ”require” it. Add the following code to your index.js file. app.set(”view engine”, ”pug”); app.set(”views”,”./views”); Now create a new directory called views. Inside that create a file called first_view.pug, and enter the following data in it. doctype html html head title = “Hello Pug” body p.greetings#people Hello World! To run this page, add the following route to your app − app.get(”/first_template”, function(req, res){ res.render(”first_view”); }); You will get the output as − Hello World! Pug converts this very simple looking markup to html. We don’t need to keep track of closing our tags, no need to use class and id keywords, rather use ”.” and ”#” to define them. The above code first gets converted to − <!DOCTYPE html> <html> <head> <title>Hello Pug</title> </head> <body> <p class = “greetings” id = “people”>Hello World!</p> </body> </html> Pug is capable of doing much more than simplifying HTML markup. Important Features of Pug Let us now explore a few important features of Pug. Simple Tags Tags are nested according to their indentation. Like in the above example, <title> was indented within the <head> tag, so it was inside it. But the <body> tag was on the same indentation, so it was a sibling of the <head> tag. We don’t need to close tags, as soon as Pug encounters the next tag on same or outer indentation level, it closes the tag for us. To put text inside of a tag, we have 3 methods − Space seperated h1 Welcome to Pug Piped text div | To insert multiline text, | You can use the pipe operator. Block of text div. But that gets tedious if you have a lot of text. You can use “.” at the end of tag to denote block of text. To put tags inside this block, simply enter tag in a new line and indent it accordingly. Comments Pug uses the same syntax as JavaScript(//) for creating comments. These comments are converted to the html comments(<!–comment–>). For example, //This is a Pug comment This comment gets converted to the following. <!–This is a Pug comment–> Attributes To define attributes, we use a comma separated list of attributes, in parenthesis. Class and ID attributes have special representations. The following line of code covers defining attributes, classes and id for a given html tag. div.container.column.main#division(width = “100”, height = “100”) This line of code, gets converted to the following. − <div class = “container column main” id = “division” width = “100” height = “100”></div> Passing Values to Templates When we render a Pug template, we can actually pass it a value from our route handler, which we can then use in our template. Create a new route handler with the following. var express = require(”express”); var app = express(); app.get(”/dynamic_view”, function(req, res){ res.render(”dynamic”, { name: “TutorialsPoint”, url:”http://www.tutorialspoint.com” }); }); app.listen(3000); And create a new view file in views directory, called dynamic.pug, with the following code − html head title=name body h1=name a(href = url) URL Open localhost:3000/dynamic_view in your browser; You should get the following output − We can also use these passed variables within text. To insert passed variables in between text of a tag, we use #{variableName} syntax. For example, in the above example, if we wanted to put Greetings from TutorialsPoint, then we could have done the following. html head title = name body h1 Greetings from #{name} a(href = url) URL This method of using values is called interpolation. The above code will display the following output. − Conditionals We can use conditional statements and looping constructs as well. Consider the following − If a User is logged in, the page should display “Hi, User” and if not, then the “Login/Sign Up” link. To achieve this, we can define a simple template like − html head title Simple template body if(user) h1 Hi, #{user.name} else a(href = “/sign_up”) Sign Up When we render this using our routes, we can pass an object as in the following program − res.render(”/dynamic”,{ user: {name: “Ayush”, age: “20”} }); You will receive a message − Hi, Ayush. But if we don’t pass any object or pass one with no user key, then we will get a signup link. Include and Components Pug provides a very intuitive way to create components for a web page. For example, if you see a news website, the header with logo and categories is always fixed. Instead of copying that to every view we create, we can use the include feature. Following example shows how we can use this feature − Create 3 views with the following code − HEADER.PUG div.header. I”m the header for this website. CONTENT.PUG html head title Simple template body include ./header.pug h3 I”m the main content include ./footer.pug FOOTER.PUG div.footer. I”m the footer for this website. Create a route for this as follows − var express = require(”express”); var app = express(); app.get(”/components”, function(req, res){ res.render(”content”); }); app.listen(3000); Go to localhost:3000/components, you will receive the following output − include can also be used to include plaintext, css and JavaScript. There are many more features of Pug. But those are out of the scope for this tutorial. You can further explore Pug at Pug. Print Page Previous Next Advertisements ”;

ExpressJS – Middleware ”; Previous Next Middleware functions are functions that have access to the request object (req), the response object (res), and the next middleware function in the application’s request-response cycle. These functions are used to modify req and res objects for tasks like parsing request bodies, adding response headers, etc. Here is a simple example of a middleware function in action − var express = require(”express”); var app = express(); //Simple request time logger app.use(function(req, res, next){ console.log(“A new request received at ” + Date.now()); //This function call is very important. It tells that more processing is //required for the current request and is in the next middleware function route handler. next(); }); app.listen(3000); The above middleware is called for every request on the server. So after every request, we will get the following message in the console − A new request received at 1467267512545 To restrict it to a specific route (and all its subroutes), provide that route as the first argument of app.use(). For Example, var express = require(”express”); var app = express(); //Middleware function to log request protocol app.use(”/things”, function(req, res, next){ console.log(“A request for things received at ” + Date.now()); next(); }); // Route handler that sends the response app.get(”/things”, function(req, res){ res.send(”Things”); }); app.listen(3000); Now whenever you request any subroute of ”/things”, only then it will log the time. Order of Middleware Calls One of the most important things about middleware in Express is the order in which they are written/included in your file; the order in which they are executed, given that the route matches also needs to be considered. For example, in the following code snippet, the first function executes first, then the route handler and then the end function. This example summarizes how to use middleware before and after route handler; also how a route handler can be used as a middleware itself. var express = require(”express”); var app = express(); //First middleware before response is sent app.use(function(req, res, next){ console.log(“Start”); next(); }); //Route handler app.get(”/”, function(req, res, next){ res.send(“Middle”); next(); }); app.use(”/”, function(req, res){ console.log(”End”); }); app.listen(3000); When we visit ”/” after running this code, we receive the response as Middle and on our console − Start End The following diagram summarizes what we have learnt about middleware − Now that we have covered how to create our own middleware, let us discuss some of the most commonly used community created middleware. Third Party Middleware A list of Third party middleware for Express is available here. Following are some of the most commonly used middleware; we will also learn how to use/mount these − body-parser This is used to parse the body of requests which have payloads attached to them. To mount body parser, we need to install it using npm install –save body-parser and to mount it, include the following lines in your index.js − var bodyParser = require(”body-parser”); //To parse URL encoded data app.use(bodyParser.urlencoded({ extended: false })) //To parse json data app.use(bodyParser.json()) To view all available options for body-parser, visit its github page. cookie-parser It parses Cookie header and populate req.cookies with an object keyed by cookie names. To mount cookie parser, we need to install it using npm install –save cookie-parser and to mount it, include the following lines in your index.js − var cookieParser = require(”cookie-parser”); app.use(cookieParser()) express-session It creates a session middleware with the given options. We will discuss its usage in the Sessions section. We have many other third party middleware in ExpressJS. However, we have discussed only a few important ones here. Print Page Previous Next Advertisements ”;

ExpressJS – Cookies ”; Previous Next Cookies are simple, small files/data that are sent to client with a server request and stored on the client side. Every time the user loads the website back, this cookie is sent with the request. This helps us keep track of the user’s actions. The following are the numerous uses of the HTTP Cookies − Session management Personalization(Recommendation systems) User tracking To use cookies with Express, we need the cookie-parser middleware. To install it, use the following code − npm install –save cookie-parser Now to use cookies with Express, we will require the cookie-parser. cookie-parser is a middleware which parses cookies attached to the client request object. To use it, we will require it in our index.js file; this can be used the same way as we use other middleware. Here, we will use the following code. var cookieParser = require(”cookie-parser”); app.use(cookieParser()); cookie-parser parses Cookie header and populates req.cookies with an object keyed by the cookie names. To set a new cookie, let us define a new route in your Express app like − var express = require(”express”); var app = express(); app.get(”/”, function(req, res){ res.cookie(”name”, ”express”).send(”cookie set”); //Sets name = express }); app.listen(3000); To check if your cookie is set or not, just go to your browser, fire up the console, and enter − console.log(document.cookie); You will get the output like (you may have more cookies set maybe due to extensions in your browser) − “name = express” The browser also sends back cookies every time it queries the server. To view cookies from your server, on the server console in a route, add the following code to that route. console.log(”Cookies: ”, req.cookies); Next time you send a request to this route, you will receive the following output. Cookies: { name: ”express” } Adding Cookies with Expiration Time You can add cookies that expire. To add a cookie that expires, just pass an object with property ”expire” set to the time when you want it to expire. For example, //Expires after 360000 ms from the time it is set. res.cookie(name, ”value”, {expire: 360000 + Date.now()}); Another way to set expiration time is using ”maxAge” property. Using this property, we can provide relative time instead of absolute time. Following is an example of this method. //This cookie also expires after 360000 ms from the time it is set. res.cookie(name, ”value”, {maxAge: 360000}); Deleting Existing Cookies To delete a cookie, use the clearCookie function. For example, if you need to clear a cookie named foo, use the following code. var express = require(”express”); var app = express(); app.get(”/clear_cookie_foo”, function(req, res){ res.clearCookie(”foo”); res.send(”cookie foo cleared”); }); app.listen(3000); In the next chapter, we will see how to use cookies to manage sessions. Print Page Previous Next Advertisements ”;

ExpressJS – Hello World ”; Previous Next We have set up the development, now it is time to start developing our first app using Express. Create a new file called index.js and type the following in it. var express = require(”express”); var app = express(); app.get(”/”, function(req, res){ res.send(“Hello world!”); }); app.listen(3000); Save the file, go to your terminal and type the following. nodemon index.js This will start the server. To test this app, open your browser and go to http://localhost:3000 and a message will be displayed as in the following screenshot. How the App Works? The first line imports Express in our file, we have access to it through the variable Express. We use it to create an application and assign it to var app. app.get(route, callback) This function tells what to do when a get request at the given route is called. The callback function has 2 parameters, request(req) and response(res). The request object(req) represents the HTTP request and has properties for the request query string, parameters, body, HTTP headers, etc. Similarly, the response object represents the HTTP response that the Express app sends when it receives an HTTP request. res.send() This function takes an object as input and it sends this to the requesting client. Here we are sending the string “Hello World!”. app.listen(port, [host], [backlog], [callback]]) This function binds and listens for connections on the specified host and port. Port is the only required parameter here. S.No. Argument & Description 1 port A port number on which the server should accept incoming requests. 2 host Name of the domain. You need to set it when you deploy your apps to the cloud. 3 backlog The maximum number of queued pending connections. The default is 511. 4 callback An asynchronous function that is called when the server starts listening for requests. Print Page Previous Next Advertisements ”;

ExpressJS Tutorial PDF Version Quick Guide Resources Job Search Discussion Express is a minimal and flexible Node.js web application framework that provides a robust set of features for web and mobile applications. It is an open source framework developed and maintained by the Node.js foundation. Audience This tutorial has been created for anyone who has a basic knowledge of HTML, Javascript and how client-servers work. After completing this tutorial, you will be able to build moderately complex websites and back-ends for you mobile applications. Prerequisites You should have basic knowledge of Javascript and HTML. If you are not acquainted with these, we suggest you to go through tutorials on those areas first. It will definitely help, if you have some exposure to HTTP, although it is not mandatory. Having a basic knowledge of MongoDB will help you with the Database chapter. Print Page Previous Next Advertisements ”;