Definitie:

* De meeste talen: Tekenreeksen worden doorgaans gedefinieerd door tekens tussen aanhalingstekens te plaatsen (enkele `'` of dubbele `'` – de keuze hangt vaak af van de taal of specifieke context). Bijvoorbeeld:

* `myString ="Hallo wereld!"` (Python, JavaScript, vele anderen)

* `myString :='Hallo wereld!'` (Pascal, Go)

* `String myString ="Hallo wereld!";` (C#, Java)

* Speciale gevallen: Sommige talen hebben mogelijk alternatieve manieren om tekenreeksen te definiëren, zoals het gebruik van tekenreeksliterals (vooraf gedefinieerde constanten) of het gebruik van speciale constructors voor het maken van tekenreeksen op basis van andere gegevenstypen (zoals tekenarrays).

Manipulatie:

Stringmanipulatie omvat een breed scala aan bewerkingen. Veel voorkomende zijn onder meer:

* Aaneenschakeling: Het samenvoegen van twee of meer snaren.

* Python:`gecombineerd =string1 + string2`

* JavaScript:`gecombineerd =string1 + string2`

* C#:`gecombineerd =string1 + string2;`

* Veel talen bieden ook speciale functies zoals `strcat` (C) of `join` (Python, JavaScript) voor een efficiëntere aaneenschakeling van meerdere strings.

* Subtekenreeksen (slicen/extractie): Een gedeelte van een string extraheren.

* Python:`substring =string[start:end]` (exclusief `end`)

* JavaScript:`substring =string.substring(start, end)` (exclusief `end`)

* C#:`substring =string.Substring(start, lengte)`

* Veel talen bieden ook functies voor het vinden van substrings op basis van patronen (reguliere expressies).

* Lengte: Het aantal tekens in een string bepalen.

* Python:`lengte =len(string)`

* JavaScript:`lengte =string.lengte`

* C#:`lengte =tekenreeks.Lengte`

* Caseconversie: De hoofdletters van tekens wijzigen (hoofdletters naar kleine letters en omgekeerd).

* Python:`kleine letters =string.lower(); hoofdletter =string.upper()`

* JavaScript:`kleine letters =string.toLowerCase(); hoofdletter =string.toUpperCase()`

* C#:`kleine letters =string.ToLower(); hoofdletter =string.ToUpper();`

* Zoeken: Specifieke tekens of subtekenreeksen binnen een tekenreeks zoeken.

* Python:`index =string.find("substring")` (retourneert index, -1 indien niet gevonden)

* JavaScript:`index =string.indexOf("substring")` (retourneert index, -1 indien niet gevonden)

* C#:`index =string.IndexOf("substring")` (retourneert index, -1 indien niet gevonden)

* Vervanging van: Het vervangen van delen van een string door andere strings.

* Python:`newString =string.replace("oud", "nieuw")`

* JavaScript:`newString =string.replace("old", "new")` (vervangt alleen de eerste keer; gebruik regex voor complexere vervangingen)

* C#:`newString =string.Replace("oud", "nieuw");`

* Bijsnijden: Voorloop- en volgspatietekens verwijderen.

* Python:`getrimd =string.strip()`

* JavaScript:`getrimd =string.trim()`

* C#:`getrimd =string.Trim();`

* Splitsen: Een tekenreeks in kleinere reeksen verdelen op basis van een scheidingsteken (bijvoorbeeld een zin in woorden splitsen).

* Python:`woorden =string.split(" ")`

* JavaScript:`woorden =string.split(" ")`

* C#:`woorden =string.Split(' ');`

Onveranderlijkheid:

Veel programmeertalen behandelen strings als *onveranderlijke* gegevenstypen. Dit betekent dat bewerkingen die een tekenreeks lijken te wijzigen, feitelijk een *nieuwe* tekenreeks met de wijzigingen creëren, waarbij de oorspronkelijke tekenreeks ongewijzigd blijft. In Python wijzigt `string.upper()` bijvoorbeeld `string` niet op zijn plaats; het retourneert een nieuwe tekenreeks in hoofdletters. Talen als Python en JavaScript hebben methoden die zijn ontworpen om met veranderlijke lijsten met tekens te werken als je meer flexibiliteit wilt.

Dit zijn enkele van de fundamentele aspecten van het definiëren en manipuleren van reeksscalaire waarden. De specifieke beschikbare functies en methoden zijn sterk afhankelijk van de gekozen programmeertaal. Vergeet niet de documentatie van uw taal te raadplegen voor gedetailleerde informatie en geavanceerde technieken.