Beste 4D-formulieren: topkeuzes vergeleken (2026)

4D-formulieren vormen de gebruikersinterfacelaag van een 4D-applicatie en het platform biedt drie verschillende formuliertypen: detail-, lijst- en bestaand uitvoerformulier, elk geschikt voor een andere taak. Om het in 2026 goed te doen, betekent dit dat het formuliertype moet worden afgestemd op de taak en dat vervolgens lijsten met waarden, subformulieren en dynamische eigenschappen in lagen moeten worden geplaatst. Deze vergelijking omvat praktische opties, hun afwegingen en hoe u een beslissing moet nemen.

Belangrijkste punten

• 4D biedt drie soorten 4D-formulieren: detail (één record tegelijk), lijst (meerdere records in een raster) en uitvoer (afdruk/rapport-indeling). Het kiezen van het verkeerde type is de meest voorkomende fout die beginners maken.
• Projectformulieren (opgeslagen als .4DForm JSON-bestanden) zijn de moderne standaard; Tabelformulieren zijn verouderd en gekoppeld aan één tabel. Nieuw werk moet projectvormen gebruiken.
• Dynamische Formulieren (DIALOG, FORM LOAD, FORM GOTO PAGE) stellen u in staat om tijdens runtime interfaces te creëren en uit te wisselen - essentieel voor stromen in wizard-stijl en op rollen gebaseerde gebruikersinterfaces.
• Waardelijsten (statisch, hiërarchisch of vanuit een veld/array) sturen vervolgkeuzelijsten, keuzelijsten met invoervak ​​en pop-upmenu’s aan; het binden ervan aan een veld is een wijziging van de eigenschap van één regel.
• Subformulieren sluiten het ene formulier in het andere in en zijn de standaardmanier om hoofd-detail lay-outs te maken zonder widgets te dupliceren.
• Prestaties op lijstformulieren zijn sterk afhankelijk van entiteitsselectie vs. klassieke selectie en of lui laden is ingeschakeld voor grote recordsets.

Wat “4D-formulieren” eigenlijk betekent

4D-formulieren zijn declaratieve gebruikersinterfacedefinities die zijn opgeslagen in de structuur (tabelformulieren) of als op zichzelf staande projectbestanden (projectformulieren). Een formulier bevat objecten (invoervelden, knoppen, keuzelijsten, subformulieren, webgebieden en statische tekst) gerangschikt op een canvas met een gedefinieerd paginaformaat en, optioneel, meerdere pagina’s. Elk object heeft eigenschappen (gegevensbron, invoerbare status, lettertype, coördinaten) die 4D tijdens runtime evalueert.

Het onderscheid dat er het meest toe doet bij een vergelijking: een formulier is geen venster. Een formulier is een lay-out; een venster is de container die 4D opent om het weer te geven. Hetzelfde formulier kan verschijnen in een modaal dialoogvenster, een paletvenster, een aanpasbaar documentvenster of ingesloten als een subformulier. Door deze scheiding te begrijpen, kunnen ervaren ontwikkelaars één formulier in meerdere contexten hergebruiken in plaats van het opnieuw op te bouwen.

De drie formuliertypen vergeleken

Formuliertype	Getoonde records	Typisch gebruik	Belangrijk voorbehoud
Detailformulier	Eén	Gegevensinvoer, recordbewerking, dialogen	Heeft expliciete navigatie nodig (knoppen, NEXT RECORD)
Lijstformulier	Veel	Bladeren, selecteren, dashboards	Grote selecties vereisen lui laden of paging
Uitvoerformulier	Veel	Afdrukken, PDF-export, rapporten	Niet interactief; lay-out is printgericht

Detailformulieren zijn het werkpaard van gegevensinvoer. Ze geven de huidige record van een tabel weer en stellen gebruikers in staat velden rechtstreeks te bewerken. Een detailformulier is ook de logische keuze voor een instellingendialoog of inlogscherm, omdat u het helemaal niet aan een tabel kunt koppelen en alleen met procesvariabelen kunt aansturen.

