localStorage gebruiken met jQuery

Er zijn verschillende manieren om gegevens die binnen een website aangepast worden op te slaan. De eenvoudigste manier is om gebruik te maken van de localStorage. We bekijken hier een simpele manier om de hoogste score op te slaan. We beginnen met een getal op te slaan in een variabel. Vervolgens wordt de variabel verhuisd naar de localStorage.

Om te beginnen hebben we een input-veld nodig waarin we een getal kunnen invoeren. Ook hebben we een knop nodig waar we op kunnen klikken om het getal op te slaan.

<body>
     <input type=”text” name=”nieuw”>
     <input type=”button” value=”opslaan”>
</body>

Nadat we jQuery gelinkt hebben kunnen we de knop “opslaan” naar de muisklik laten luisteren. Voordat er jQuery opdrachten uitgevoerd mogen worden willen we zeker weten dat het document klaar/geladen is.

<body>
<input type=”text” name=”nieuw”>
<input type=”button” value=”opslaan”>
<script src=”http://code.jquery.com/jquery-1.10.2.js”></script>
<script>
$(document).ready(function(e)
{

});
</script>
</body>

Nu kunnen we de knop “opslaan” naar de muis laten luisteren.

<body>
<input type=”text” name=”nieuw”>
<input type=”button” value=”opslaan”>
<script src=”http://code.jquery.com/jquery-1.10.2.js”></script>
<script>
$(document).ready(function(e)
{
     $(“input[value=opslaan]”).click();
});
</script>
</body>

Als er op de knop “opslaan” geklikt wordt, wordt de inhoud van het invoerveld “name” gelezen en opgeslagen in de variabel “nieuwGetal”. Vervolgens controleren we de waarde van “nieuwGetal” in een pop-up venster.

<script>
var nieuwGetal;

$(document).ready(function(e)
{
     $(“input[value=opslaan]”).click(function(e)
     {
          nieuwGetal=$(“input[name=nieuw]”).val();
          alert(nieuwGetal)
     });
});
</script>

De ingevoerde waarde van “nieuwGetal” wordt door de browser onthouden totdat er een nieuwe waarde ingevuld wordt, of totdat het tabblad weg geklikt wordt. We kunnen de localStorage gebruiken om de browser het getal ook te laten onthouden als het tabblad, of zelfs de hele browser gesloten wordt. Binnen de localStorage maken we een variabel aan met de naam “opgeslagen”. Die variabel krijgt de waarde van “nieuwGetal”.

<script>
var nieuwGetal;

$(document).ready(function(e)
{
     $(“input[value=opslaan]”).click(function(e)
     {
          nieuwGetal=$(“input[name=nieuw]”).val();
         //alert(nieuwGetal);
         localStorage.opgeslagen=nieuwGetal;
         alert(“Het getal: ” + nieuwGetal +” is opgeslagen in de localStorage”);
     });
});
</script>

Om een soort ‘hoogste score’ weergave te krijgen moeten we ervoor zorgen dat niet elk willekeurig getal opgeslagen kan worden in de localStorage. Het getal mag alleen opgeslagen worden als het hoger is dan het getal dat al opgeslagen is. Daarvoor moeten we wel zeker weten dat de waarde van “nieuwGetal” gelezen wordt als een cijfer, niet als een tekst. We gebruiken de functie “Number()” om de waarde van het tekstveld met de naam “nieuw” te lezen als een getal.

<script>
var nieuwGetal;

$(document).ready(function(e)
{
     $(“input[value=opslaan]”).click(function(e)
     {
          nieuwGetal=Number($(“input[name=nieuw]”).val());
         //alert(nieuwGetal);
         localStorage.opgeslagen=nieuwGetal;
         alert(“Het getal: ” + nieuwGetal +” is opgeslagen in de localStorage”);
     });
});
</script>

Voordat de waarde van “nieuwGetal” opgeslagen wordt in de localStorage moet gecontroleerd worden of het getal wel hoger is dan het getal dat al opgeslagen is. Daarvoor moeten we eerst controleren of er al een getal opgeslagen is in de localStorage. Als dat niet zo is wordt er een waarde “0” gegeven aan de variabel “opgeslagen” in de localStorage.

<script>
var nieuwGetal;

$(document).ready(function(e)
{
     if(localStorage.opgeslagen)
     {
          alert(“In de localStorage is opgeslagen:”+ localStorage.opgeslagen);
     }
     else
     {
          localStorage.opgeslagen=0;
          alert(“het getal 0 is opgeslagen in de localStorage”)
     }

     $(“input[value=opslaan]”).click(function(e)
     {
          nieuwGetal=Number($(“input[name=nieuw]”).val());
          //alert(nieuwGetal);
          localStorage.opgeslagen=nieuwGetal;
         alert(“Het getal: ” + nieuwGetal +” is opgeslagen in de localStorage”);
     });
});
</script>

Voordat er een nieuw getal opgeslagen wordt eerst gecontroleerd of het nieuwe getal wel hoger is dan het opgeslagen getal in de localStorage. Daarvoor moet de klikfunctie van de knop “opslaan” aangepast worden:

$(“input[value=opslaan]”).click(function(e)
{
     nieuwGetal=Number($(“input[name=nieuw]”).val());
     //alert(nieuwGetal);
     if(nieuwGetal > localStorage.opgeslagen)
     {
          localStorage.opgeslagen=nieuwGetal;
          alert(“Het getal: ” + nieuwGetal +” is opgeslagen in de localStorage”);
     }
     else
     {
          alert(“voer een hoger getal in dan: “+ localStorage.opgeslagen);
     }
});

De waarde van de variabel “opgeslagen” wordt nu door de browser onthouden (tot de cache gewist wordt).  Als laatste stap kijken we naar de mogelijkheid om de gegevens in de localStorage zelf te wissen. Eerst hebben we een nieuwe knop nodig:

<body>
<input type=”text” name=”nieuw”>
<input type=”button” value=”opslaan”>
<input type=”button” value=”wissen”>

Vervolgens geven we de nieuwe knop “wissen” een klikfunctie. Als er op de knop geklikt wordt wordt het item “opgeslagen” gewist uit de localStorage:

<script>
var nieuwGetal;

$(document).ready(function(e)
{
     if(localStorage.opgeslagen)
     {
          alert(“In de localStorage is opgeslagen:”+ localStorage.opgeslagen);
     }
     else
     {
          localStorage.opgeslagen=0;
          alert(“het getal 0 is opgeslagen in de localStorage”)
     }

     $(“input[value=opslaan]”).click(function(e)
     {
          nieuwGetal=Number($(“input[name=nieuw]”).val());
          //alert(nieuwGetal);
          if(nieuwGetal>localStorage.opgeslagen)
          {
               localStorage.opgeslagen=nieuwGetal;
               alert(“Het getal: ” + nieuwGetal +” is opgeslagen in de localStorage”);
          }
          else
          {
               alert(“voer een hoger getal in dan: “+ localStorage.opgeslagen);
          }
     });

     $(“input[value=wissen]”).click(function(e)
     {
          localStorage.removeItem(“opgeslagen”);
     });
});
</script>

<script>

Javascript Image slider

Een image slider is een veel voorkomende manier om een serie afbeeldingen te vertonen op een website. Vaak worden er binnen een pagina verschillende sliders gebruikt. Het is met Javascript mogelijk om alle sliders binnen een pagina met 1 functie aan te sturen. Daarvoor wordt ‘event.target’ gebruikt, het ‘doel van de gebeurtenis’. Door ‘event.target’ te gebruiken weet Javascript wie er aangeklikt wordt. vervolgens kan Javascript de afbeelding die bij de aangeklikte knop hoort aanpassen.

Laten we beginnen met een enkele image-slider. We maken een div-tag met daarin een div met afbeeldingen en 2 h1-tags met daarin een pijl naar links en een pijl naar rechts. We gebruiken classes in plaats van id’s zodat we de image slider makkelijk kunnen hergebruiken als we klaar zijn.

<body>
<div class=”imgSlider”>
     <div class=”plaatjes”>
          <img src=”img/brood.jpg” />
          <img src=”img/croissant.jpg”/>
          <img src=”img/fruit.jpg”/>
          <img src=”img/coffee.jpg”/>
     </div>
     <h1 >&lt;</h1>
     <h1 >&gt;</h1>
</div>
</body> 

Gebruik css om de div ‘imgSlider’ de afmeting te geven van 1 afbeelding. In het voorbeeld is dat 500px bij 300px. We stellen alvast een margin in van 50px zodat we makkelijk extra sliders kunnen toevoegen als de eerste slider af is.

<style type=”text/css”>
.imgSlider
{
     position:relative;
     width:500px;
     height:300px;
     margin:50px;
     overflow:hidden;
}
</style>

Gebruik css om de afbeelding een maat te geven. We geven een vaste breedte en een automatisch hoogte zodat de afbeelding in verhouding blijft als hij geschaald moet worden. We gebruiken ‘float:left’ om de afbeeldingen zonder tussenruimte naast elkaar te laten staan.

<style type=”text/css”>
.imgSlider
{
     position:relative;
     width:500px;
     height:300px;
     margin:50px;
     border:#000 dotted;
}

.imgSlider img
{
     width:500px;
     height:auto;
     float:left;
}
</style>

De afbeeldingen hebben nog niet genoeg ruimte om naast elkaar te staan, de div ‘imgSlider’ is maar breed genoeg voor 1 afbeelding. Om dat op te lossen geven we de div ‘plaatjes’ genoeg breedte voor 4 afbeeldingen naast elkaar. 1 afbeelding is 500px breed. We maken ‘plaatjes’ dus 2000px breed. Met Javascript passen we later de waarde ‘left’ aan van ‘plaatjes’. Om dat soepel te laten verlopen gebruiken we een css-transition.

<style type=”text/css”>
.imgSlider
{
     position:relative;
     width:500px;
     height:300px;
     margin:50px;
     border:#000 dotted;
}

.imgSlider img
{
     width:500px;
     height:auto;
     float:left;
}

.imgSlider .plaatjes
{
     position:absolute;
     top:0px;
     left:0px;
     width:2000px;
     transition:left 0.5s;
}
</style>

In dit voorbeeld is alle content buiten de div ‘imgSlider’ onzichtbaar door de instelling ‘overflow:hidden’. Daarom plaatsen we de h1-tags met de pijlen binnen de div ‘imgSlider’. De h-1 tags hebben geen class of id, maar we kunnen de css (pseudo)selector ‘nth-child’ gebruiken. De div ‘imgSlider’ bestaat uit 3 elementen: de div ‘plaatjes’ en 2 h1-tags. ‘plaatjes’ is het eerste ‘child’, de eerste h-1 tag is het tweede ‘child’ en de tweede h1-tag is het derde ‘child’. De eerste h1-tag krijgt de instelling ‘float-left’, de tweede h1-tag ‘float-right’.

<style type=”text/css”>
.imgSlider
{
     position:relative;
     width:500px;
     height:300px;
     margin:50px;
     border:#000 dotted;
}

.imgSlider img
{
     width:500px;
     height:auto;
     float:left;
}

.imgSlider .plaatjes
{
position:absolute;
top:0px;
     left:0px;
     width:2000px;
     transition:left 0.5s;
}
.imgSlider h1:nth-child(2)
{
     float:left;
     position:relative;
     margin:20px;
}
.imgSlider h1:nth-child(3)
{
     float:right;
     position:relative;
     margin:20px;
}
</style>

Nu is het tijd voor Javascript. Eerst moeten we de pijlen laten luisteren naar de muisklik. Als een pijl aangeklikt wordt, wordt de functie ‘verschuiven()’ uitgevoerd.

<body>
<div class=”imgSlider”>
     <div class=”plaatjes” style=”left:0px;”>
          <img src=”img/brood.jpg”/>
          <img src=”img/croissant.jpg”/>
          <img src=”img/fruit.jpg”/>
          <img src=”img/coffee.jpg”/>
     </div>
     <h1 onclick=”schuiven()”>&lt;</h1>
     <h1 onclick=”schuiven()”>&gt;</h1>
</div>
<script type=”text/javascript”>
function schuiven()
{
}
</script>
</body>

