Tekstcase converteren _

Wat is tekstcase-conversie?

Tekstcase-conversie neemt een invoerstring en stuurt dezelfde woorden uit in een andere letter-hoofdletterconventie. De meest voorkomende doelen zijn camelCase en PascalCase (gebruikt voor identifiers in de meeste talen met accolades), snake_case en CONSTANT_CASE (Python, Ruby, Rust, C-macro's), kebab-case (URL's, CSS-klassenamen, HTML-attributen, npm-pakketnamen), dot.case (configuratiesleutels, JavaScript-objectpaden), path/case (identifiers in bestandssysteemstijl), Title Case en Sentence case (koppen en proza), plus volledige lower case en UPPER CASE. Deze converter detecteert de natuurlijke woordgrenzen in je invoer — witruimte, koppeltekens, underscores, punten, schuine strepen en de lowercase→uppercase-overgangen die helloWorld-stijl identifiers markeren — en stelt ze opnieuw samen met het scheidingsteken en hoofdletterpatroon dat elk doelcase vereist.

Hoe werkt case-conversie?

Je invoer wordt volledig in je browser verwerkt met een kleine vanilla-JavaScript-tokenizer en elf case-formatters. De stappen op hoog niveau zijn:

1. Je invoer wordt letterlijk uit het tekstveld gelezen — elke byte die je hebt geplakt wordt lokaal in het geheugen bewaard.
2. Een tokenizer splitst de invoer op witruimte, underscores, koppeltekens, punten en schuine strepen, en splitst elk fragment vervolgens nog eens op lowercase→uppercase-grenzen (zodat helloWorld ["hello", "World"] wordt) en op letter↔cijfer-grenzen (zodat v2API ["v", "2", "API"] wordt).
3. Lege tokens worden uitgefilterd en de overgebleven tokens worden naar kleine letters omgezet met String.prototype.toLocaleLowerCase, zodat Unicode-letters in Turks, Duits en andere locales correct behouden blijven.
4. Elf formatters stellen de tokens vervolgens om de beurt samen in elk doelcase — camelCase, PascalCase, snake_case, CONSTANT_CASE, kebab-case, dot.case, path/case, Title Case (met een lijst van kleine woorden zodat and, the, of enz. in kleine letters blijven behalve als eerste of laatste woord), Sentence case, volledige lower case en volledige UPPER CASE.
5. De uitvoer wordt naar één rij per case in het resultatenraster geschreven; elke rij heeft een eigen kopieerknop die de asynchrone Clipboard-API gebruikt met een synchrone document.execCommand('copy')-fallback voor oudere browsers.

Waarom een hoofdletter-converter gebruiken?

• Identifiers refactoren: hernoem een JavaScript-variabele van user_id naar userId, een Python-functie van helloWorld naar hello_world, of een Rust-constante van maxBuffer naar MAX_BUFFER zonder handmatig teken-per-teken te bewerken.
• Configuratiesleutels converteren: zet een JSON-config vol camelCase-sleutels in één plakbeurt om naar snake_case YAML voor een Python-service, of naar kebab-case voor een Helm chart.
• Koppen schrijven: plak een conceptkop en lees de Title Case-vorm (met de uitzonderingen voor kleine woorden van de Chicago Manual of Style) terug naast de Sentence case-vorm (AP Stylebook) — kies welke je publicatie gebruikt.
• URL-slugs genereren: plak een blogposttitel en kopieer de kebab-case-vorm direct in het slug-veld van je CMS — de tokenizer verwerkt interpunctie en frases van meerdere woorden zonder overgebleven scheidingstekens.

Wat zijn veelvoorkomende toepassingen van case-conversie?

Schakelen tussen letter-hoofdletterconventies komt voor in software-engineering, content-auteurschap en data-engineering:

• Code refactoring: identifiers in een codebase hernoemen wanneer een stijlgids verandert (bijv. JavaScript camelCase → Python snake_case tijdens een backend-herschrijving) zonder typfouten te introduceren.
• API-payload-hervorming: converteer camelCase JSON-sleutels naar snake_case voordat je ze aan een Ruby on Rails- of Django-backend doorgeeft, of naar kebab-case voor een CSS-in-JS-klassenaam.
• Kop- en slug-auteurschap: produceer Title Case-paginatitels, Sentence case-meta-beschrijvingen en kebab-case-URL-slugs uit dezelfde bronkop in één stap.

