AI en studiekeuze

Inleiding

Wat ga je bouwen?

Je maakt een webpagina die gegevens uit een online opslagplek haalt, ze laat zien, en er nieuwe gegevens aan toevoegt. De opslagplek is een bin bij de dienst JSONBin. De gegevens zelf staan in het formaat JSON.

Met JavaScript praat je webpagina met JSONBin. Dat gebeurt met drie soorten verzoeken:

  • GET: haalt de huidige gegevens uit de bin op. Er verandert niets.
  • PUT: vervangt de inhoud van de bin door de nieuwe versie die je stuurt. Zo voeg je een record toe.
  • POST: maakt een nieuwe bin aan. Records voeg je niet met POST toe.
Het stappenplan

Je begint met de voorbereiding. Daarna werk je stap 1 tot en met 4 in volgorde af, want elke stap bouwt op de vorige.

  • Voorbereiding: gegevens opmaken in JSON
  • Stap 1: account en bin aanmaken
  • Stap 2: gegevens ophalen (GET)
  • Stap 3: gegevens op de pagina tonen
  • Stap 4: nieuw record toevoegen (PUT)

Daarna volgt de beveiliging met Firebase, in een eigen onderdeel.

Gegevens opmaken in JSON

De JSON datastructuur

In deze voorbereiding maak je de gegevens klaar in JSON. Hieronder staat een voorbeeld met drie records, waarbij elk record dezelfde vijf velden heeft.

Begrippen

  • Record: één object in de lijst, bijvoorbeeld één persoon.
  • Veld: één sleutel-waarde-paar binnen een record.
  • Sleutel (key): staat links van de dubbele punt.
  • Waarde (value): staat rechts van de dubbele punt.

Schrijfregels

  • Elk record staat tussen accolades { }. Records worden van elkaar gescheiden met een komma.
  • Sleutels staan tussen dubbele aanhalingstekens en bevatten alleen kleine letters, zonder spaties. Gebruik een underscore voor meerwoordige namen, zoals geboorte_datum.
  • Tekst staat tussen dubbele aanhalingstekens, zoals "Greet".
  • Getallen, true en false staan zonder aanhalingstekens.
				
					[
  {
    "voornaam": "Evert",
    "achternaam": "Jansen",
    "tussenvoegsel": "van den",
    "leeftijd": 17,
    "happy": true
  },
  {
    "voornaam": "Lisa",
    "achternaam": "de Vries",
    "tussenvoegsel": "",
    "leeftijd": 18,
    "happy": false
  },
  {
    "voornaam": "Greet",
    "achternaam": "Ignaarkennis",
    "tussenvoegsel": "",
    "leeftijd": 16,
    "happy": true
  }
]
				
			

Gebruik een tool zoals jsonlint om je JSON te controleren.

Stap 1: Account en bin aanmaken

Hoe maak ik een account aan?
  • Ga naar jsonbin.io.
  • Klik rechtsboven op “Sign up”.
  • Meld je aan met je schoolmail of met Google.
  • Kies het gratis account. Dit account voldoet voor onze opdracht. Je hebt geen creditcard nodig.
  • Bevestig je e-mailadres via de bevestigingsmail. Daarna kun je pas verder.
Hoe maak ik een bin aan?
  • Klik op “Create a New Bin”.
  • Plak je JSON in het veld en controleer die eerst op jsonlint.com.
  • Geef de bin een duidelijke titel. De titel en de privacy-instelling kun je later niet meer wijzigen. Alleen de inhoud kun je aanpassen.
  • Laat de bin op privé staan. Dat is de standaard.
  • Kopieer de bin-ID. Die heb je nodig in je JavaScript.

 

Hoe kom ik aan mijn sleutel?
  • Ga naar je dashboard en klik op “API Keys”.
  • Kopieer de Master Key (ook wel secret key genoemd). In de code gebruik je die als X-Master-Key.
  • Gebruik deze sleutel alleen om te oefenen, met een eigen bin en fictieve gegevens.
  • Let op: JavaScript draait in de browser. Wie de broncode bekijkt, ziet dan ook de sleutel. Deel een webapp dus nooit met de sleutel erin. Hoe je dat oplost, behandelen we in stap 5.