Als op 1 van de pijlen geklikt wordt, is het de bedoeling dat de div ‘plaatjes’ verplaatst wordt binnen de div ‘imgSlider’. Daarvoor moet Javascript eerst op zoek naar ‘imgSlider’ en ‘plaatjes’. We geven Javascript eerst de opdracht een variabel met de naam ‘imgSlider’ te maken waarin de slider opgeslagen wordt. Vervolgens zoekt Javascript binnen ‘imgSlider’ naar een element met de class-naam ‘plaatjes’. Dat element wordt opgeslagen als een variabele met de naam ‘plaatjes’. Als er op 1 van de pijlen geklikt wordt moet ‘plaatjes’ verschuiven. Dat doen we door de css waarde ‘left’ te veranderen. Die waarde wordt gegeven als een tekst, bijvoorbeeld ’10px’. Omdat je met tekst geen rekensommen kunt maken, gebruiken we ‘offsetLeft’ om Javascript de getal-waarde te laten zoeken van de css ‘left’ instelling. ‘offsetLeft’ is een getal en kan alleen gebruikt worden om de left-waarde te lezen. Het is niet mogelijk om een waarde toe te kennen.

<script type=”text/javascript”>
var imgSlider=document.getElementsByClassName(“imgSlider”)[0];
var plaatjes=imgSlider.getElementsByClassName(“plaatjes”)[0];
var plaatjesLeft=plaatjes.offsetLeft;

function schuiven()
{
}
</script>

Nu is het tijd de functie ‘schuiven()’ te gebruiken. Als er op een van de pijlen geklikt wordt, moet de slider verschuiven, maar de slider kan twee kanten op schuiven; naar links en naar rechts. Door tussen de haakjes van de functie ‘schuiven()’ een parameter door te geven kunnen we dezelfde functie gebruiken voor het links en rechts verschuiven van de plaatjes.

<div class=”imgSlider”> 
     <div class=”plaatjes”>
          <img src=”img/brood.jpg”/>
          <img src=”img/croissant.jpg”/>
          <img src=”img/fruit.jpg”/>
          <img src=”img/coffee.jpg”/>
     </div>
     <h1 onclick=”schuiven(‘links’)”>&lt;</h1>
     <h1 onclick=”schuiven(‘rechts’)”>&gt;</h1>
</div>

Als we parameters meesturen als de functie geactiveerd wordt, moet bij de functie-beschrijving verteld worden dat er  parameters binnen komen. Er wordt een soort lokale variabele gemaakt die de waarde krijgt van wat er opgestuurd wordt. In dit voorbeeld heet de variabele ‘richting’ en kan de waarde ‘links’ of ‘rechts’ zijn.

function schuiven(richting)
{
}

De waarde van ‘richting’ kunnen we gebruiken om Javascript te laten kiezen naar welke kant de plaatjes verplaatst moeten worden.

function schuiven(richting)
{
     if(richting==”links”)
     {
     }
     else if(richting==”rechts”)
     {
     }
}

Laten we beginnen met de plaatjes naar links te verschuiven. De variabele ‘plaatjesLeft’ kijkt wat de css left-waarde is van de plaatjes. Daarvan haalt hij 500 af (plaatjesLeft-=500), dat is de breedte van een afbeelding. Die nieuwe waarde van ‘plaatjesLeft’ wordt toegepast op de css left-waarde van de plaatjes (plaatjes.style.left=plaatjesLeft). Het woord “px” wordt er achter geplakt omdat css een waarde en een eenheid nodig heeft.

function schuiven(richting)
{
     if(richting==”links”)
     {
          plaatjesLeft-=500;
          plaatjes.style.left=plaatjesLeft +”px”;
     }
     else if(richting==”rechts”)
     {
     }
}

Nu werkt de slider al wel, maar als er te vaak geklikt wordt verdwijnen alle plaatjes uit beeld. Dat gaan we voorkomen door de plaatjes terug te sturen naar de begin positie. Een plaatje is 500 pixel breed. We hebben in dit voorbeeld vier plaatjes, na drie keer schuiven is het vierde plaatje in beeld. Na het vierde plaatje moet ‘plaatjes’ terug naar het begin. Dus na drie keer schuiven is de waarde van plaatjesLeft -1500. De waarde van ‘plaatjesLeft ‘ moet groter blijven dan -1500, want als de waarde kleiner wordt zouden de plaatjes uit beeld verdwijnen, dat is niet de bedoeling. Daarom wordt ‘plaatjes’ terug gestuurd naar het begin:

function schuiven(richting)
{
     if(richting==”links”)
     {
          if(plaatjesLeft>1500)
          {
               plaatjesLeft-=500;
               plaatjes.style.left=plaatjesLeft +”px”;
          }
          else
          {
               plaatjesLeft=0;
               plaatjes.style.left=plaatjesLeft +”px”;
          }
     }
     else if(richting==”rechts”)
     {
     }
}

Dit kunnen we herhalen voor het schuiven naar rechts, maar dan omgekeerd: Bij ‘plaatjesLeft’ wordt nu 500 opgeteld. Maar de css left-waarde moet kleiner blijven dan ‘0’, anders verdwijnen de plaatjes uit beeld. Dus als ‘plaatjesLeft’ kleiner is dan nul, dan mag er vijfhonderd bij opgeteld worden. Anders wordt de css left-waarde aangepast naar ‘-1500px’, waardoor het laatste plaatje in beeld komt.

function schuiven(richting)
{
     if(richting==”links”)
     {
          if(plaatjesLeft>1500)
          {
               plaatjesLeft-=500;
               plaatjes.style.left=plaatjesLeft +”px”;
          }
          else
          {
          plaatjesLeft-=500;
          plaatjes.style.left=plaatjesLeft +”px”;
          }
     }
     else if(richting==”rechts”)
     {
          if(plaatjesLeft<0)
          {
               plaatjesLeft+=500;
               plaatjes.style.left=plaatjesLeft +”px”;
          }
          else
          {
               plaatjesLeft=-1500;
               plaatjes.style.left=plaatjesLeft +”px”;
          }
     }
}

Javascript audio speler

Met de html audio-tag is het mogelijk audiobestanden in de webbrowser af te spelen. Daarbij is het mogelijk gebruik te maken van de standaard meegeleverde ‘controls’, maar natuurlijk is het stijlvoller om de vormgeving van de audio-controls af te stemmen op de website waar de audio geplaatst wordt. Dat is mogelijk door zelf besturingselementen te maken en die met Javascript de audio-tag aan te sturen.

Om te beginnen hebben we een audio-tag nodig. Omdat niet alle browsers dezelfde audiobestanden kunnen afspelen gebruiken we 2 source-tags voor verschillende versies van hetzelfde audio bestand. De audio-tag plaatsen we in een div met de class-naam ‘audioSpeler’.

<body>
     <div class=”audioSpeler”>
          <audio>
              <source src=”sound.mp3″ type=”audio/mp3″/>
              <source src=”sound.wav” type=”audio/wav”/>
          </audio>
     </div>
</body>

Als we het resultaat testen in de browser is er niets te zien of te horen. Een audio-tag is zelf niet zichtbaar. Omdat we niet hebben aangegeven dat we de standaard ‘controles’ van de browser willen gebruiken, zijn die controls ook niet te zien. De browser is ingesteld om een audio bestand meteen te pauzeren, daarom is er niets te horen. We maken nu eerst een afspeelknop (p-tag met de tekst ‘start’) zodat we die kunnen gebruiken om het afspelen te starten. We plaatsen de afspeelknop in een div met de naam ‘knoppen’ zodat we later makkelijk meer functionaliteit toe kunnen voegen. Als op de knop geklikt wordt, wordt de functie  ‘afspelen()’ uitgevoerd.

<body>
     <div class=”audioSpeler”>
          <div class=”knoppen”>
               <p onclick=”afspelen()”>start</p>
          </div>
          <audio>
               <source src=”sound.mp3″ type=”audio/mp3″/>
               <source src=”sound.wav” type=”audio/wav”/>
          </audio>
     </div>

<script type=”text/javascript”>
function afspelen()
{

}
</script>
</body>

Om het audiobestand te kunnen afspelen met Javascript, moet Javascript de audio-tag eerst kunnen vinden. Daar maken we een variabel met de naam ‘audio’ voor aan. In onderstaand voorbeeld geven weJavascript eerst de opdracht de (eerste) audiospeler te zoeken en daarna binnen de audiospeler te zoeken naar de (eerste) audio-tag.

<script type=”text/javascript”>
var audioSpeler=document.getElementsByClassName(“audioSpeler”)[0];
var audio=audioSpeler.getElementsByTagName(“audio”)[0];

function afspelen()
{

}
</script>

Vervolgens kunnen we de functie ‘afspelen()’ gebruiken om de opdracht te geven het audio bestand af te spelen:

<script type=”text/javascript”>
var audioSpeler=document.getElementsByClassName(“audioSpeler”)[0];
var audio=audioSpeler.getElementsByTagName(“audio”)[0];

function afspelen()
{
     audio.play();
}
</script>

Vaak wordt de afspeelknop gebruikt om een het afspelen te starten, maar ook te stoppen: Als de speler is gepauzeerd moet het afspelen gestart worden, als de speler al afspeelt moet het afspelen gepauzeerd worden. Dat is eenvoudig te bereiken door ‘if()’ en ‘else’ te gebruiken. Javascript kan de eigenschappen van de audio-tag lezen. Een van die eigenschappen is ‘paused’. We laten Javascript kijken of de audio-tag gepauzeerd is. Als dat zo is moet de audio-tag afgespeeld worden. Anders, als de audio-tag niet gepauzeerd is, moet de audio-tag gepauzeerd worden.

<script type=”text/javascript”>
var audioSpeler=document.getElementsByClassName(“audioSpeler”)[0];
var audio=audioSpeler.getElementsByTagName(“audio”)[0];

function afspelen()
{
     if(audio.paused==true)
     {
          audio.play();
     }
     else
     {
          audio.pause();
     }
}
</script>

Als we ons script testen in de browser is het duidelijk te horen of het audio bestand afgespeeld wordt of niet, maar het communiceert beter als dat ook te zien is. Eerst gebruiken we een variabel met de naam ‘startKnop’ om Javascript de startknop te laten zoeken (de eerste p-tag van de audiospeler). Daarna gebruiken we de opdracht ‘innerHTML’ om de tekst van de startknop aan te passen als de werking daarvan verandert.

<script type=”text/javascript”>
var audioSpeler=document.getElementsByClassName(“audioSpeler”)[0];
var audio=audioSpeler.getElementsByTagName(“audio”)[0];
var startKnop=audioSpeler.getElementsByTagName(“p”)[0];

function afspelen()
{
     if(audio.paused==true)
     {
          audio.play();
          startKnop.innerHTML=”pauze”;
     }
     else
     {
          audio.pause();
          startKnop.innerHTML=”start”;
     }
}
</script>

Naast het starten en stoppen van het afspelen kunnen we ook het volume aanpassen. Eerst plaatsen we een extra p-tag met de tekst ‘vol +’. Als deze p-tag aangeklikt wordt wordt de functie ‘volume()’ uitgevoerd.

<div class=”audioSpeler”>
     <div class=”knoppen”>
          <p onclick=”afspelen()”>start</p>
          <p onclick=”volume()”>vol +</p>
     </div>
     <audio>
          <source src=”sound.mp3″ type=”audio/mp3″/>
          <source src=”sound.wav” type=”audio/wav”/>
     </audio>
</div>

Als op de knop ‘vol +’ gekikt wordt, wordt de functie ‘volume()’ uitgevoerd. Die functie kijkt naar de waarde van volume en telt daar 0.1 bij op (+=0.1).

function volume()
{
     audio.volume+=0.1;
}

We maken een extra knop met de tekst ‘vol -‘ om het volume ook lager te kunnen maken. Deze knop voert dezelfde functie ‘volume()’ uit. Die gaan we zometeen aanpassen zodat dezelfde functie het volume hoger of lager kan zetten.

<div class=”audioSpeler”>
     <div class=”knoppen”>
          <p onclick=”afspelen()”>start</p>
          <p onclick=”volume()”>vol +</p>
          <p onclick=”volume()”>vol -</p>
     </div>
     <audio>
          <source src=”sound.mp3″ type=”audio/mp3″/>
          <source src=”sound.wav” type=”audio/wav”/>
     </audio>
</div>

De ronde haken achter een functie kunnen we gebruiken om informatie door te geven die gebruikt moet worden als de functie uitgevoerd wordt. Als de functie ‘volume()’ wordt uitgevoerd kunnen we aangeven of het geluid harder of zachter moet.