Lijstformulieren presenteren een schuifbaar raster met records. In moderne 4D zijn lijstformulieren doorgaans opgebouwd rond een keuzelijst-object in plaats van de oude “lijstformulier met kolommen”-benadering. Keuzelijsten kunnen op arrays of op selecties zijn gebaseerd, en op selecties gebaseerde keuzelijsten zijn rechtstreeks gebonden aan een entiteitsselectie - wat het voorkeursmodel is bij het werken met ORDA.

Uitvoerformulieren bestaan ​​om af te drukken. Ze geven records weer in een paginalay-out met kop-, voetteksten en onderverdelingsniveaus. Uitvoerformulieren zijn niet bedoeld voor interactie op het scherm en met 4D kunnen gebruikers niet in velden bladeren zoals ze dat op een detailformulier zouden doen.

Gerelateerd: Airtable — Een spreadsheet-eenvoudige interface bovenop een echte relationele database, met automatiseringen, weergaven en deelbare interfaces..

Dit zijn de drie primaire 4D-formulieren.

Projectformulieren versus tabelformulieren

Projectformulieren worden opgeslagen als individuele “.4DForm”-bestanden in de map “Forms” van het project en zijn voorzien van versiebeheer: elk formulier is een afzonderlijk JSON-document, dus twee ontwikkelaars die verschillende formulieren bewerken, komen zelden met elkaar in botsing tijdens een samenvoeging. Tabelformulieren bevinden zich in het structuurbestand en worden bewerkt via dezelfde formuliereditor, maar zijn conceptueel gekoppeld aan een enkele tabel.

De praktische tips voor 2026: Begin elk nieuw formulier als een projectformulier. Tabelformulieren blijven volledig ondersteund en kom je tegen in oudere databases, maar projectformulieren geven je duidelijkere verschillen, makkelijker hergebruik tussen tabellen en een duidelijker mentaal model. Het converteren van een tabelformulier naar een projectformulier houdt in dat u het uit de formulierlijst van de tabel verplaatst naar de formulierlijst van het project; objectdefinities blijven behouden.

Als u aan het winkelen bent: Zoho Creator — Een low-code app-bouwer die aansluit op de bredere Zoho-suite en prijzen per gebruiker in plaats van per app..

Een formulier bouwen: de kernstappen

1. Maak het formulier in de formuliereditor (Verkenner → Formulieren → Nieuw), waarbij u detail, lijst of uitvoer kiest.
2. Stel het paginaformaat in en voeg indien nodig pagina’s toe voor lay-outs met meerdere stappen.
3. Objecten plaatsen: Sleep velden van Verkenner naar het canvas of voeg knoppen, keuzelijsten en subformulieren toe vanuit de Objectbibliotheek.
4. Gegevensbronnen koppelen: wijs elk invoerobject toe aan een veld, variabele of expressie.
5. Configureer waardelijsten voor elke vervolgkeuzelijst, keuzelijst met invoervak ​​of pop-upmenu.
6. Events koppelen — voeg methoden toe om methoden te koppelen aan formuliergebeurtenissen (On Load, On Clicked, On Data Change) en objectgebeurtenissen.
7. Test in de formuliereditor met behulp van het ingebouwde voorbeeld en vervolgens in een actief venster.

Stap 6 is waar het meeste echte werk gebeurt bij het maken van 4D-formulieren. Een formulier zonder gebeurtenismethoden is een statisch beeld; de formuliergebeurtenis ‘On Load’ is doorgaans de plek waar u arrays invult, een lijst met waarden laadt of invoerbare statussen instelt op basis van de rol van de huidige gebruiker.

Waardelijsten: de details waar mensen over struikelen

Waardelijsten zijn het mechanisme achter elke vervolgkeuzelijst, keuzelijst met invoervak en pop-upmenu in 4D-formulieren. Er zijn drie soorten:

• Statische lijsten — u voert waarden één keer in de lijsteditor in. Ideaal voor vaste opsommingen zoals statuscodes.
• Hierarchische lijsten — ondersteunt geneste elementen met een | scheidingsconventie, handig voor categoriebomen.
• Dynamische lijsten — tijdens runtime gevuld vanuit een veld, een array of een formule. Deze weerspiegelen live gegevens, zodat een lijst met actieve klanten up-to-date blijft zonder herimplementatie.