Stap 2: Gegevens ophalen (GET)

In je HTML-pagina maak je een div met id namenlijst. Daar komen de resultaten te staan, en bij een fout een foutmelding.

Voeg eerst jQuery toe met een <script>-regel in je HTML. Zonder jQuery werkt de code hieronder niet.

De sleutel en de bin-ID zet je in variabelen. De variabele data is een lege lijst waarin je de opgehaalde records bewaart.

Wat doet $.ajax()?
$.ajax() stuurt een verzoek op de achtergrond naar de database. De gebruiker kan intussen gewoon de pagina gebruiken. Het verzoek bevat:

  • url: het adres van de bin. /latest betekent: de laatste versie.
  • method: GET, dus je wilt gegevens ontvangen.
  • headers: je sleutel, zodat JSONBin weet wie je bent.
  • success: wat er gebeurt als het lukt. De gegevens komen in data.
  • error: wat er gebeurt als het mislukt.
				
					const apiKey = "jouw-API-sleutel";
const binId = "De-bin-ID";
let data = [];

function haalDataOp() {
  $.ajax({
    url: `https://api.jsonbin.io/v3/b/${binId}/latest`,
    method: "GET",
    headers: { "X-Master-Key": apiKey },
    success: function (response) {
      data = response.record;
      console.log(data);
    },
    error: function (xhr, status, error) {
      console.error("Fout bij ophalen:", status, error);
      $("#namenlijst").html("<p>Fout bij laden van data.</p>");
    }
  });
}
				
			

Stap 3: Gegevens op de pagina tonen

Wat doet deze functie?

De functie toonData() zet de records uit data op de pagina.

De functie maakt de lijst op de pagina leeg, controleert of de data een lijst is, en zet daarna per record een regel op de pagina.

DOM: de DOM is de opbouw van de webpagina zoals de browser die kent. Elk onderdeel op de pagina, zoals een <div> of een <p>, is een element. Met $("#namenlijst") zoek je het element op dat de id namenlijst heeft.

Roep toonData() aan in de success-functie van haalDataOp(), zodat de lijst wordt getoond zodra de gegevens binnen zijn.

Stap A: het juiste element vinden
$lijst is de variabele die het element van de pagina bevat. Het $-teken is een conventie en betekent dat dit een jQuery-object is.

Stap B: controleren of de data een lijst is
Array.isArray() controleert of iets een array is. Als dat niet zo is, toont de pagina een foutmelding. return stopt de functie meteen.

Stap C: per record een regel maken

  • forEach: loopt door elk element van de lijst. Het huidige record heet item.
  • ||: betekent “of”. Als tussenvoegsel leeg is of ontbreekt, gebruikt de code een lege tekst.
  • item => { ... }: een korte manier om function(item) { ... } te schrijven.
  • Verschil met een for-loop: een for-loop geeft ook de positie (0, 1, 2 enzovoort). Een forEach geeft alleen het element.
				
					function toonData() {
  const $lijst = $("#namenlijst");
  $lijst.empty();

  // Controleert of data echt een array is
  if (!Array.isArray(data)) {
    $lijst.html("<p>Geen geldige array ontvangen!</p>");
    return; // stopt de functie hier
  }

  data.forEach(item => {
    const tekst = `${item.voornaam} ${item.tussenvoegsel || ""} ${item.achternaam}
      (leeftijd: ${item.leeftijd}, blij: ${item.happy})`;
    $lijst.append($("<p>").text(tekst));
  });
}
				
			
item

bij elke ronde pakt forEach één record uit de lijst en geeft het de naam item. In de eerste ronde is item het eerste record, in de tweede ronde het tweede, enzovoort. Met item.voornaam haal je de voornaam uit dat record. In item => { ... } is item de naam van dat record.

Stap 4: Nieuw record toevoegen (PUT)

Wat leer je hier? Hoe je gegevens uit een formulier opslaat in de bin, en waarom de hele lijst opnieuw wordt verstuurd.