<div class=”audioSpeler”>
     <div class=”knoppen”>
          <p onclick=”afspelen()”>start</p>
          <p onclick=”volume(‘harder’)”>vol +</p>
          <p onclick=”volume(‘zachter’)”>vol -</p>
     </div>
     <audio>
          <source src=”sound.mp3″ type=”audio/mp3″/>
          <source src=”sound.wav” type=”audio/wav”/>
     </audio>
</div>

De gegevens (parameters) die tussen de ronde haken doorgegeven worden aan de functie kunnen we binnen het uitvoeren van de functie gebruiken. Eerst wordt er binnen de functie een variabel gemaakt (die alleen binnen de functie herkend wordt).

<script type=”text/javascript”>
var audioSpeler=document.getElementsByClassName(“audioSpeler”)[0];
var audio=audioSpeler.getElementsByTagName(“audio”)[0];
var startKnop=audioSpeler.getElementsByTagName(“p”)[0];

function afspelen()
{
     if(audio.paused==true)
     {
          audio.play();
          startKnop.innerHTML=”pauze”;
     }
     else
     {
          audio.pause();
          startKnop.innerHTML=”start”;
     }
}

function volume(waarde)
{
     audio.volume+=0.1;
}
</script>

Vervolgens kunnen we de waarde die naar de functie gestuurd wordt gebruiken. Als de waarde ‘harder’ doorgegeven wordt, moet het volume hoger, als de waarde ‘zachter’ doorgegeven wordt, maken we het volume lager.

function volume(waarde)
{
     if(waarde==”harder”)
     {
          audio.volume+=0.1;
     }
     else if(waarde==”zachter”)
     {
          audio.volume-=0.1;
     }
}

Na een aantal keer klikken is het waar te nemen dat het geluid harder en zachter gaat. Toch is het gebruiksvriendelijker om ook visueel te laten weten dat het volume aangepast wordt. Eerst maken we een extra p-tag om de waarde van het volume in weer te geven.

<body>
     <div class=”audioSpeler”>
          <div class=”knoppen”>
               <p onclick=”afspelen()”>start</p>
               <p onclick=”volume(‘harder’)”>vol +</p>
               <p onclick=”volume(‘zachter’)”>vol -</p>
               <p>vol:1</p>
          </div>
          <audio>
               <source src=”almeria/04 Moveonday.mp3″ type=”audio/mp3″/>
               <source src=”almeria/04 Moveonday.wav” type=”audio/wav”/>
          </audio>
</div>

Als laatste stap maken we een variabel met de naam ‘volumeWaarde’ waarin we Javascript vertellen waar de juiste p-tag gevonden kan worden. Als het volume aangepast wordt door de functie ‘volume()’ wordt in de p-tag ‘volumeWaarde’ de tekst aangepast.

<script type=”text/javascript”>
var audioSpeler=document.getElementsByClassName(“audioSpeler”)[0];
var audio=audioSpeler.getElementsByTagName(“audio”)[0];
var startKnop=audioSpeler.getElementsByTagName(“p”)[0];
var volumeWaarde=audioSpeler.getElementsByTagName(“p”)[3];

function afspelen()
{
     if(audio.paused==true)
     {
          audio.play();
          startKnop.innerHTML=”pauze”;
     }
     else
     {
          audio.pause();
          startKnop.innerHTML=”start”;
     }
}

function volume(waarde)
{
     if(waarde==”harder”)
     {
          audio.volume+=0.1;
     }
     else if(waarde==”zachter”)
     {
          audio.volume-=0.1;
     }
     volumeWaarde.innerHTML=audio.volume;
}
</script>

De volumeWaarde heeft nog een schoonheidsfoutje. Hoewel we de waarde van het volume met ‘0.1’ veranderen, maakt Javascript van de aangepaste waarde een getal met flink aantal cijfers achter de komma. De Javascript functie ‘toFixed()’ kan dat getal afronden. Tussen de ronde haken geven we aan dat het getal afgerond moet worden op 1 cijfer achter de komma.

function volume(waarde)
{
     if(waarde==”harder”)
     {
          audio.volume+=0.1;
     }
     else if(waarde==”zachter”)
     {
          audio.volume-=0.1;
     }
     volumeWaarde.innerHTML=audio.volume.toFixed(1);
}

Javascript en html formulieren gebruiken

Een html formulier wordt doorgaans gebruikt om gebruikers informatie door te geven aan de server, die de informatie bijvoorbeeld in een database kan opslaan. Maar formulieren kunnen in combinatie met Javascript ook toegepast worden binnen een webpagina. Er zijn een aantal verschillende mogelijkheden binnen een html formulier die in principe op dezelfde manier werken: Binnen een formulier kan de gebruiker een keus aangeven. Er zijn verschillende manieren om die keus aan te geven, bijvoorbeeld door een checkbox aan te vinken, een radiobutton te selecteren, een tekstveld in te vullen, etc.

In onderstaand voorbeeld bekijken we hoe javascript kan samenwerken met een html formulier. Om te beginnen hebben we een formulier nodig. We gebruiken 3 radiobuttons om een keus aan te geven. Elke radiobutton heeft een naam en een waarde nodig. In dit voorbeeld krijgen de knoppen allemaal dezelfde naam. Dat zorgt ervoor dat de gebruiker maar 1 knop tegelijk kan selecteren. De knoppen krijgen wel een verschillende waarde (value) zodat Javascript kan lezen welke keus gemaakt is.

<body>
     <form name=”formulier” action=””>
          <input type=”radio” name=”keus” value=”keus1″ />
          <input type=”radio” name=”keus” value=”keus2″ />
          <input type=”radio” name=”keus” value=”keus3″ />
     </form>
</body> 

We hebben een formulier dat op zich werkt, maar niet zo gebruiksvriendelijk is. We gebruiken een h3-tag om aan te geven wat de bedoeling is en gebruiken p-tags om bij elke knop aan te geven wat de keus is die geselecteerd kan worden. Bij het openen van de website wordt de eerste knop alvast geselecteerd door de status van deze knop op ‘checked’ in te stellen.

<body>
     <form name=”formulier” action=””>
         <h3>Maak een keuze:</h3>
        <p> keus1<input type=”radio” name=”keus” value=”keus1″  checked=”checked”/></p
        <p> keus2<input type=”radio” name=”keus” value=”keus2″ /> </p>
        <p> keus3<input type=”radio” name=”keus” value=”keus3″ /> </p>
     </form>
</body>

Nu kunnen we javascript gebruiken om de gemaakte keus te lezen. Om te beginnen moet er een functie uitgevoerd worden als de waarde van 1 van de radiobuttons verandert (onchange). we noemen deze functie ‘kies’.

<body>
     <form name=”formulier” action=””>
          <h3>Maak een keuze:</h3>
          <p> keus1<input type=”radio” name=”keus” value=”keus1″ checked=”checked” onchange=”kies()”/> </p>
          <p> keus2<input type=”radio” name=”keus” value=”keus2″ onchange=”kies()”/> </p>
          <p> keus3<input type=”radio” name=”keus” value=”keus3″ onchange=”kies()”/> </p>
</form>
<script type=”text/javascript”>

function kies()
{
     
}
</script>
</body>

Vervolgens gaan we de functie ‘kies’ gebruiken om de  tekst van de h3-tag aan te passen. Om informatie uit het formulier te kunnen lezen en om binnen het formulier de h3-tag te kunnen vinden, moeten de h3-tag en het formulier eerst opgeslagen worden in een variabel. Daarna kunnen we ‘innerHTML’ gebruiken om de tekst binnen de h3-tag aan te passen. Als 1 van de knoppen aangeklikt wordt  komt er in de h3-tag te staan: ‘Je keus is: ‘.

<script type=”text/javascript”>
var formulier=document.getElementsByName(“formulier”)[0];
var formulierH3=formulier.getElementsByTagName(“h3”)[0];

function kies()
{
     formulierH3.innerHTML=”Je keus is: “
}
</script>

We hebben nu een formulier dat op Javascript reageert: de tekst verandert als de selectie verandert. Nu laten we Javascript de geselecteerde keus lezen en die bijschrijven in de h3-tag. De functie wordt wel wat ingewikkelder, want Javascript moet eerst kijken welke knop geselecteerd is (checked). Daarvoor moeten we eerst een lijst maken met de mogelijke opties. die lijst bestaat uit alle input-tags in het formulier. We slaan de lijst op in een variabel.

<script type=”text/javascript”>
var formulier=document.getElementsByName(“formulier”)[0];
var formulierH3=formulier.getElementsByTagName(“h3”)[0];
var opties=formulier.getElementsByTagName(“input”);

function kies()
{
     formulierH3.innerHTML=”Je keus is: “
}
</script>

Vervolgens kunnen we de opdracht beschrijven die Javascript moet uitvoeren als de eerste input-tag geselecteerd is. Als de eerste input-tag geselecteerd is, verandert de tekst in de h3-tag.Daar wordt nog steeds bijgeschreven ‘Je keus is: ‘ maar daar wordt nu aan toe gevoegd de waarde (value) van de geselecteerde knop. De value van de eerste input-tag is ‘keus1’. Als de eerste knop geselecteerd is, komt er dus in de h3-tag te staan: ‘Je keus is: keus1’.

<script type=”text/javascript”>
var formulier=document.getElementsByName(“formulier”)[0];
var formulierH3=formulier.getElementsByTagName(“h3”)[0];
var opties=formulier.getElementsByTagName(“input”);

function kies()
{
     if(opties[0].checked==true)
     {
          formulierH3.innerHTML=”Je keus is: ” + opties[0].value;
     }
}
</script>

Dit kunnen we herhalen voor de tweede en derde knop.

<script type=”text/javascript”>
var formulier=document.getElementsByName(“formulier”)[0];
var formulierH3=formulier.getElementsByTagName(“h3”)[0];
var opties=formulier.getElementsByTagName(“input”);

function kies()
{
     if(opties[0].checked==true)
     {
          formulierH3.innerHTML=”Je keus is: ” + opties[0].value;
     }
     else if(opties[1].checked==true)
     {
          formulierH3.innerHTML=”Je keus is: ” + opties[1].value;
     }
     else if(opties[2].checked==true)
     {
          formulierH3.innerHTML=”Je keus is: ” + opties[2].value;
     }
}
</script>

Naast het invoeren van een keus kan een html formulier op verschillende manieren gebruikt worden. Bijvoorbeeld om het uiterlijk of de inhoud van de website aan te passen. In dit geval kunnen we de waarde van de geselecteerde knop gebruiken om het uiterlijk van de andere knoppen aan te passen. Als de eerste knop geselecteerd is wordt de transparantie van de tweede en derde p-tag van het formulier aangepast. Daarvoor maken we eerst weer een variabel met daarin een lijst van alle p-tags.

<script type=”text/javascript”>
var formulier=document.getElementsByName(“formulier”)[0];
var formulierH3=formulier.getElementsByTagName(“h3”)[0];
var opties=formulier.getElementsByTagName(“input”);
var formulierP=formulier.getElementsByTagName(“p”);

function kies()
{
     if(opties[0].checked==true)
     {
          formulierH3.innerHTML=”Je keus is: ” + opties[0].value;
          formulierP[0].style.opacity=”1″;
          formulierP[1].style.opacity=”0.5″;
          formulierP[2].style.opacity=”0.5″; 
     }
     else if(opties[1].checked==true)
     {
          formulierH3.innerHTML=”Je hebt gekozen: ” + opties[1].value;
     }
     else if(opties[2].checked==true)
     {
          formulierH3.innerHTML=”Je hebt gekozen: ” + opties[2].value;
     }
}
</script>

Dit is natuurlijk makkelijk uit te breiden naar de andere knoppen: Als de tweede knop geselecteerd is, wordt de transparantie van de eerste en derde p-tag gehalveerd. Als de derde knop geselecteerd is, wordt de transparantie van de eerste en tweede p-tag gehalveerd.

<script type=”text/javascript”>
var formulier=document.getElementsByName(“formulier”)[0];
var formulierH3=formulier.getElementsByTagName(“h3”)[0];
var opties=formulier.getElementsByTagName(“input”);
var formulierP=formulier.getElementsByTagName(“p”);

