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 denda fil 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...

==  Ladda in nödvändig kod  ==
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.

== Instantiera 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.

== Grundkonfiguera 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  börjar med att titta på rad 25, här skapar vi en koppling som gör att när någon försöker läsa in "<code>/</code>" (dvs roten) på vår webbtjänst, så körs koden i <code>routes</code>-objektet. Vi ska snart titta närmare på den koden i nästa aktivitet.

På raden efter så gör vi det samma, fast nu kopplar vi "<code>/users</code>" till 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 kopplar 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 många typer av webbapplikationer, webbtjänster och [[REST]]-[[API]]:er.

== Felhanterare ==
För övriga URL-fragment på vår sajt vill vi att det ska returneras en felkod. Det gör vi på 28-33. Som du kanske minns så är <code>404</code> den HTTP felkod som meddelar att en sida finns.

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 ==
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 ==

[[Node - grunderna för routing i Express]]

[[Category: Node|N6]]