Een veel voorkomende valkuil: een lijst met dynamische waarden koppelen aan een veld waarin een referentie (een ID) is opgeslagen terwijl een label wordt weergegeven. 4D beheert dit met het concept van “geassocieerde waarde”: de lijst slaat de ene waarde op en geeft de andere weer. Het correct instellen hiervan is het verschil tussen een vervolgkeuzelijst waarin ‘42’ wordt vermeld en een vervolgkeuzelijst waarin ‘Acme Corp.’ wordt vermeld.

Subformulieren en hoofddetaillay-outs

Subformulieren integreren het ene formulier in het andere. Het bovenliggende formulier host een subformulierobject; het kindformulier wordt binnenin weergegeven. Gegevens stromen door de eigenschap “table” van het subformulier en, in moderne 4D, door het object Form dat aan het kind wordt doorgegeven.

Het hoofddetail is het canonieke gebruik voor 4D-formulieren: een detailformulier voor een factuur bovenaan, een lijstformulier voor factuurregels in een subformulier eronder. Wanneer het bovenliggende record verandert, wordt de subformulierselectie bijgewerkt, op voorwaarde dat u deze bijwerkt in ‘On Data Change’ van het bovenliggende record of door de selectie opnieuw te binden. Met subformulieren kunt u ook herbruikbare componenten maken: een ‘klantkiezer’-formulier kan in elke ouder worden neergezet die het nodig heeft.

Dynamische formulieren en runtime-UI

Dynamische 4D-formulieren wijzigen de interface terwijl de applicatie actief is. De belangrijkste commando’s zijn DIALOG (een formulier openen als een modaal of niet-modaal dialoogvenster), FORM LOAD (een formulier in het geheugen laden zonder het weer te geven), FORM GOTO PAGE (pagina’s wijzigen) en OBJECT SET... die de eigenschappen van het object direct wijzigen.

Gerelateerd: Knack — Een databasebouwer zonder code, gericht op portals, directory's en interne tools, met vaste prijzen in plaats van kosten per gebruiker..

Dynamische formulieren zijn belangrijk voor twee scenario’s. Ten eerste Wizard Flows: een enkel formulier met meerdere pagina’s, doorgestuurd via FORM GOTO PAGE terwijl de gebruiker de stappen voltooit. Ten tweede, op rollen gebaseerde interfaces — verberg of schakel objecten uit bij On Load op basis van gebruikersrechten, zodat een formulier zowel voor een beheerder als voor een alleen-lezen-viewer geschikt is. De wisselwerking is complexiteit: dynamisch gedrag is moeilijker te debuggen dan een statische lay-out, dus reserveer dit voor gevallen waarin een tweede formulier anders nodig zou zijn.

Prestatieoverwegingen

De prestaties van 4D-lijstformulieren worden gedomineerd door het aantal records dat 4D moet materialiseren. Een op selecties gebaseerde keuzelijst die aan een entiteitsselectie is gekoppeld, laadt alleen de rijen die worden weergegeven, waardoor het geheugen leeg blijft naarmate de tabel groeit. Klassieke array-gebaseerde keuzelijsten laden alles van tevoren en zullen merkbaar vertragen op grote tabellen.

Twee andere hefbomen: lui laden van keuzelijsten (rijen ophalen tijdens het scrollen) en server-side queries die een begrensde selectie retourneren in plaats van de hele tabel. Voor client-server-implementaties vallen de retourkosten voor het ophalen van records via het netwerk doorgaans in de schaduw van de weergavetijd, dus het beperken van de selectie is de optimalisatie met de hoogste waarde.

Onze keuze: Claris FileMaker Pro — Het langlopende relationele databaseplatform voor teams die aangepaste apps nodig hebben op desktop, internet en mobiel vanuit één bestand..

Hoe te beslissen