function kies()
{
     if(opties[0].checked==true)
     {
          formulierH3.innerHTML=”Je keus is: ” + opties[0].value;
          formulierP[0].style.opacity=”1″;
          formulierP[1].style.opacity=”0.5″;
          formulierP[2].style.opacity=”0.5″; 
     }
     else if(opties[1].checked==true)
     {
          formulierH3.innerHTML=”Je hebt gekozen: ” + opties[1].value;
          formulierP[0].style.opacity=”0.5″;
          formulierP[1].style.opacity=”1″;
          formulierP[2].style.opacity=”0.5″;
     }
     else if(opties[2].checked==true)
     {
          formulierH3.innerHTML=”Je hebt gekozen: ” + opties[2].value;
          formulierP[0].style.opacity=”0.5″;
          formulierP[1].style.opacity=”0.5″;
          formulierP[2].style.opacity=”1″;
     }
}
</script>

WordPress verkort bericht met een thumbnail

Met WordPress is het mogelijk om een overzicht van verkorte berichten weer te geven. Dat kan bijvoorbeeld door de opdracht ‘the_excerpt()’ te gebruiken in plaats van ‘the_content()’ om de eerste paar woorden van een bericht te laden in plaats van het hele bericht.

Een andere manier is om van een bericht alleen een (door de schrijver geselecteerde) afbeelding te laden. Bij het schrijven van een bericht kan aangegeven worden welke afbeelding gebruikt moet worden als ‘thumbnail’. Standaard is deze optie niet aanwezig in WordPress. Om deze optie te activeren hebben we een extra php-bestand nodig: ‘functions.php’.

In ‘functions.php’ worden alle aanvullende functies beschreven die niet standaard bij een thema horen. We maken een nieuw (leeg) php bestand en slaan dat op als ‘functions.php’.

In ‘functions.php’ schrijven we de opdracht om thumbnails te ondersteunen:

<?php add_theme_support( ‘post-thumbnails’ ); ?>

Nu kunnen we in onze homepage (index.php) de thumbnails gebruiken. Eerst hebben we de standaard post-loop nodig om alle bericht informatie te laden. In onderstaand voorbeeld worden de berichten geladen een div met id-naam ‘berichten’.

<body>
     <div id=”berichten”>
     <?php while(have_posts()):
           the_post(); 
           endwhile; ?>
     </div>
</body>

Als het bericht geladen wordt willen we alleen de titel van het bericht en de door de schrijver geselecteerde thumbnail zien. Omdat de gebruiker de mogelijkheid moet hebben om door te kunnen klikken naar het volledige bericht, plaatsen we de titel en de thumbnail samen in een a-tag met de class-naam ‘bericht_thumbnail’. We gebruiken de WordPress opdracht ‘the_permalink()’ om te linken naar het bijbehorende bericht.

Let op! We gebruiken nu html en php door elkaar. Vergeet dus niet de php-tags op de juiste plaats te openen en te sluiten. Eerst maken we de knop (a-tag).

<body>
     <div id=”berichten”>
     <?php while(have_posts()):
          the_post(); ?>
          <a class=”bericht_thumbnail” href=”<?php the_permalink(); ?>”>
          </a>
     <?php endwhile; ?>
     </div>
</body>

Vervolgens plaatsen we in de knop een h4-tag met daarin de titel van het bericht en een thumbnail (die automatisch in een img-tag geplaatst zal worden).

<body>
     <div id=”berichten”>
     <?php while(have_posts()):
          the_post(); ?>
          <a class=”bericht_thumbnail” href=”<?php the_permalink(); ?>>
               <h4><?php the_title(); ?></h4>
               <?php the_post_thumbnail() ?>
          </a>
     <?php endwhile; ?>
     </div>
</body>

We hebben nu een aanklikbare thumbnail. Als de thumbnail aangeklikt wordt, wordt de gebruiker doorverwezen naar het volledige bericht. Standaard gebruikt WordPress het bestand ‘index.php’ om het bericht te tonen. Om het bericht een eigen opmaak te geven is het bestand ‘single.php’ nodig.

WordPress bericht in aparte pagina vertonen

Single post layout

In WordPress wordt content vaak geplaatst door gebruik te maken van posts/berichten. Bij het plaatsen van veel korte berichten is dat geen probleem, maar als je regelmatig langere berichten wilt plaatsen wordt je website al snel onoverzichtelijk. WordPress heeft daarvoor de oplossing om berichten verkort weer te geven. Er wordt een verkorte weergave van het bericht geplaatst met een link naar het volledige bericht. Het volledige bericht wordt als een aparte pagina geladen.

Er is maar een kleine aanpassing nodig om in plaats van een volledig bericht een verkort bericht te laden. In plaats van de functie ‘the_content()’te gebruiken voor het plaatsen van het volledige bericht, wordt de functie ‘the_excerpt()’ gebruikt voor het plaatsen van de verkorte tekst.

In onderstaand voorbeeld plaatsen we de volledige berichten in een div met de id ‘berichten’.

<body>
 <div id=”berichten”>
          <?php while ( have_posts() ) :
                    the_post(); ?>
                    <div class=”post”>
                         <h1><?php the_title(); ?></h1>
                         <p><?php the_content(); ?></p>
                    </div>
               <?php endwhile; ?>
     </div>
</body>

Om in plaats van volledige berichten, verkorte berichten te plaatsen is een kleine aanpassing nodig: We vervangen de functie ‘the_content()’ voor de functie ‘the_excerpt()’:

<body>
 <div id=”berichten”>
          <?php while ( have_posts() ) :
                    the_post(); ?>
                    <div class=”post”>
                         <h1><?php the_title(); ?></h1>
                         <p><?php the_excerpt(); ?></p>
                    </div>
               <?php endwhile; ?>
     </div>
</body>

Als we een verkorte weergave van het bericht gebruiken hebben we ook een link naar de volledige versie nodig. Hiervoor gebruiken we de titel van het bericht. In de h1-tag plaatsen we een a-tag die linkt naar het volledige bericht. Het link adres naar het volledige bericht laten we WordPress zelf maken met de functie ‘the_permalink()’.

<body>
 <div id=”berichten”>
          <?php while ( have_posts() ) :
                    the_post(); ?>
                    <div class=”post”>
                         <h1><a href=”<?php the_permalink(); ?>” ><?php the_title(); ?></a></h1>
                         <p><?php the_excerpt(); ?></p>
                    </div>
               <?php endwhile; ?>
     </div>
</body>

Bij het aanklikken van de de titel wil WordPress de volledige post op een aparte pagina vertonen. De opmaak voor die pagina moet  wel omschreven worden. Standaard wordt voor de opmaak van het enkele bericht gebruik gemaakt van ‘index.php’. Om een bericht een eigen opmaak te geven kunnen we een nieuw php-bestand maken met de naam ‘single.php’.

Omdat we nu een enkel bericht laden is de post-loop niet langer nodig. Alleen het gevraagde bericht wordt vertoond:

<body>
     <div id=”enkel_bericht”>
              <? php the_post(); ?>
               <h1> <?php the_title(); ?> </h1>
               <p> <?php the_content(); ?> </p>
     </div>
</body>

Het complete thema bestaat nu uit 3 bestanden: ‘index.php’, ‘single.php’ en ‘style.css’.

WordPress post-loop filteren

We hebben in een ander voorbeeld gekeken hoe we berichten verschillend vorm kunnen geven door de categorie van het bericht te gebruiken als css-class. Dat geeft al aardig wat mogelijkheden voor het vormgeven van de berichten, maar het is erg lastig om met die methode berichten op verschillende plaatsen binnen een pagina te plaatsen.

Standaard maakt WordPress gebruik van een opdracht die alle berichten uit de database haalt en ze binnen je pagina plaatst. In onderstaand voorbeeld worden alle berichten binnen een div geplaatst met de class ‘post’. De titel van het bericht wordt binnen een h1-tag geplaatst en de content van het bericht binnen een p-tag.

<body>
<div id=”content”>
     <div id=”producten”>
          <?php while ( have_posts() ) : 
                    the_post(); ?>
                    <div class=”post”> 
                         <h1><?php the_title(); ?></h1>
                         <p><?php the_content(); ?></p>
                    </div>
               <?php endwhile; ?>
     </div>
</div>
</body>  

Als we een filter toevoegen aan de opdracht om berichten te plaatsen is het mogelijk om niet alle berichten te plaatsen, maar een selectie van berichten te maken. In onderstaand voorbeeld worden alleen berichten geplaatst met de categorie “producten”.

<body>
<div id=”content”>
     <div id=”producten”
          <?php query_posts(‘category_name= producten’);
               while ( have_posts() ) : 
                    the_post(); ?>
                    <div class=”post”> 
                         <h1><?php the_title(); ?></h1>
                         <p><?php the_content(); ?></p>
                    </div>
               <?php endwhile; ?>
     </div>
</div>
</body>  

Deze opdracht om berichten te plaatsen kun je verschillende keren gebruiken, steeds met een ander filter. Bijvoorbeeld om links op een pagina producten te vertonen, en rechts op de pagina nieuwsberichten te plaatsen. In onderstaand voorbeeld wordt de opdracht om berichten te plaatsen 2 keer herhaalt. Het enige verschil is de categorie-naam die gefilterd wordt.

<body>
<div id=”content”>
     <div id=”producten”
          <?php  query_posts(‘category_name= producten’);
               while ( have_posts() ) :
                    the_post(); ?>
                    <div class=”post”>
                         <h1><?php the_title(); ?></h1>
                         <p><?php the_content(); ?></p>
                    </div>
               <?php endwhile;  ?>
     </div>
     <div id=”nieuws”>
          <?php query_posts(‘category_name= nieuws’);
               while ( have_posts() ):
                    the_post(); ?>
                   <div class=”post”>
                         <h1><?php the_title(); ?></h1>
                         <p><?php the_content(); ?></p>
                    </div>
               <?php endwhile; ?>
     </div>
</div>
</body>

WordPress custom Field gebruiken als css class

Bij het schrijven van een bericht is het mogelijk om een aantal extra gegevens toe te voegen aan het bericht. Standaard kan voor een bericht een datum, categorie en tags ingevuld worden. Maar er zijn meer mogelijkheden. Door gebruik te maken van Custom Fields is het mogelijk zelf invul vensters toe te voegen aan een bericht. Ga hiervoor naar de ‘Screen Options’ en vink ‘Custom Fields’ aan.

Er verschijnt nu een invul veld met de titel Custom Fields. Daarin kan een ‘Name’ en een ‘Value’ ingevuld worden. Bijvoorbeeld Name: ‘soort’, value:’fotobericht’. Deze informatie kan door WordPress makkelijk toe gevoegd worden aan een bericht door de opdracht ‘the_meta()’. Deze WordPress functie wordt net als bijvoorbeeld ‘the_content()’ en ‘the_title()’ gebruikt om content te plaatsen. ‘the_meta()’ maakt een ul-tag met daarin li-elementen voor elke Custom Field waarde.

Deze functie is minder geschikt voor het toevoegen van een css-class. We gebruiken wel het Custom Field, maar in combinatie met de opdracht ‘get_post_meta()’. We gebruiken ‘get_post_meta()’ in onderstaand voorbeeld om de value(s) van het Custom Field als css-class toe te voegen. We beginnen met de post-loop om berichten te laden:

<body>
     <div id=”berichten”>
     <?php while(have_posts()):
           the_post(); 
           endwhile; ?>
     </div>
</body>

Vervolgens plaatsen we de content van ieder bericht in een div. Let op, de php code wordt onderbroken door html. Vergeet dus niet de php-tag voor de html te sluiten en na de html weer te openen.

<body>
     <div id=”berichten”>
     <?php while(have_posts()):
          the_post();?>
          <div>
               <?php the_content()?>
          </div>
     <?php endwhile; ?>
     </div>
</body>

De content van ieder bericht wordt in een div-tag geplaatst. Nu willen we de Value van het Custom Field gebruiken als css-class voor de div die ieder bericht verpakt.

<body>
     <div id=”berichten”>
     <?php while(have_posts()):
          the_post();?> 
          <div class=” <?php get_post_meta(); ?> “>
               <?php the_content()?>
          </div>
     <?php endwhile; ?>
     </div>
</body>

Voordat WordPress de meta gegevens kan laden met de functie ‘get_post_meta()’  moeten een aantal gegevens aan de functie doorgegeven worden:  Van welk bericht moeten de gegevens opgehaald worden:

<body>
     <div id=”berichten”>
     <?php while(have_posts()):
          the_post();?> 
          <div class=” <?php get_post_meta(get_the_ID()); ?> “>
               <?php the_content()?>
          </div>
     <?php endwhile; ?>
     </div>
</body>