Het formulier

Maak in je HTML een formulier. De id’s moeten precies overeenkomen met de namen in je JavaScript.

Wat doet deze functie?

De functie wacht tot het formulier wordt verstuurd, controleert de leeftijd, slaat het nieuwe record op in de bin, en laat daarna de lijst opnieuw zien.

Stap A: het formulier uitlezen
.val() haalt de waarde op die iemand in een invoerveld heeft ingevuld. .trim() haalt spaties aan het begin en eind weg. Met $("#happy").val() === "true" zet je de keuze om in true of false.

Stap B: de leeftijd controleren
parseInt() zet tekst om in een getal. Als er geen getal staat, levert dat NaN op. isNaN() controleert dat. Dan stopt de code, zodat er geen null in de bin terechtkomt.

Stap C: het record toevoegen en opslaan
[...data, nieuwRecord] maakt een nieuwe lijst met het nieuwe record erbij. JSON.stringify() zet die lijst om in JSON-tekst, en Content-Type vertelt JSONBin dat je JSON stuurt. Pas bij een geslaagde PUT wordt de nieuwe lijst de data.

Stap D: het resultaat tonen
Bij succes staat er een bevestiging in #feedback, worden de records opnieuw opgehaald en wordt het formulier leeggemaakt. Bij een fout verschijnt een foutmelding.

Let op bij PUT: PUT vervangt de hele inhoud van de bin. Als twee leerlingen tegelijk iets toevoegen, kan de ene toevoeging de andere overschrijven.

				
					<form id="toevoeg-formulier">
  <input id="voornaam" type="text">
  <input id="achternaam" type="text">
  <input id="tussenvoegsel" type="text">
  <input id="leeftijd" type="number">
  <select id="happy">
    <option value="true">Ja</option>
    <option value="false">Nee</option>
  </select>
  <button type="submit">Toevoegen</button>
</form>
<div id="feedback"></div>

				
			
				
					$("#toevoeg-formulier").on("submit", function (e) {
  e.preventDefault(); // voorkomt dat de pagina opnieuw laadt

  const leeftijd = parseInt($("#leeftijd").val());
  if (isNaN(leeftijd)) {
    $("#feedback").text("Vul een geldige leeftijd in.");
    return; // stopt hier, er wordt niets opgeslagen
  }

  const nieuwRecord = {
    voornaam: $("#voornaam").val().trim(),
    achternaam: $("#achternaam").val().trim(),
    tussenvoegsel: $("#tussenvoegsel").val().trim(),
    leeftijd: leeftijd,
    happy: $("#happy").val() === "true"
  };

  const nieuweLijst = [...data, nieuwRecord];

  $.ajax({
    url: `https://api.jsonbin.io/v3/b/${binId}`,
    method: "PUT",
    headers: {
      "X-Master-Key": apiKey,
      "Content-Type": "application/json"
    },
    data: JSON.stringify(nieuweLijst),
    success: function () {
      data = nieuweLijst;
      $("#feedback").text("Succesvol toegevoegd!");
      haalDataOp();
      $("#toevoeg-formulier").trigger("reset");
    },
    error: function () {
      $("#feedback").text("Fout bij toevoegen.");
    }
  });
});
				
			

Volgende onderdeel: een veilige webapp met Firebase

Deze database bevat persoonlijke gegevens. Daarom beschermen we de webapp straks met een login, zodat alleen ingelogde gebruikers de pagina kunnen gebruiken. Dat doen we in het volgende onderdeel met Firebase.

Let op: een login beschermt de pagina, niet de sleutel. De apiKey staat nog steeds in de JavaScript, en die draait in de browser. Wie de broncode bekijkt, ziet de sleutel en kan dus ook zelf bij de bin. Dat lossen we in het volgende onderdeel op.

 

Je hebt nu alle stappen gehad: je hebt een bin aangemaakt, data opgehaald, de data op de pagina getoond en een nieuw record toegevoegd. Daarmee ben je klaar voor de beveiliging.