Anders är en webbutvecklare och hårdrockare som gillar brädspel, kaffe och öl.

Detta är ett arkiverat inlägg, som importerats hit för referens. Det kan se konstigt ut och innehålla utdaterad information eller inaktuella åsikter.

Javascript-utveckling, my take

Att utveckla JavaScript är en balansgång på brinnande lina. JavaScript kan göra fantastiska skillnader i användbarhet, och ingen ska vara rädd för att neka sina webbapplikationer sådant. Samtidigt är kraven på kvalitet högre än någonsin: Genvägar kan göra googles spindlar ledsna, script som inte fungerar i vissa webbläsare skapar frustration och missämja, och långa laddningstider är det aldrig någon som gillat.

Jag tänkte därför mycket kort skriva ner mina JavaScript-vanor, i hopp om att det hjälper någon.

Först: hur det inte ska se ut

När JavaScript googlas på innehåller många nybörjartutorials nedanstående exempel.

  1. Tjohej!
  2. Tjohej!
  3. <form action="" onsubmit="foobar()"> ... </a>
  4. <input type="text" onchange="foobar()">
  5. // och så vidare

Det är sorgligt att sådana dåliga exempel ska synas mest för alla som vill lära sig göra häftiga webbplatser. Länkar med felaktigt href (protokollet javascript existerar inte) gör googles spindlar förvirrade och kan påverka sökplaceringar i större omfattningar. Bland webbutvecklare är det sett som dålig sed att använda style-attributet på HTML-element, för att det skapar spaghettikod och blir svårare att hantera i långa loppet. Av samma skäl hör varken onclick, onchange eller liknande hemma i HTMLdokument.

Lugn, det finns bättre!

Det jag talar om är en filosofi som heter Unobtrusive JavaScript, som grovt går ut på att gränssnitt har tre lager:

Semantik och disposition av innehåll : HTML och XHTML

Presentation och design : CSS

Interaktivitet och respons : JavaScript

JavaScript är ett lager i sig självt, som ska arbeta fristående från de andra två (undre) lagren. Rent praktiskt ser det ut så här:

  1. window.onload = function()
  2. {
  3. var lnk = document.getElementsByTagName('a');
  4. lnk.onclick = foobar;
  6. var frm = document.getElementsByTagName('form');
  7. frm.onsubmit = foobar;
  9. var inpt = document.getElementsByTagName('input');
  10. inpt.onchange = foobar;
  11. }

Det enda spåret vi ser av detta är en script i head:

  1. <html>
  2. <head>
  3. <title>Exempelsida</title>
  4. ...
  5. <script src="foobar.js" type="text/javascript"></script>
  6. </head>
  7. ...
  8. <html>

Hemligheten ligger i window.onload. Den körs varje gång en sida har laddats. Det ovanstående kod gör är att leta upp HTML-element via DOM och tilldela dessa händelselyssnare. Det finns otaliga bättre sätt att göra det på än jag gör, men principen är densamma: JavaScript initieras av JavaScript, ej av HTML.

Tjästestrukturerade script

Med ovanstående i åtanke kan jag gå vidare med hur jag brukar göra för att enkelt kunna hitta i mina (till slut gigantiska) JavaScript-filer. Jag börjar alltid med att skissa på vad jag ska scripta, och delar in dessa i tjänster och delade egenskaper.

Tjänst : Kan vara en blogg, kontaktsida, kalender eller något annat som bildar en del av ett dokument.

Delade egenskaper : Kan vara toggle-funktioner, tooltips, formulärwidgets eller annat som delas av flera tjänster.

Utifrån det använder jag JavaScriptobjekt för att skapa egna scopes. Ett typiskt objekt brukar se ut så här för mig:

cn (objekt) : Står för "classnames", men innebär mer än så. Här skriver jag upp alla klassnamn, id och elementnamn som jag behöver för att söka igenom DOM-trädet. När jag vill ha bloggens wrapper (omslutande element) skriver jag this.cn.wrp eller Blog.cn.wrp.

labels (objekt) : Om jag skapar nya element med script, ska länktexter, knapptexter et cetera stå här för att underlätta hantering.

Exists (function : bool) : Funktionen letar igenom DOM-trädet efter instanser av tjänsten, och returnerar en bool (sant/falskt).

init (function : void) : Applicerar script på tjänsten.

  1. var Blog = new Object();
  2. Blog.cn = new Object();
  3. Blog.cn.wrp = "blogWrapper";
  4. Blog.cn.wrp = "blogEntries";
  5. Blog.labels = new Object();
  6. Blog.labels.toggle = "visa hela";
  7. Blog.exists = function(){ //finns? };
  8. Blog.init = function(){ //starta };

Jag föredrar dock istället kortvarianten för att det är mer läsbart:

  1. var Blog = {
  2. cn : {
  3. wrp : "blogWrapper",
  4. entry : "blogEntries"
  5. },
  6. labels : {
  7. toggle : "visa hela"
  8. }
  9. exists : function(){
  10. //finns?
  11. },
  12. init : function(){
  13. //starta
  14. }
  15. }

Till detta kompletterar jag med en funktion som brukar ha "prepare" som prefix, en sk invoke:

  1. window.onload = function() {
  2. prepareBlog();
  3. };
  5. function prepareBlog() {
  6. if(Blog.exists()) {
  7. Blog.init();
  8. }
  9. }

I den anonyma funktionen läggs alla tjänsters invokes efter varandra för att exekvera på sidan. Ett annat sätt är att låta Blog.init köra Blog.exists internt och avbryta om falskt istället för att skapa en ny funktion för det, men det är som man själv vill.

Nog för idag

Jag är inte riktigt färdig ännu. Det återstår litet pill till innan jag är klar med mina rutiner. Mer om detta kommer i en senare blogg om ämnet.

Vidare läsning