Ook moet aangegeven worden welke meta gegevens opgehaald moeten worden. In dit voorbeeld hebben we in het Custom Field de Name ‘soort’ ingevuld. Door die Name aan de functie door te geven wordt de Value (‘fotobericht’) opgehaald.

<body>
     <div id=”berichten”>
     <?php while(have_posts()):
          the_post();?> 
          <div class=” <?php get_post_meta(get_the_ID(), ‘soort’); ?> “>
               <?php the_content()?>
          </div>
     <?php endwhile; ?>
     </div>
</body>

De laatste waarde die doorgegeven moet worden aan de functie is of het wel of niet een enkele waarde moet zijn. In het voorbeeld hebben we een Name en een Value ingevuld, het betreft dus een enkele waarde:

<body>
     <div id=”berichten”>
     <?php while(have_posts()):
          the_post();?> 
          <div class=” <?php get_post_meta(get_the_ID(), ‘soort’, true); ?> “>
               <?php the_content()?>
          </div>
     <?php endwhile; ?>
     </div>
</body>

WordPress bericht-categorie gebruiken als css class

WordPress kent 2 manieren om content te plaatsen; Content die lange tijd niet aangepast hoeft te worden wordt als pagina (page) gepubliceerd, bijvoorbeeld een contact pagina. Content die regelmatig uitgebreid of ge-update wordt, wordt gepubliceerd als bericht (post). Bijvoorbeeld een aanbiedingen pagina van een bedrijf of webshop.

In dit voorbeeld bekijken we hoe we de geplaatste berichten kunnen vormgeven met css. Daarvoor gebruiken we de  categorie van het bericht als css class. Op die manier kunnen berichten met verschillende categories verschillend vorm gegeven worden omdat ze verschillende css classes krijgen. We beginnen met de berichten te laden. Ieder bericht wordt in een div geplaatst met de class-naam ‘post’. Met css kunnen de algemene opmaak van de post beschrijven.

<body>
     <div id=”wrapper”>
          <?php while ( have_posts() ) : 
               the_post();?>
               <div class=”post “> 
                    <?php the_content();
               </div>
           endwhile;?>
     </div>
</body>

De volgende stap is om een extra css-class toe te voegen aan ‘post’. De extra class wordt bepaald door de categorie van het bericht. Zo kunnen berichten verschillende classes krijgen, die we met css verschillend vorm kunnen geven. Eerst wordt een variabel gemaakt (herkenbaar aan $) met de naam ‘category’. Met de functie ‘get_the_category()’ maakt WordPress een lijst van eigenschappen van het bericht. Die lijst wordt opgeslagen in de variabel ‘category’. Met ‘echo’ wordt de opdracht gegeven om het item ‘cat_name’  (van het eerste item) in het html bestand te schrijven.

<body>
     <div id=”wrapper”>
          <?php while ( have_posts() ) :
               the_post();?>
               <div class=”post <?php $category=get_the_category() ; echo $category[0]->cat_name; ?>“>
                    <?php the_content();
               </div>
           endwhile;?>
     </div>
</body>

Het is mogelijk om aan een bericht meerdere categorien toe te voegen. Om elke categorie toe te voegen moet de opdracht een beetje aangepast worden.

<body>
     <div id=”wrapper”>
          <?php while ( have_posts() ) : 
               the_post();?>
               <div class=”post <?php foreach(get_the_category() as $category); echo $category->cat_name; ?>”> 
                    <?php the_content();
               </div>
           endwhile;?>
     </div>
</body>

De categorie namen worden nu achter elkaar geplakt als een lange class-naam achter de class “post”. Om de categories van elkaar te scheiden moeten we na elke categorie een spatie toevoegen:

<body>
     <div id=”wrapper”>
          <?php while ( have_posts() ) : 
               the_post();?>
               <div class=”post <?php foreach(get_the_category() as $category); echo $category->cat_name .” “; ?> “> 
                    <?php the_content();
               </div>
           endwhile;?>
     </div>
</body>

 

 

WordPress menu laden

WordPress heeft twee manieren om via het dashboard content te plaatsen: Als pagina, of als bericht/post. Om een menu te maken die weergeeft welke pagina’s er zijn wordt de opdracht ‘wp_list_pages()’ gebruikt:

<body>
     <div id=”wrapper”>
          <header><h1><?php bloginfo(‘name’); ?></h1></header>
         <nav><?php wp_list_pages(); ?></nav>
         <div class=”berichten”></div>
     </div>
</body>

Als een website/blog is opgebouwd uit posts/berichten, kan er een menu lijst gemaakt worden waarin bijvoorbeeld de bericht-categories komen te staan. In plaats van ‘wp_list_pages()’ wordt dan gebruik gemaakt van ‘wp_list_categories()’.

<body>
     <div id=”wrapper”>
          <header><h1><?php bloginfo(‘name’); ?></h1></header>
         <nav><?php wp_list_categories(); ?></nav>
         <div class=”berichten”></div>
     </div>
</body>

Met de WordPress opdracht ‘wp_list_categories()’ maakt WordPress een menu dat bestaat uit een li met de titel ‘categories’, daarin zit een ul, en daarin zitten li elementen met elk een eigen a-tag. Zo’n ingewikkeld menu is lastig te stylen met css. Daarom geven we WordPress de opdracht om een menu te maken zonder titel (dan blijft er alleen een serie li-elementen over):

<body>
     <div id=”wrapper”>
          <header><h1><?php bloginfo(‘name’); ?></h1></header>
         <nav><?php wp_list_categories(‘title_li=’); ?></nav>
         <div class=”berichten”></div>
     </div>
</body>

WordPress berichten laden

Er zijn twee veel voorkomende manieren om content te plaatsen met WordPress: door middel van berichten (posts) of door middel van pagina’s (pages). In dit voorbeeld kijken we naar het plaatsen van berichten.

Voor het plaatsen van berichten moet WordPress in de database kijken of er berichten zijn. Daarvoor gebruikt WordPress een while-loop. Een loop is een opdracht die steeds herhaalt wordt.

<body>
     <?php while () :?>
     <?php endwhile; ?>
</body>

WordPress gebruikt de while-loop om te kijken of er een bericht is in de database.

<body>
     <?php while ( have_posts() ) : ?>
     <?php endwhile; ?>
</body>

Als dat zo is wordt het bericht geladen. Daarna kijkt WordPress of er meer berichten zijn om te laden enz. De loop stopt pas als alle berichten geladen zijn.

<body>
     <?php while ( have_posts() ) : the_post(); ?>
     <?php endwhile; ?>
</body>

WordPress laadt alle berichten uit de database, maar ze zijn nog niet zichtbaar. Laten we de content van de  berichten zichtbaar maken door ze in een div met id “berichten” plaatsen. Ieder bericht wordt in een nieuwe p-tag geplaatst.

<body>
     <div id=”berichten”>
          <?php while ( have_posts() ) : the_post() ;?>
          <p><?php the_content();?></p>
          <?php endwhile; ?>
     </div>
</body>

Als WordPress de gegevens van het bericht geladen heeft met de opdracht ‘the_post()’ kunnen we  verschillende delen van de content laden. In bovenstaand voorbeeld wordt de content geladen met de opdracht ‘the_content’. Behalve de content kan ook de titel van het bericht geladen worden. In onderstaand voorbeeld wordt de titel van het bericht geschreven in een h2-tag:

<body>
     <div id=”berichten”>
          <?php while ( have_posts() ) : the_post() ?>
          <h2><?php the_title?></h2>
          <p><?php the_content();?> </p>
          <?php endwhile; ?>
     </div>
</body>

Tenslotte kunnen we de content nog wat beter ordenen door de titel en de content samen in een div met de class-naam ‘bericht’ te plaatsen.

<body>
     <div id=”berichten”>
     <?php while ( have_posts() ) : the_post() ?>
          <div class=”bericht”>
               <h2><?php the_title?></h2>
               <p><?php the_content();?></p>
           </div>
           <?php endwhile; ?>
     </div>
</body>

Van html naar WordPress

WordPress is ooit begonnen als blog-tool en uitgegroeid tot een prima middel om volwaardige websites mee te maken. Toch is de blog-structuur nog duidelijk herkenbaar: Het plaatsen van content gaat in principe door het aanmaken van verschillende posts op een pagina.

Voor een wordpress-site zijn minstens 2 bestanden nodig met een verplichte naam: style.css (Hierin staat de opmaak van de website beschreven) en index.php(Hierin staat de opbouw van de website beschreven). Die bestanden kun je met bijvoorbeeld Dreamweaver maken en op de server uploaden met bijvoorbeeld Filezilla. Het is belangrijk dat de bestanden in een map op de goede plaats ge-upload worden. Binnen de WordPress installatie is dat: htdocs/ wp-content/ themes/ map eigen theme.

In een html-pagina staat alle  content vast. Het voordeel van het gebruiken van een cms (conten management system) is dat content opgeslagen wordt in een database. Een cms als WordPress kan met gebruik van php-functies data ophalen en bijschrijven in het html-document. Voor het maken van een originele WordPress website kun je goed beginnen met een html versie van de site. Zo kun je met css het ontwerp goed neerzetten. Vervolgens vervang je de html teksten voor WordPress functies die in de database op zoek gaan naar de juiste informatie.

Als de bestanden ‘index.php’ en ‘style.css’ geupload zijn in de themes-map van WordPress zijn ze via de editor in het dashboard te veranderen. Om te beginnen moet de link naar het ‘style.css’ door WordPress zelf gemaakt worden. WordPress krijgt de opdracht om alle algemene informatie over de website/blog op te halen, en daarvan de ‘stylesheet_url’ te gebruiken.

<head>
<link type=”tekst/css” rel=”stylesheet” href=”<?php bloginfo( ‘stylesheet_url’ ); ?>/>
</head>

Van de lijst met bloginfo kunnen veel meer gegevens gebruikt worden, bijvoorbeeld de titel van de website/blog. Met onderstaand voorbeeld zoekt WordPress de titel die de gebruiker heeft opgegeven in het dashboard bij de instellingen .

<head>
<link type=”tekst/css” rel=”stylesheet” href=”<?php bloginfo( ‘stylesheet_url’ ); ?>”/>
<title><?php bloginfo(‘name’); ?></title>
</head>

Met de verschillende WordPress functies is zo een hele website op te bouwen. Hier volgt een voorbeeld van een basis pagina met een header, een menu en ruimte om berichten te plaatsen. Deze elementen zijn met css makkelijk vorm te geven. De content die  Wordpress hier  aan toe voegt zal zich automatisch aan je css aanpassen.

<body>
     <div id=”wrapper”>
          <header></header>
          <nav></nav>
          <div class=”berichten”></div>
     </div>
</body>

Aan deze eenvoudige html-structuur kunnen we door WordPress content laten toevoegen. Bijvoorbeeld de titel van onze website in een h1-tag in de header plaatsen:

<body>
     <div id=”wrapper”>
          <header><h1><?php bloginfo(‘name’); ?></h1></header>
          <nav></nav>
          <div class=”berichten”></div>
     </div>
</body>

WordPress heeft twee manieren om via het dashboard content te plaatsen: Als pagina, of als bericht/post. Om een menu te maken die weergeeft welke pagina’s er zijn wordt de opdracht ‘wp_list_pages()’ gebruikt:

<body>
     <div id=”wrapper”>
          <header><h1><?php bloginfo(‘name’); ?></h1></header>
         <nav><?php wp_list_pages(); ?></nav>
         <div class=”berichten”></div>
     </div>
</body>

Als een website/blog is opgebouwd uit posts/berichten, kan er een menu lijst gemaakt worden waarin bijvoorbeeld de bericht-categories komen te staan. In plaats van ‘wp_list_pages()’ wordt dan gebruik gemaakt van ‘wp_list_categories()’.

<body>
     <div id=”wrapper”>
          <header><h1><?php bloginfo(‘name’); ?></h1></header>
         <nav><?php wp_list_categories(); ?></nav>
         <div class=”berichten”></div>
     </div>
</body>

Met de WordPress opdracht ‘wp_list_categories()’ maakt WordPress een menu dat bestaat uit een li met de titel ‘categories’, daarin zit een ul, en daarin zitten li elementen met elk een eigen a-tag. Zo’n ingewikkeld menu is lastig te stylen met css. Daarom geven we WordPress de opdracht om een menu te maken zonder titel (dan blijft er alleen een serie li-elementen over):