• Gegevensinvoer voor één record? Gedetailleerd formulier.
• Bladeren of selecteren uit vele records? Lijstformulier met een keuzelijst op basis van selectie.
• Afdrukken of PDF-uitvoer? Uitvoerformulier.
• Herbruikbaar op meerdere tabellen? Projectvorm, geen tafelvorm.
• Proces in meerdere stappen? Een formulier met meerdere pagina’s, dynamisch geavanceerd.
• Hoofd-detailrelatie? Detailformulier met een subformulier voor een lijstformulier.
• Vaste keuzeset? Lijst met statische waarden. Live gegevens? Dynamische zoeklijst.

Deze opties helpen u bij het kiezen van de juiste 4D-formulieren voor uw behoeften.

Leermiddelen

De officiële 4D-documentatie is de gezaghebbende referentie voor 4D-formulieren, objecten, gebeurtenissen en opdrachten. Begin daar om de exacte eigenschapsnamen en opdrachthandtekeningen te achterhalen. Als achtergrondinformatie over de onderliggende databaseconcepten geeft het Wikipedia-artikel over 4D (software) een nuttige geschiedenis van het platform. De JSON formaatpagina is de moeite waard om te lezen als u van plan bent de .4DForm-bestanden met de hand te bewerken of ze te vergelijken in versiebeheer. Voor algemene relationele ontwerpprincipes die aangeven hoe u de tabellen achter uw formulieren structureert, bekijkt u het overzicht van databasenormalisatie.

Veelgestelde vragen

Wat is een 4D-formulier?

Een 4D-formulier is een declaratieve gebruikersinterfacepresentatie die is samengesteld uit objecten (invoervelden, knoppen, keuzelijsten, subformulieren) die zijn gekoppeld aan gegevensbronnen. 4D evalueert de eigenschappen van het formulier tijdens runtime en geeft het weer in een venster, een dialoogvenster of als een ingebed subformulier. Er zijn drie soorten formulieren: detail, lijst en uitvoer.

Wat is het verschil tussen een detailformulier en een lijstformulier in 4D?

Een detailformulier geeft één record tegelijk weer en wordt gebruikt voor gegevensinvoer en -bewerking. Een lijstformulier geeft veel records weer, meestal in een keuzelijst, en wordt gebruikt voor bladeren en selecteren. De twee worden vaak gecombineerd: een lijstformulier om een ​​record te kiezen en vervolgens een detailformulier om het te bewerken.

Moet ik projectformulieren of tabelformulieren gebruiken?

Projectformulieren zijn standaard de moderne standaard en worden opgeslagen als afzonderlijke “.4DForm”-bestanden, waardoor ze gemakkelijker te hergebruiken en te beheren zijn in versiebeheer. Tabelformulieren zijn verouderd en gekoppeld aan één tabel. Bij nieuwe ontwikkelingen moeten projectvormen worden gebruikt; tabelformulieren blijven ondersteund voor bestaande databases.

Hoe werken waardenlijsten in 4D-formulieren?

Invoerlijsten vullen vervolgkeuzelijsten, keuzelijsten met invoervak ​​en pop-upmenu’s in. Ze kunnen statisch zijn (slechts één keer ingevoerd), hiërarchisch (geneste items) of dynamisch (tijdens runtime gemaakt op basis van een veld, array of formule). Een waardenlijst kan de ene waarde opslaan terwijl een andere wordt weergegeven. Zo geeft u de naam van een klant weer terwijl u zijn of haar ID opslaat.

Kan ik een 4D-formulier tijdens runtime wijzigen?

Ja. Dynamische formulieren gebruiken opdrachten zoals DIALOG, FORM LOAD en FORM GOTO PAGE om formulieren te laden, van pagina te wisselen en objecteigenschappen te wijzigen terwijl de toepassing actief is. Dit ondersteunt stromen in wizard-stijl en op rollen gebaseerde interfaces waarbij één formulier verschillende gebruikers bedient.

Waarom is mijn 4D-lijstformulier traag bij grote tabellen?

De traagheid van de lijstvorm wordt doorgaans veroorzaakt doordat er te veel records worden gematerialiseerd. Op selecties gebaseerde keuzelijsten die zijn gekoppeld aan entiteitsselecties laden alleen de weergegeven rijen, terwijl op arrays gebaseerde keuzelijsten alles laden. Het inschakelen van lazyloading en het beperken van de query tot een begrensde selectie zijn de twee oplossingen met de grootste impact.