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>

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>