Visa källa för Node - grundkoden för vår första applikation

Vi ska börja att titta på innehållet i vår <code>app.js</code>-fil. Det är rätt mycket kod här. I alla fall om man betänker att app:en bara skriver ut ett par rader text. Dock så är detta kod som är den grund som behövs oavsett vilken Express-app man än bygger. Så vi kommer inte att behöva lägga till så mycket till den oavsett hur stor eller liten vår slutliga app blir.

== <code>app-js</code> ==
Så här ser vår <code>app-js</code> ut ifrån början:

<syntaxhighlight lang="javascript" line start="1">
var express = require('express');
var path = require('path');
var favicon = require('serve-favicon');
var logger = require('morgan');
var cookieParser = require('cookie-parser');
var bodyParser = require('body-parser');

var routes = require('./routes/index');
var users = require('./routes/users');

var app = express();

// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');

// uncomment after placing your favicon in /public
//app.use(favicon(path.join(__dirname, 'public', 'favicon.ico')));
app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(cookieParser());
app.use(express.static(path.join(__dirname, 'public')));

app.use('/', routes);
app.use('/users', users);

// catch 404 and forward to error handler
app.use(function(req, res, next) {
  var err = new Error('Not Found');
  err.status = 404;
  next(err);
});

// error handlers

// development error handler
// will print stacktrace
if (app.get('env') === 'development') {
  app.use(function(err, req, res, next) {
    res.status(err.status || 500);
    res.render('error', {
      message: err.message,
      error: err
    });
  });
}

// production error handler
// no stacktraces leaked to user
app.use(function(err, req, res, next) {
  res.status(err.status || 500);
  res.render('error', {
    message: err.message,
    error: {}
  });
});

module.exports = app;
</syntaxhighlight>


Pust, det var en hel del kod! Låt oss gå igenom den och försöka få klarhet i vad saker och ting gör...
== <code>require</code> ==
På de första nio raderna har vi massa olika typer av <code>require</code>. Dessa är till för att läsa in koden ifrån de paket som vi lagt till. Genom att säga att de är <code>required</code>, alltså nödvändiga, så ser vi till att vår applikation inte kan dra igång om något av de nödvändiga paketen fattas. <code>require</code> är en extension till JavaScript som ingår i Node.

== Starta igång Express ==
På rad elva skapar vi en instans av express. Detta är själva huvuddelen av framework:et. Det är via denna instans som vi kommer att kommunicera med framework:et.

== Sätta igång mallhanteringen ==
På rad 14-15 ställer vi in vilket mall-paket som ska användas för att generera dynamiska webbsidor. För tillfället kommer vi inte att använda detta. Men det kan lika gärna vara kvar för framtida bruk.

== Initiera Express ==
Rad 17-23 ställer in vilka olika paket som Express ska använda sig av. Vi ställer in hur man ska logga vad appen gör för något. Vi ställer in hur man ska tolka JSON och cookies. Sen talar vi om var statiskt material ska hämtas ifrån.

== Koppla webbanrop till kod ==
Nu på rad 25 - 26 kommer vi till den intressanta biten! Här väljer vilka URL-fragment som ska mappas till kod på vår server. Vi läste in koden som ska användas redan på rad åtta, nio, men det är först nu vi kopplar den till något. Vi tittar på rad 25, här kopplar vi att när någon försöker läsa in "<code>/</code>", dvs root:en, på vår webbtjänst så ska koden i <code>routes</code>-objektet köras. Vi ska snart titta närmare på den koden. Därefter gör vi det samma fast nu länkar vi "<code>/users</code>" med koden som hämtats ifrån <code>users.js</code>.

Det här är den metodologi man jobbar med när man gör Express-applikationer. Man mappar en URL till en metod som hanterar hur just denna bit av sajten ska uppföra sig. I det här fallet kan vi tolka "<coude>route</code>" som att den omdirigerar eller sänder ett URL-anrop till specifik kod. På så vis kan vi få olika funktionalitet och olika svar ifrån servern beroende på vilken URL vi använder för att anropa den. På detta vis kan man lätt bygga både webbapplikationer och [[REST]]-[[API]]:er.

== Felhanterare ==
Vi vill även sätta så att om någon försöker komma åt en annan tjänst på vår server så ska de få ett felmeddelande som svar. Det gör vi på 28-33. Som du kanske minns så är <code>404</code> HTTP:s felkod för att en sida inte återfanns.

På slutet av koden finns två olika felhanterare. Den ena är till för när vi utvecklare och den andra är till för när applikationen körs på riktigt. Den enda skillnaden är att utvecklarversionen visar lite utförligare felmeddelanden.

== Nödvändig grundkod ==
Så precis som sades i början, så är mycket av koden vi tittat på nödvändig grundkod som krävs för att dra igång och initiera Express. När vi vill utöka applikationen kommer vi att skriva nya metoder som ska hantera beteendet för specifika URL:er. Vi behöver därför titta närmare på hur omdirigeringskoden ser ut. I nästa aktivitet ska vi titta vidare på hur man omdirigerar ifrån en URL till faktisk kod och se hur vi kan utnyttja detta för att skapa applikationer.

== Nästa aktivitet ==

[[Grunderna för routing i Express]]