What is Node.js?
•
1 gefällt mir•318 views
Domino v10 development will bring us Node.js integration in the form of the “NERD” stack - Node, Express, React and Domino. Using Node and React programming skills developers will be able to access Domino data via a Domino module running under Node. BUT WHAT IS NODE? In this session Tim explains what Node is, how to work with it, and how Domino developers will be be able to take advantage of this new platform.
Empfohlen
Empfohlen
Weitere ähnliche Inhalte
Ähnlich wie What is Node.js?
Ähnlich wie What is Node.js? (20)
Kürzlich hochgeladen
Kürzlich hochgeladen (20)
What is Node.js?
- 3. So, what is Node.js? • It is a fully programmable server engine • You code it using Javascript • Most of the time it is used as a web server • It can – serve web pages – run APIs – be a networked application – do IoT stuff – be containerized
- 4. Why are we interested? •Will be integrated into Domino 10 •Allows access to Domino data from Node easily •Parallel development path •Extend existing Domino apps – Mobile – New websites – Microservices – Other platforms
- 5. Why use Node to do this? •It is a hugely popular web platform •Part of the MEAN/MERN development stacks •Easy to add modules to do different things •Lots of resources and support out there •JavaScript, so works well with – UI frameworks (Angular, React, etc) – NoSQL datastores (MongoDB, CouchDB, etc) – Domino 10 will be a JavaScript NoSQL datastore
- 7. Can I do JavaScript? •If you have used JavaScript in Domino web forms – maybe client-side validation scripts – or some JQuery •or in XPages server-side JavaScript •…then you will be fine with JavaScript in Node •If you’ve used LotusScript, similar but different syntax – e.g. variables, arrays, loops, functions – …but has new stuff which is really great :-)
- 10. Download the installer •Go to the Node.js website – https://nodejs.org – Download the installer – Run the installer •This installs two separate packages – Node.js runtime – npm package manager • (npm is used to install add-on modules)
- 12. Our first Node server • Lets make a simple Node web server • Start with a project folder to hold everything • Create an empty JavaScript source file in it – server.js • Open this in your favorite code editor – Mine is Visual Studio Code – https://code.visualstudio.com – Others suggest Webstorm • Start writing some code…
- 13. Adding HTTP •This is going to be a web server, so we need to handle HTTP requests. •Node has a built-in HTTP module, so let’s add this in •We do this with the 'require' command const http = require('http'); •We can use 'require' to add any other modules we may need
- 14. Create a server object • Now our Node app knows how to handle HTTP, let’s create a Node HTTP server const server = http.createServer(…); • This will take a function as a parameter • This function is the listener which tells it what to do when it receives a request
- 15. Add a listener const server = http.createServer((req, res) => { res.statusCode = 200; res.setHeader('Content-Type', 'text/plain'); res.end('Hello World!n'); }); • Don’t worry about the strange arrow =>, that is just a different way of saying function, more on this later • This acts on the request req and the response res • Status 200 is 'success OK' • Tells browser to expect some text • Adds our text and tells the server to send the response
- 16. Tell it to start listening const hostname = '127.0.0.1'; const port = 3000; server.listen(port, hostname, () => { console.log(`Server running at http://$ {hostname}:${port}/`); }); •This tells the server to listen on port 3000 and prints a message to the Node console •This is all we need, only 11 lines of code.
- 17. Run our server • Back in terminal or command window • In our project folder, where server.js is, type node server.js • The server starts running • You will see the message displayed in the terminal or command window • Browse to it on http://127.0.0.1:3000 • It says Hello World!
- 20. Turning our server into an app • We use the npm package manager • It does almost all the work for us • Start by initializing our app npm init • This prompts for app name, etc, can just accept defaults • Creates a package.json file – Lists our server.js – Start script is 'node server.js'
- 21. Install Node into our project •We will install Node locally so everything is contained in one folder – (We installed it globally from our download earlier) •Install by typing npm install node •Creates new folder node_modules
- 24. Modify our server.js •Replace Node's http module with express const express = require('express') •Instead of the http server, we create an Express app const app = express()
- 25. Add a route •Routes are pattern matches for incoming URIs – Sort of like Domino Web Site Rules •Can have multiple routes to do different things •Our route will listen for a regular browser 'get' request app.get('/', (req, res) => { res.send('Hello World!') } ) •The '/' means the root of our web server
- 26. Tell app to start listening •Basically the same as the http version app.listen(port, hostname, () => { console.log(`Server running at http://$ {hostname}:${port}/`); }); •Only 10 lines of code! •Run is same as before npm start
- 29. Display a web page •We can display static files from the file system – These could be an Angular or React app •Put these in a 'public' sub folder •Default is index.html •Add a route pointing to this sub folder app.use(express.static(__dirname + '/public')); •Requests hitting the root of the server '/' are redirected here
- 30. Catch-all route • We can add a catch-all route after our static route, or any other routes we may use • This will handle any other URLs people use and avoids 404 errors. • We use a '/*' pattern to match anything app.get('/*', (req, res) => { res.send('Another part of the site') }) • The '/' is first redirected by our static route, anything else will be caught by this route
- 31. What about Domino? • Install the Domino DB connector npm install dominodb • Will be able to use code something like this in your routes: const { domServer } = require('domino-db'); domServer(serverConfig).then( async (server) => { const db = await server.useDatabase(dbConfig); const docs = await db.bulkReadDocuments(query); } • The query can be the new Domino General Query Framework • NDA, but for more on this, see John Curtis' session Weds 11am
- 33. That's it •What follows is more detail about Javascript – JSON – let and const – Arrow functions – Async behaviour •No time for it now, but you can read it later – Email: tim@turtlepartnership.com – Blog: https://turtleblog.info
- 34. What else do we need to know? • That is a basic Node app built • Now I want to talk about some general JavaScript terms and concepts • JavaScript is improving all the time with new features that are used in Node • You will see them in examples and articles • Knowing about these will make your life easier when starting out
- 36. Sample JSON let myJson = { "name":"Tim", "myArray": [ { "itemid":"0001" }, { "itemid":"0002" }, { "itemid":"0003" } ], "quantity":5 }
- 37. Using JSON •Can be passed around, used as parameters •Can reference it by name and use dot notation to access or update properties let myJson = {}; myJson.name = "Bob"; doSomethingWith( myJson.myArray[2].itemid ); const myString = JSON.stringify(myJson);
- 39. let and const •These are almost always better than 'var' – 'var' applies to whole enclosing function •'let' is like 'var' but the variable is limited to the current code block, i.e. inside the curly brackets {} – Can't let an existing let – Helps avoid confusion •'const' is for values that will not change – Get error if try to set another value
- 40. Arrow functions => •The arrow is similar to the traditional 'function', so (arg1, arg2) => { ..code.. } – kind of works like: function ( arg1, arg2 ) { ..code.. } •Difference is when you use 'this' – with 'function', the 'this' is what calls the function – with '=>', the 'this' is from outside what calls the function – (More or less, it's worth reading up on) •Great when passing functions as parameters in Node modules, where you want 'this' to be the overall node app
- 42. Async example function getDataAsync() { … do a lookup … console.log("got data"); } console.log("start"); getDataAsync(); console.log("finish"); • The output is: start finish got data
- 43. Callbacks •The original way async functions allowed you to handle them: myAsyncFunction( callback ) {…} •Callback is a function that is called when the async function finishes. •It usually receives the result of the async function as a parameter •You can get a confusing chain of callbacks if you want to do async stuff with the results
- 44. Promises • More readable • Passes results to next function in a chain with '.then' doAsync1() .then( (result1) => { return getAsync2(result1); }) .then( (result2) => { return getAsync3(result2); }) .then( (result3) => { etc } ) .catch( (error) => { handle error } ) • You can create your own Promise function by wrapping your async code with 'resolve' and 'reject'
- 45. Promise.all • How to handle multiple async processes in order? • E.g. collection of documents, each of which needs handling in an async way • Array of promises, then Promise.all to run them in order var promises = []; for (var i = 0; i < collection.length; i++) { promises.push( doAsyncStuff(collection[i]) ); } Promise.all(promises).then( function (results) { //'results' is array of results in order }
- 46. Async / Await •Latest way of handling async functions async function doAsyncStuff() { const value1 = await asyncFunction1(); const value2 = await asyncFunction2( value1 ); } •Avoids chains of callbacks or .thens •Can use regular try/catch for error handling •Can await your own promise functions