<body>
     <div id=”wrapper”>
          <header><h1><?php bloginfo(‘name’); ?></h1></header>
         <nav><?php wp_list_categories(‘title_li=’); ?></nav>
         <div class=”berichten”></div>
     </div>
</body>

Om de content toe te voegen is een wat ingewikkelder code nodig. WordPress kijkt in de database of er posts/berichten zijn. Ieder bericht dat gevonden wordt, wordt in de div ‘berichten’ geplaatst.

<body>
     <div id=”wrapper”>
          <header><h1><?php bloginfo(‘name’); ?></h1></header>
          <nav><?php wp_list_categories(‘title_li=’); ?></nav>
          <div class=”berichten”>
               <?php while ( have_posts() ): the_post(); 
                         the_content(); 
                    endwhile; ?>
          </div>
     </div>
</body>

Als WordPress een post/bericht gevonden heeft kan er eenvoudig een titel toegevoegd worden. In onderstaand voorbeeld wordt de titel van het bericht in een h2-tag geplaatst en de content van het bericht vervolgens in een p-tag. Let op, de wordpress/php opdracht wordt onderbroken door de 2 html-tags. De php-tag moet dan ook afgesloten worden voordat de html-tag geplaatst wordt. Na de html-tags wordt er een nieuwe php-tag geopend.

<body>
     <div class=”wrapper”>
          <header><h1><?php bloginfo(‘name’); ?></h1></header>
          <nav><?php wp_list_categories(‘title_li=’); ?></nav>
          <div class=”berichten”>
               <?php while ( have_posts() ): the_post(); ?>
                         <h2> <?php the_title(); ?> </h2>
                         <p> <?php the_content(); ?> </p>
                   <?php  endwhile; ?>
          </div>
     </div>
</body>

Op dezelfde manier is het mogelijk om elk bericht in een eigen div te plaatsen, zodat de berichten gestyled kunnen worden met css. Let op, je kunt geen html en php door elkaar gebruiken. Voordat een html-tag geplaatst wordt moet eerst de php-tag afgesloten worden (en na de html-tag weer geopend):

<body>
     <div class=”wrapper”>
          <header><h1><?php bloginfo(‘name’); ?></h1></header>
          <nav><?php wp_list_categories(‘title_li=’); ?></nav>
          <div class=”berichten”>
             <?php while ( have_posts() ):<?php the_post();?>
<div class=”bericht”>
<h2> <?php the_title(); ?> </h2>
<p> <?php the_content(); ?> </p>
</div>
<?php endwhile;?>

          </div>
     </div>
</body>

Het WordPress thema dat we gemaakt hebben bestaat nu uit 2 bestanden: ‘index.php’ en ‘style.css’. De opmaak van ons WordPress thema kunnen we verder uitwerken in het bestand ‘style.css’.

Javascript getElementsbyClassName

Een veel voorkomende manier om met Javascript elementen te selecteren is ‘document.getElementById()’. Dat is een methode die goed werkt als je unieke elementen wilt beïnvloeden met Javascript. Voor deze methode is het wel noodzakelijk dat ieder element dat je wilt gebruiken een ‘id’ heeft.

In documenten waar veel dezelfde elementen voorkomen kan het chaotisch en vergezocht worden om ieder element van een id te voorzien. Een weblog kan bijvoorbeeld veel uit veel kleine post bestaan. Die post krijgen hun opmaak van een css-class, in plaats van een id.

Om html-elementen zonder id, maar met een class toch aan te kunnen spreken met Javascript is er de methode: document.getElementsByClassName(‘class’). Javascript doorzoekt het document en maakt een lijst van alle elementen met de class-naam tussen de haakjes.

In onderstaand voorbeeld wordt de variabel ‘berichtDivs’ gemaakt. Daar wordt een lijst in gemaakt van drie divs met de class ‘bericht’.

<body>
     <div class=”bericht”><p>tekst</p></div>
     <div class=”bericht”><p>tekst</p></div>
     <div class=”bericht”><p>tekst</p></div>
<script type=”text/javascript”>
var berichtDivs=document.getElementsByClassName(“bericht”);
</script>
</body>

 

Om 1 van de berichten uit de lijst ‘berichtDivs’ te selecteren moet  je aangeven welk bericht  je bedoelt. In dit voorbeeld kunnen we de 1e, 2e of 3e div bedoelen.  Op deze manier werkt een Javascript-lijst ook. De 1e div met class ‘bericht’ wordt op de 1e plaats in de lijst gezet (positie 0), de 2e op de 2e plek (positie 1), de 3e op de 3e plek (positie 2).

In onderstaand voorbeeld maken we de eerste div uit de lijst ‘berichtDivs’ onzichtbaar. Daarbij wordt na het noemen van de variabel ‘berichtDivs’ tussen blokhaken [ ] aangegeven de hoeveelste div bedoeld wordt.

<body>
<div class=”bericht”><p>tekst</p></div>
<div class=”bericht”><p>tekst</p></div>
<div class=”bericht”><p>tekst</p></div>
<script type=”text/javascript”>
var berichtDivs=document.getElementsByClassName(“bericht”);

berichtDivs[0].style.visibility=”hidden”;
</script>
</body>

Op dezelfde manier werkt ook ‘document.getElementsByTagName()’. Een methode die gebruikt kan worden als er geen gebruik gemaakt wordt van id’s en classes. Alle html-elementen met de opgegeven tag-naam worden in een lijst gezet. In onderstaand voorbeeld krijgt de 2e p-tag (positie 1) de tekstkleur rood.

<body>
<div class=”bericht”><p>tekst</p></div>
<div class=”bericht”><p>tekst</p></div>
<div class=”bericht”><p>tekst</p></div>
<script type=”text/javascript”>
var berichtDivs=document.getElementsByClassName(“bericht”);
var teksten=document.getElementsByTagName(“p”);

berichtDivs[0].style.visibility=”hidden”;
teksten[1].style.color=”red”;
</script>
</body>

 

Datum en tijd gebruiken met Javascript

Met Javascript is het mogelijk de datum en tijd uit te lezen van de computer/telefoon van de bezoeker van je website. Dat kan bijvoorbeeld gebruikt worden aan te geven hoe lang een kortingsactie nog geldig is.

Javascript kan in 1 opdracht alle tijdsgegevens ophalen. Die worden samen in een variabel opgeslagen. We geven die variabel de naam ‘tijd’ Als we de inhoud van ‘tijd’ opvragen in een alert-bericht krijgen we een rij gegevens te zien (dag, maand, datum, jaar, uren, minuten, seconden).

<body>
<script type=”text/javascript”>
var tijd=new Date();
alert(tijd);
</script>
</body>

Om die gegevens beter te kunnen gebruiken is het handiger om die variabel ‘tijd’ met de rij gegevens op te knippen in afzonderlijke variabelen. Dat kun je doen door van alle gegevens van ‘tijd’ er 1 op te vragen. In onderstaand voorbeeld wordt binnen alle gegevens van ‘tijd’ gezocht naar het huidige jaar.

<script type=”text/javascript”>
var tijd=new Date();
var jaar=tijd.getFullYear();
alert(jaar);
</script>

Op dezelfde manier zijn ook de andere gegevens als afzonderlijke variabelen op te slaan, maar bij het opvragen van de maand is iets bijzonders te zien. Het lijkt er namelijk op dat Javascript er een maand naast lijkt te zitten. In April (de 4e maand) geeft Javascript als antwoord ‘3’ bij het uitvoeren van de functie getMonth(). De reden hiervoor is dat Javascript niet bij ‘1’ begint te tellen, maar bij ‘0’.

<script type=”text/javascript”>
var tijd=new Date();
var jaar=tijd.getFullYear();
var maand=tijd.getMonth();
alert(maand);
</script>

De opdracht ‘getDate()’ geeft gewoon aan de hoeveelste dag van de maand het is, maar als we de dag opvragen krijgen met ‘getDay()’ zien we dat Javascript een getal geeft in plaats van de naam van de dag. Ook nu begint Javascript bij ‘0’ te tellen.

<script type=”text/javascript”>
var tijd=new Date();
var jaar=tijd.getFullYear();
var maand=tijd.getMonth();
var datum=tijd.getDate();
alert(datum);
</script>

<script type=”text/javascript”>
var tijd=new Date();
var jaar=tijd.getFullYear();
var maand=tijd.getMonth();
var datum=tijd.getDate();
var dag=tijd.getDay();
alert(dag);
</script>

De uren, minuten en seconden worden gegeven in de verwachte getallen.

<script type=”text/javascript”>
var tijd=new Date();
var jaar=tijd.getFullYear();
var maand=tijd.getMonth();
var datum=tijd.getDate();
var dag=tijd.getDay();
var uren=tijd.getHours();
var minuten=tijd.getMinutes();
var seconden=tijd.getSeconds();
alert(seconden);
</script>

We zijn nu zover dat we met Javascript de datum gegevens uit kunnen lezen en bewaren in variabelen. Die variabelen hebben we vertoont in een alert-pop up. Het wordt boeiender als we deze variabelen kunnen toepassen binnen een html-document. Als voorbeeld maken we een eenvoudige klok. Om te beginnen hebben we in de body een tekst-tag nodig. Die geven we de id ‘klok’ zodat we deze tag makkelijk met Javascript kunnen vinden.

<body>
<h1 id=”klok”></h1>

<script type=”text/javascript”>

Vervolgens laten we Javascript zoeken naar een tag met de id ‘klok’. Die zoektocht wordt opgeslagen in een variabel. Daarna plaatsen we de uren, minuten en seconden in ‘klok’ door gebruik te maken van de opdracht ‘innerHTML’. De uren, minuten en seconden worden gescheiden door een dubbele punt(:).

<script type=”text/javascript”>
var tijd=new Date();
var jaar=tijd.getFullYear();
var maand=tijd.getMonth();
var datum=tijd.getDate();
var dag=tijd.getDay();
var uren=tijd.getHours();
var minuten=tijd.getMinutes();
var seconden=tijd.getSeconds();
//alert(seconden);

var klok=document.getElementById(“klok”);
klok.innerHTML=uren +”:” +minuten +”:” +seconden;
</script>

Nu wordt de juiste tijd weergegeven in een html pagina. Het valt wel meteen op dat de klok stil staat. De opdracht aan Javascript om de datum gegevens op te halen, op te slaan in variabelen en te vertonen in de h1-tag ‘klok’, wordt namelijk maar 1 keer uitgevoerd.

Om Javascript de tijd elke seconde te laten verversen hebben we een functie nodig die door een ‘setInterval’ geactiveerd wordt. Daarvoor moeten we een aantal dingen aanpassen. Om te beginnen worden alle variabelen die we nodig hebben al wel gemaakt/benoemd, maar nog zonder waarde. Daarna maken we een ‘setInterval’ die elke seconde de functie ‘veranderTijd()’ uitvoert. De functie ‘veranderTijd’ leest de actuele tijd en plaatst die in de variabelen.

<script type=”text/javascript”>
var tijd;
var jaar;
var maand;
var datum;
var dag;
var uren;
var minuten;
var seconden;
//alert(seconden);

var klok=document.getElementById(“klok”);
klok.innerHTML=uren+”:” +minuten+”:” +seconden;
var interval=setInterval(veranderTijd,1000);

function veranderTijd()
{
     tijd=new Date();
     jaar=tijd.getFullYear();
     maand=tijd.getMonth();
     datum=tijd.getDate();
     dag=tijd.getDay();
     uren=tijd.getHours();
     minuten=tijd.getMinutes();
     seconden=tijd.getSeconds();
}
</script>

Nu wordt de tijd elke seconde bijgewerkt, maar dat is nog niet te zien in ‘klok’. Daarom moet de opdracht om html aan te passen van ‘klok’ ook verplaatst worden naar een plek binnen de functie ‘veranderTijd’. Na 1 seconde wordt deze functie uitgevoerd. Dat zorgt ervoor dat we 1 seconde moeten wachten voordat onze klok zichtbaar is en gaat lopen. Om dat op te lossen kunnen we Javascript de opdracht geven om bij het laden van het document alvast 1 keer de functie ‘veranderTijd’ uit te voeren. Dat wordt vervolgens elke seconde herhaalt door ‘interval’.

<script type=”text/javascript”>
var tijd;
var jaar;
var maand;
var datum;
var dag;
var uren;
var minuten;
var seconden;
//alert(seconden);

var klok=document.getElementById(“klok”);

var interval=setInterval(veranderTijd,1000);