Hoe ziet een voorbeeld van case-conversie eruit?

Plak Hello World API in de invoer. Het resultatenraster rendert elf rijen tegelijkertijd: helloWorldApi (camelCase), HelloWorldApi (PascalCase), hello_world_api (snake_case), HELLO_WORLD_API (CONSTANT_CASE), hello-world-api (kebab-case), hello.world.api (dot.case), hello/world/api (path/case), Hello World Api (Title Case), Hello world api (Sentence case), hello world api (lower case) en HELLO WORLD API (UPPER CASE). Dezelfde invoer geplakt als helloWorldAPI tokenizeert tot dezelfde drie woorden — de lowercase→uppercase-grensdetector verwerkt die vorm ook.

Draait dit in mijn browser?

Ja. De tokenizer en de elf case-formatters zijn ongeveer 120 regels vanilla JavaScript die in het browsertabblad draaien. Er wordt niets geüpload, geen service worker proxieert je invoer, en de pagina doet nul netwerkverzoeken voor de conversiestap zelf. Het enige uitgaande verkeer bestaat uit de standaard pagina-laadassets (CSS, fonts, analytics) — je tekst bereikt Ultim8Soft nooit.

Welk case-formaat moet ik gebruiken voor variabelenamen?

Het hangt af van de taal en de stijlgids van het team. JavaScript- en TypeScript-codebases gebruiken overwegend camelCase voor variabelen en functies, PascalCase voor klassen en React-componenten, en CONSTANT_CASE voor omgevingsvariabelenamen en module-niveau constanten — de Google JavaScript-stijlgids en de Airbnb-stijlgids zetten beide deze keuzes vast. Python (PEP 8), Ruby en Rust geven de voorkeur aan snake_case voor variabelen en functies, PascalCase voor klassen, en CONSTANT_CASE voor module-niveau constanten. C- en C++-codebases (Linux-kernel, LLVM) leunen op snake_case voor functies en CONSTANT_CASE voor preprocessor-macro's. Bij twijfel: voer de linter of formatter van je team uit — die vertelt je welke conventie wordt afgedwongen.

Hoe wordt de invoer getokeniseerd?

De tokenizer splitst de invoer eerst op elke reeks witruimte, underscore (_), koppelteken (-), punt (.) of schuine streep (/). Elk resulterend fragment wordt vervolgens opnieuw gesplitst op lowercase→uppercase-grenzen (zodat helloWorld ["hello", "World"] wordt) en op letter↔cijfer-grenzen (zodat v2API ["v", "2", "API"] wordt). Lege tokens worden uitgefilterd en de overgebleven tokens worden naar kleine letters omgezet via String.prototype.toLocaleLowerCase. De formatters herkapitaliseren en hervoegen de tokens vervolgens samen met het scheidingsteken dat elk doelcase vereist. De strategie behandelt alle zes veelvoorkomende identifier-vormen — camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE en gewone door spaties gescheiden proza — out of the box.

Hoe zit het met Unicode / niet-ASCII-tekens?

Unicode-letters overleven de heen-en-terugreis. De tokenizer gebruikt String.prototype.toLocaleLowerCase en toLocaleUpperCase, die locale-specifieke hoofdletterregels respecteren — Turkse i met en zonder punt, Duitse ß die in hoofdletter naar SS wordt, accentueerde Latijnse letters in Frans en Spaans, enzovoort. Niet-letterkarakters die NIET in de scheidingsset zitten (witruimte, _, -, ., /) — bijvoorbeeld cijfers, accentueerde letters of CJK-karakters — worden binnen het token bewaard waarin ze verschijnen, en de case-formatters geven ze letterlijk weer. Dit betekent dat een invoer zoals nœud_principal tokenizeert tot ["nœud", "principal"] en netjes converteert naar nœudPrincipal (camelCase) of NœudPrincipal (PascalCase).

Deze hoofdletter-converter is een enkele statische pagina die de tokenizer en de elf formatters volledig in je browser draait — geen vendor-bibliotheek, geen netwerkaanroep per conversie, geen account. Plak hierboven willekeurige tekst, scan de elf case-uitvoeringen naast elkaar en kopieer degene die je nodig hebt.