function veranderTijd()
{
     tijd=new Date();
     jaar=tijd.getFullYear();
     maand=tijd.getMonth();
     datum=tijd.getDate();
     dag=tijd.getDay();
     uren=tijd.getHours();
     minuten=tijd.getMinutes();
     seconden=tijd.getSeconds();

     klok.innerHTML=uren+”:” +minuten+”:” +seconden;
}
veranderTijd();
</script>

Javascript setInterval

Er zijn situaties waarin je wilt dat een bepaalde javascript functie niet meteen, maar na een tijdje uitgevoerd of herhaalt moet worden. Daarvoor heeft Javascript de setInterval() functie. Die functie heeft twee parameters nodig tussen de ronde haakjes: De functie die uitgevoerd moet worden en om de hoeveel tijd die functie uitgevoerd moet worden, de interval. De waarde van de interval is in mili seconden. In onderstaand voorbeeld wordt de functie ‘popUp’ elke 2 seconden uitgevoerd.

<body>
<script type=”text/javascript”>
setInterval(popUp, 2000);

function popUp()
{
     alert(“ok”);
}
</script>
</body>

Een setInterval wordt in principe oneindig herhaald. Om dat te voorkomen kan de setInterval gestopt worden door de functie clearInterval(). Tussen de ronde haakjes van clearInterval() wordt de naam aangegeven van de setInterval die beëindigd moet worden. Daarvoor heeft de setInterval wel een naam nodig. Die naam wordt gegeven via een variabel. In het voorbeeld hieronder wordt de functie ‘popUp’ 1 keer uitgevoerd en dan wordt de interval meteen gestopt.

<body>
<script type=”text/javascript”>
var interval=setInterval(popUp, 2000);

function popUp()
{
     alert(“ok”);
     clearInterval(interval);
}
</script>
</body>

Als je een setInterval vaker dan 1 keer, maar niet oneindig wilt gebruiken, kun je nog een variabel gebruiken die bijhoudt hoevaak de setInterval actief is geweest. In combinatie met een if-voorwaarde kan de setInterval alsnog gestopt worden. In onderstaand voorbeeld wordt de setInterval 5 keer uitgevoerd. Elke keer wordt de variabel ‘aantalIntervals’ met 1 verhoogt. Als de waarde van ‘aantalIntervals’ gelijk is aan 5, wordt de setInterval beëindigd.

<body>
<script type=”text/javascript”>
var interval=setInterval(popUp, 2000);
var aantalIntervals=0;

function popUp()
{
     aantalIntervals+=1;
     alert(aantalIntervals);

     if(aantalIntervals==5)
     {
         clearInterval(interval);
     }
}
</script>
</body>

 

Html attribuut aanpassen met Javascript

Javascript kan in principe alles binnen een html-document aanpassen. In dit voorbeeld kijken we naar de mogelijkheid om attributen in de html-tags aan te passen. Zo is het bijvoorbeeld mogelijk om het src-attribuut van een img-tag of i-frame te veranderen, of het href-attribuut van een a-tag.

In dit voorbeeld gebruiken we een iframe om een youtube video te vertonen. Met Javascript veranderen we het src-attribuut zodat binnen hetzelfde i-frame verschillende video’s vertoont kunnen worden.

Stap 1. Om te beginnen hebben we een nieuw html-document nodig met in de body-tag een iframe naar een youtube video. Youtube geeft bij iedere video de mogelijkheid de video te delen. Bij de opties voor ‘delen’ kun je de juiste iframe code kopieren.  We willen later met Javascript aanpassingen doen aan de instellingen van het iframe. Daarom voegen we een id-attribuut toe met de naam ‘video’, zodat Javascript het iframe makkelijk kan vinden. Nadat we een iframe hebben toegevoegd aan ons html-document plaatsen we twee a-tags die als knoppen gebruikt gaan worden om het src-attribuut van het iframe te veranderen.

<body>
     <iframe id=”video” width=”560″ height=”315″ src=”//www.youtube.com/embed/video” frameborder=”0″ allowfullscreen></iframe>
     <a href=”#”>Javascript voor beginners</a>
     <a href=”#”>Javascript voor gevorderden</a>
</body>

Stap 2. De beide knoppen moeten een Javascript functie uitvoeren als er op geklikt wordt. De functies die uitgevoerd moeten worden zijn zelfbedachte functies, daarom moeten we de functies zelf beschrijven in de script-tag. We noemen de functies: ‘filmBeginners()’ en ‘fimlGevorderden()’. Javascript moet aanpassingen doen aan het iframe ‘. Daarom geven we Javascript eerst de opdracht dit iframe met de id ‘video’ op te zoeken in het html-document. Om die zoektocht maar 1 keer te hoeven maken wordt de zoekopdracht opgeslagen in een variabel.

Let op! Youtube gaat ervan uit dat video’s online gedeeld worden. Als een video vertoont moet worden op een website op je computer, moet de url die youtube geeft aangevuld worden met ‘http:’ voor de url : src=”http://www.youtube.com/embed/video”

<body>
<iframe id=”video” width=”560″ height=”315″ src=”http://www.youtube.com/embed/video” frameborder=”0″ allowfullscreen></iframe>
<a href=”#” onclick=”filmBeginners()”>Javascript voor beginners</a>
<a href=”#” onclick=”filmGevorderden()”>Javascript voor gevorderden</a>

<script type=”text/javascript”>
var video=document.getElementById(“video”);

function filmBeginners()
{
}

function filmGevorderden()
{
}
</script>

</body>

Stap 3. Het iframe heeft meteen al een ingevuld src-attribuut, in dit geval wordt bij het laden van de pagina de film voor beginners vertoont. Als er op de knop met de functie ‘filmGevorderden()’ geklikt wordt, moet de waarde van het src-attribuut aangepast worden met een nieuwe url. Die url zoeken we ook weer op op youtube en plakken die in onze functie.

<script type=”text/javascript”>
var video=document.getElementById(“video”);

function filmBeginners()
{
     video.src=”http://www.youtube.com/embed/videoBeginners”;
}

function filmGevorderden()
{
     video.src=”http://www.youtube.com/embed/videoGevorderden”;
}
</script>

Stap 4. We hebben nu een mooi voorbeeld van een youtube videospeler met een eigen afspeel lijst. Maar deze manier van functies gebruiken wordt veel werk als we een lange afspeel lijst hebben. Als we de functie een beetje aanpassen hoeven we maar 1 functie te maken. We maken een nieuwe functie met de naam ‘veranderFilm()’ en gaan gebruik maken van de ronde haken van de functie ( ) om parameters te versturen naar de functie, in dit voorbeeld wordt tussen de haken aangegeven welke url de functie moet invullen bij het src-attribuut.

Let op! Bij het doorgeven van de url wordt er gebruik gemaakt van enkele leestekens ‘ ‘ binnen dubbele leestekens ” “.

<body>
<iframe id=”video” width=”560″ height=”315″ src=”http://www.youtube.com/embed/yQaAGmHNn9s” frameborder=”0″ allowfullscreen></iframe>
<a href=”#” onclick=”veranderFilm(‘http://www.youtube.com/embed/videoBeginners’)“>Javascript voor beginners</a>
<a href=”#” onclick=”veranderFilm(‘http://www.youtube.com/embed/videoGevorderden’)“>Javascript voor gevorderden</a>

<script type=”text/javascript”>
var video=document.getElementById(“video”);

function veranderFilm(videoUrl)
{
     video.src=videoUrl;
}

</script>
</body>

 

ScrollY gebruiken als input voor Javascript

Sinds Html5 wordt in veel websites gebruik gemaakt van het scrollen om elementen in de pagina aan te sturen. Bijvoorbeeld een element dat met een fade-in verschijnt als de gebruiker de pagina naar beneden scrollt. Voor dit effect wordt Javascript gebruikt die afhankelijk van de scrollhoogte opdrachten uitvoert. Met deze techniek kunnen heel ingewikkelde effecten gemaakt worden die het ontwerp van je website echt verrijken. In dit voorbeeld kijken we naar een eenvoudige manier om Javascript met de scrollbalk te laten samenwerken. Deze manier heeft zijn beperkingen, maar is eenvoudig te begrijpen en heel geschikt om mee te beginnen.

Stap 1. Allereerst hebben we een html-document nodig met de script-tag in de body. Voor dit voorbeeld hebben we een scrollbalk nodig, dus laten we beginnen met de body groter te maken dan het browser venster. Hiervoor gebruiken we css. Om een element een hoogte in procenten te geven is het noodzakelijk de hoogte eerst bij ‘html’ te benoemen. In dit voorbeeld benoemen we de hoogte in 1 keer voor html en de body-tag tegelijk.

<head>
<style>
html, body
{
height:200%;
}
</style>
</head>

<body>
<script type=”text/javascript”>
</script>
</body>

Stap 2. We gaan in dit voorbeeld Javascript een eenvoudige p-tag laten beïnvloeden door de scrollBalk. Om te beginnen plaatsen we een p-tag in de body. Omdat we deze p-tag willen beïnvloeden met Javascript geven we meteen een id attribuut met de naam ‘tekst’. Vervolgens laten we Javascript in het document zoeken naar de p-tag met id ‘tekst’.

<body>
<p id=”tekst”></p>

<script type=”text/javascript”>
var tekst=document.getElementById(“tekst”);
</script>
</body>

Stap 3. Om de scrollbalk te gebruiken is het handig om te zien welke informatie de scrollbalk doorgeeft. In dit voorbeeld gebruiken we de waarde van ‘scrollY’. Als het html-document geopend wordt heeft de scrollY standaard de waarde 0; De bovenkant van de website is in beeld. Als de gebruiker scrollt verschuift de scrollbalk tegelijk met de website. Laten we er eerst voor zorgen dat we te zien krijgen welke waarde de scrollbalk doorgeeft als er gescrollt wordt. Hiervoor maken we een variabel met de naam ‘scrollY’. Die waarde  verandert bij het scrollen. Daarom geven we Javascript de opdracht zelf op zoek te gaan naar de waarde van scrollY. Om de waarde van ‘scrollY’ zelf te kunnen zien plaatsen we die in p-tag ‘tekst’ met behulp van de Javascript eigenschap ‘innerHTML’. Let op, de variabele naam “ScrollY” mag niet hetzelfde geschreven worden als de waarde “scrollY”!

<script type=”text/javascript”>
var tekst=document.getElementById(“tekst”);
var scrolly=window.scrollY;

tekst.innerHTML=scrolly;
</script>

Stap 4. Bij het openen van het html-document wordt de waarde van scrollY in ‘tekst’ gezet. Scroll door de pagina en ververs het browservenster. Als ‘tekst’ nog in beeld is zul je zien dat er een andere waarde verschijnt. We gaan een paar aanpassingen doen zodat ‘tekst’ mooi in beeld blijft en we meteen bij het scrollen de waarde zien veranderen. Als Javascript merkt dat het html-document naar boven gescrollt wordt, laten we Javascript ‘tekst’ met het zelfde aantal pixels naar beneden plaatsen. Hierdoor lijkt het alsof ‘tekst’ blijft staan. Om dat te doen moet eerst de positie van ‘tekst’ ingesteld worden.

<style>
html, body
{
height:200%;
}
p#tekst
{
     position:absolute;
     top:0px;
     left:0px;
}
</style>

Vervolgens geven we Javascript de opdracht om iedere keer als er gescrollt wordt de functie ‘scrollen()’ uit te voeren. Dat is een functie die we zelf bedenken, en dus ook zelf moeten beschrijven. De functie ‘scrollen()’ doet 3 dingen: 1. De waarde van variabele ‘scrolly’ wordt bijgewerkt, 2. De waarde van variabele ‘scrolly’ wordt in ‘tekst’ geplaatst en 3. de css-top waarde van ‘tekst’ wordt aangepast. Omdat de waarde van ‘scrolly’ alleen een getal is, en css naast de waarde ook de eenheid moet weten, moet bij de nieuwe css-top waarde van Javascript de eenheid (+”px”) worden toegevoegd.

<script type=”text/javascript”>
var tekst=document.getElementById(“tekst”);
var scrolly=window.scrollY;

window.onscroll=scrollen;

function scrollen()
{
     scrolly=window.scrollY;
     tekst.innerHTML=scrolly;
     tekst.style.top=scrolly +”px”;
}

</script>

Stap 5. De laatste stap van dit voorbeeld. We zien dat de waarde van ‘scrolly’ hoger en lager wordt bij het heen en weer scrollen. Deze waarde gebruiken we nu om ‘tekst’ in beeld te houden, maar we kunnen natuurlijk meer css eigenschappen beïnvloeden. Bijvoorbeeld de opacity. Als de waarde van ‘scrolly’ laag is, maken we de opacity van ‘tekst’ laag. Als de waarde van ‘scrolly’ hoger wordt, wordt de opacity van ‘tekst’ hoger. De waarde van ‘scrolly’ kan behoorlijk groot worden in vergelijking met de waarde van opacity, die mag variëren van 0 tot 1. Om een mooi fade-effect te krijgen delen we de waarde van ‘scrolly’ daarom door een groot getal. In dit voorbeeld door 200.

<script type=”text/javascript”>
var tekst=document.getElementById(“tekst”);
var scrolly=window.scrollY;

window.onscroll=scrollen;

function scrollen()
{
scrolly=window.scrollY;
tekst.innerHTML=scrolly;
tekst.style.top=scrolly +”px”;
tekst.style.opacity=scrolly/200;
}

</script>

 

Javascript functies

Met Javascript heb je veel extra mogelijkheden om een website extra interactiviteit te geven. In tegenstelling tot Html en Css is Javascript een script taal. Daardoor is het mogelijk Javascript ingewikkelde opdrachten te geven en zelf informatie te verzamelen, voor bijvoorbeeld het uitvoeren van formules.

Die Javascript opdrachten(functies) worden volgens vaste grammatica regels geschreven. Als een functie niet aan de juiste grammatica regels voldoet, wordt de functie niet uitgevoerd. Het is dus heel belangrijk dat Javascript functies goed geschreven worden.

Stap 1. Om te beginnen plaatsen we de script-tag in het html-document, tussen de body-tags (Javascript kan ook tussen de head-tags of als gekoppeld Javascript bestand toegevoegd worden ).

<body>
<script type=”text/javascript”>
</script>
</body>

Stap 2. Het is nu mogelijk om bestaande Javascript functies uit te voeren, maar het is ook mogelijk om zelf functies te bedenken. Laten we eerst kijken naar een eenvoudig voorbeeld van de bestaande Javascript functie ‘alert()’. Deze functie geeft de opdracht een pop-up venster te openen.

<body>
<script type=”text/javascript”>
alert();
</script>
</body>

Laten we nu een eigen, nieuwe functie maken en bekijken hoe een functie in elkaar zit. Eerst vertel je Javascript dat je een functie maakt, vervolgens geef je een naam. Voor dit voorbeeld kiezen we voor de naam ‘popup’. Tussen de ronde haken die volgen ( ) kan informatie aan de functie door te geven. Dat is niet verplicht, de ruimte tussen de ronde haken mag leeg blijven. Tussen de accolades { }  wordt de opdracht beschreven die Javascript moet uitvoeren.

<body>
<script type=”text/javascript”>
function popup(){}
</script>
</body>

Stap 3. De functie werkt op zich wel, maar er ontbreken nog 2 dingen. de functie heeft nog geen inhoud om uit te voeren, en er wordt nog geen opdracht gegeven de functie uit te voeren. Laten we onze zelf bedachte functie ‘popup()’ gebruiken om de bestaande functie ‘alert()’ in te schakelen. Vervolgens geven we de opdracht  ‘popup()’ uit te voeren.

<body>
<script type=”text/javascript”>
function popup()
{
alert();
}

popup();

</script>
</body>

Zoals eerder beschreven is het mogelijk de ronde haken ( ) te gebruiken om informatie aan de functie door te geven. Zo kunnen we een zelfbedachte tekst binnen de pop-up plaatsen die opgeroepen wordt door onze functie.

<body>
<script type=”text/javascript”>
function popup()
{
alert“tekst”); 
}

popup();

</script>
</body>

Stap 4. Als laatste stap kunnen we ook de ronde haken van onze eigen functie gebruiken om informatie door te geven aan de functie ‘alert()’. Bij het activeren van de functie ‘popup()’ wordt een tekst mee gegeven, in dit voorbeeld is het de tekst ‘Frank’. Bij het maken/beschrijven van de functie geven we aan dat de functie informatie krijgt toegestuurd. In dit voorbeeld wacht de functie op ‘naam’. Die ‘naam’ stuurt de functie weer door naar de functie ‘alert()’.

<body>
<script type=”text/javascript”>
function popup(naam)
{
alert(naam); 
}

popup(“Frank”);

</script>
</body>

Als bij het activeren van de functie ‘popup()’ een andere tekst meegegeven wordt, bijvoorbeeld ‘hallo’, zal de functie deze tekst laten zien in het pop-up venster.

<body>
<script type=”text/javascript”>
function popup(naam)
{
alert(naam); 
}

popup(“Hallo“);

</script>
</body>

Css aanpassen met Javascript

Als je goed kunt werken met html en css heb je een goede basis om mooie web designs te maken. Je zult echter wel snel aanlopen tegen de beperkte interactieve mogelijkheden van html en css. Natuurlijk kun je met bijvoorbeeld :hover, transition en animation je ontwerp wat interactiever maken, maar daar houdt het ongeveer ook wel mee op.

Na het leren van html en css is het een mooie vervolgstap om Javascript te gebruiken om je website meer interactie te geven. Met Javascript is het mogelijk om alles binnen je html-pagina aan te passen. Hier bekijken we een voorbeeld van  een tekst die door verschillende knoppen een ander uiterlijk kan krijgen.

Stap1. Open een nieuw html-document en maak een koptekst. We willen het uiterlijk van de koptekst later aanpassen met Javascript. Daarom geven we de koptekst een id-attribuut zodat Javascript onze koptekst straks makkelijk kan vinden. Gebruik css om de koptekst te stylen.

<body>
     <h1 id=”koptekst”>Koptekts</h1>
</body>

En vervolgens de css:

<style>
h1#koptekst
{
font-family:”Courier New”, Courier, monospace;
font-size:36px;
color:#300;
}
</style>

Stap 2. Maak nu een aantal knoppen die we kunnen aanklikken om verschillende css instellingen te kunnen aanpassen met Javascript. We gebruiken a-tags en voegen daar de Javascript opdracht ‘onclick’ aan toe om een Javascript functie uit te voeren.

<body>
     <h1 id=”koptekst”>Koptekts</h1>
     <a href=”#” onclick=”klein()”>klein</a>
     <a href=”#” onclick=”rood()”>rood</a>
     <a href=”#” onclick=”arial()”>arial</a>
</body>

Als er op de a-tags geklikt wordt, worden er een functie uitgevoerd. Omdat we zelf een functie(naam) bedacht hebben moeten we die functies ook zelf omschrijven binnen script-tags:

<body>
<h1 id=”koptekst”>Koptekts</h1>
<a href=”#” onclick=”klein()”>klein</a>
<a href=”#” onclick=”rood()”>rood</a>
<a href=”#” onclick=”arial()”>arial</a>

<script type=”text/javascript”>
function klein()
{
}

function rood()
{
}

function arial()
{
}
</script>
</body>

Stap 3. We willen dat Javascript css gaat veranderen van de koptekst. Daarvoor moeten we beginnen met Javascript de opdracht te geven om een html-tag met id ‘koptekts’ te zoeken. We gaan verschillende aanpassingen doen, maar willen niet dat Javascript steeds opnieuw het hele document moet doorzoeken naar dezelfde html-tag. Daarom maken we 1 keer een variabel en koppelen die aan de zoekopdracht.

<script type=”text/javascript”>
var koptekst=document.getElementById(“koptekst”);

Nu Javascript de koptekst kan vinden kunnen we de opdracht geven om verschillende css instellingen aan te passen. Javascript doet eigenlijk aanpassingen aan instellingen van de style-eigenschap. Daarmee worden de originele css waardes overschreven.

<script type=”text/javascript”>
var koptekst=document.getElementById(“koptekst”);
function klein()
{
     koptekst.style.fontSize=”18px”;
}

function rood()
{
     koptekst.style.color=”#F00″;
}

function arial()
{
     koptekst.style.fontFamily=”Arial, Helvetica, sans-serif”
}
</script>

We hebben in dit voorbeeld een paar css waardes aangepast met Javascript. Met Javascript is het mogelijk alle css waardes te overschrijven. Voor een goede werking is het wel belangrijk dat iedere css waarde die later aangepast moet worden, al vooraf beschreven staat in het css document.

Css class veranderen met Javascript

Javascript kan in principe alle html en css beïnvloeden binnen een document. Toch heeft het als nadeel dat je website technisch onleesbaar kan worden als je teveel aanpast met Javascript. Dat kan voor frustraties zorgen als je bijvoorbeeld met iemand anders samenwerkt aan een site of als je na lange tijd aanpassingen moet doen.

Een goede oplossing hiervoor is om css classes van html elementen toe te voegen of te verwijderen. Op die manier zijn de verschillende css opmaak instellingen goed zichtbaar omdat ze allemaal als classes in het css document terug zijn te vinden. Het enige wat Javascript doet is een css class weghalen of toevoegen aan een element. Je zult zien dat dat direct gevolgen heeft voor het uiterlijk van het html element. Als voorbeeld maken we een vierkante knop die rond wordt als erop geklikt wordt.

 

Stap 1. Start met een nieuw html document, met daarin een a-tag. Deze tag willen we later aanpassen met Javascript, daarom geven we alvast een id.

<body>
     <a id=”knop” href=”#”> </a>
</body>

Vervolgens beschrijven we met css het uiterlijk van ‘knop’.

<style>
a#knop
{
     width:100px;
     height:100px;
     display:block;
     background-color:#000;
     border:#FFF 2px dashed;
     box-shadow:#000 0px 0px 0px 4px;
}
</style>

 

Stap 2. We hebben nu een vierkante knop. We willen dat die knop rond wordt als erop geklikt wordt. Het eerste wat we doen is het aangepaste uiterlijk beschrijven in een nieuwe class:

<style>
a#knop
{
width:100px;
height:100px;
display:block;
background-color:#000;
border:#FFF 2px dashed;
box-shadow:#000 0px 0px 0px 4px;
}

.rond
{
border-radius:50%;
}
</style>

 

Stap 3. De class waarin beschreven staat dat de knop rond moet zijn bestaat nu, maar heeft nog geen invloed omdat de class nog niet gekoppeld is aan de knop. Dat gaan we doen met Javascript. Om te beginnen moet de knop een Javascript functie uitvoeren als erop geklikt wordt. We noemen die functie ‘verandClass()’. Omdat Javascript die functie niet kent moeten we die  zelf maken. Dat doen we binnen de script-tag.

<a id=”knop” href=”#” onclick=”veranderClass()”> </a>

<script type=”text/javascript”>

     function veranderClass()
     {

     }
</script>

 

Stap 4. Als de knop aangeklikt wordt, moet javascript een class  bijschrijven in de html code, om precies te zijn in de a-tag met de id ‘knop’. Daarvoor moet Javascript eerst in het html document op zoek naar een tag met de id ‘knop’. Het is niet handig als Javascript bij iedere aanpassing opnieuw moet gaan zoeken. Daarom gebruiken we een variabel met de naam ‘knop’. Die symbool staat voor een html-tag met de id ‘knop’.

<script type=”text/javascript”>

     var knop=document.getElementById(“knop”);

     function veranderClass()
     {

     }

</script>

Vervolgens kunnen we in de functie ‘veranderClass’ de opdracht geven de class ‘rond’ toe te voegen aan ‘knop’.

<script type=”text/javascript”>
     var knop=document.getElementById(“knop”);

     function veranderClass()
     {
          knop.className=”rond”;
     }
</script>

 

We hebben nu een heel eenvoudig voorbeeld wat met 1 keer klikken werkt. Het blijft een simpele knop, maar het voorbeeld wordt net iets mooier als we kunnen wisselen tussen rond en vierkant. Als laatste stap gaan we  de functie ‘veranderClass’ uitbreiden door Javascript te laten kiezen: Als de knop geen class ‘rond’ heeft wordt de class ‘rond’ toegevoegd. Als de knop wel een class ‘rond’ heeft wordt de class ‘rond’ verwijderd (en wordt de knop vierkant).

<script type=”text/javascript”>
     var knop=document.getElementById(“knop”);

     function veranderClass()
     {
          if(knop.className==”rond”)
          {
               knop.className=””;
          }
          else
          {
               knop.className=”rond”;
          }
}
</script>