String Manipulation Grade 10

Strings are sequences of characters. Delphi provides built-in functions and procedures to analyse, extract, and modify strings.

What is String Manipulation?

String manipulation is the process of working with text inside a program — searching it, pulling pieces out of it, changing it and measuring it. A string is simply a piece of text: a name, an ID number, an email address or a whole sentence are all strings.

Everyday analogy: Think of a string like a row of bead letters on a piece of string, exactly like a beaded keyring that spells a name. Each bead is one character and it sits in a fixed position. String manipulation is what you do when you slide beads off the end, count how many there are, swap a small to a capital bead, or read which bead is sitting in position 3.

Note: In Delphi, the very first character of a string sits at position 1 (not 0). This is why the reference string below numbers its letters starting at 1.

Quick Reference

Group 1 — Searching a String

Searching means asking "is this smaller piece of text in there, and if so, where?" The answer you get back is a position number. This is the first thing you do before you can extract or change part of a string, because you usually need to know where something is first.

Everyday analogy: It is like using Find (Ctrl+F) in a document. You type a word, and the computer jumps to the spot where it appears and tells you where it is. Pos is Delphi's version of that "Find".

Pos — Find Position

Returns the integer position of the first occurrence of a substring. Returns 0 if not found.

IntegerVariable := Pos(StrToBeFound, SourceText);

iX := Pos('e', sSourceText);    // = 5  (first 'e' in 'Andre')
iX := Pos('is', sSourceText);   // = 7
iX := Pos('xyz', sSourceText);  // = 0  (not found)

Index [ ] — Character at Position

Access a single character using square brackets and a position number.

StringVariable := SourceText[CharacterPosition];

sNewText := sSourceText[2];   // = 'n'
sNewText := sSourceText[5];   // = 'e'

Group 2 — Extracting Part of a String

Extracting means taking a copy of a piece of the string without changing the original. You decide where to start and how many characters to grab. This is how you pull a first name out of a full name, a year out of a date, or an area code out of a phone number.

Everyday analogy: Think of cutting a slice out of a loaf of bread. The loaf (the original string) stays whole; you just take a slice from a chosen spot of a chosen thickness. Copy takes the slice, and Index [ ] takes a single thin slice — just one character.

Copy — Extract Substring

Extracts a section of text starting at a position for a given number of characters.

StringVariable := Copy(SourceText, BeginPosition, Length);

sNewText := Copy(sSourceText, 10, 4);  // = 'cute'  (start at 10, take 4)
sNewText := Copy(sSourceText, 1, 5);  // = 'Andre' (start at 1, take 5)

Group 3 — Changing a String

Changing a string means actually modifying it — adding text in, taking text out, or measuring it. Unlike extracting, these Insert and Delete procedures change the original string directly, so afterwards the string is different from before.

Everyday analogy: This is like editing a sentence in your exercise book. Insert squeezes a new word into the middle of the sentence; Delete rubs a few words out. Length is just counting how many letters the sentence now has.

Insert — Add Text

Inserts text into an existing string at a given position. Modifies the string directly.

Insert(InsertText, SourceText, Position);

Insert('very ', sSourceText, 10);
// sSourceText is now: 'Andre is very cute'

Delete — Remove Text

Removes a section of text from a string. Modifies the string directly.

Delete(SourceText, Position, Length);

Delete(sSourceText, 9, 5);
// sSourceText is now: 'Andre is' (removed ' cute')

Length — String Length

IntegerVariable := Length(SourceText);

iX := Length(sSourceText);   // = 13 (length of 'Andre is cute')
iX := Length('Hello');       // = 5

Group 4 — Changing Case

Changing case means turning all the letters into capitals (UpperCase) or all into small letters (LowerCase). The most important reason we do this is to compare text fairly. The computer thinks 'YES', 'yes' and 'Yes' are three different strings, so if you force them all to lowercase first, they all match.

Everyday analogy: Imagine a teacher marking a one-word answer. Whether a learner wrote "Cape Town", "CAPE TOWN" or "cape town", it is the same correct answer. Lowercasing both the answer and the memo before comparing is how you make sure capitals do not unfairly mark someone wrong.

Important Rule: UpperCase and LowerCase return a new string — they do not change the original unless you store the result back into a variable.

UpperCase and LowerCase

sResult := UpperCase(sSourceText);
// 'Andre is cute' → 'ANDRE IS CUTE'

sResult := LowerCase(sSourceText);
// 'Andre is cute' → 'andre is cute'

Practical Patterns

Reverse a String

var
  sInput, sReverse: string;
  i: Integer;
begin
  sInput   := edtInput.Text;
  sReverse := '';
  for i := Length(sInput) downto 1 do
    sReverse := sReverse + sInput[i];
  lblResult.Caption := sReverse;
end;

Count Occurrences of a Character

var
  sText: string;
  i, iCount: Integer;
begin
  sText  := LowerCase(edtInput.Text);
  iCount := 0;
  for i := 1 to Length(sText) do
    if sText[i] IN ['a','e','i','o','u'] then
      Inc(iCount);
  lblResult.Caption := 'Vowels: ' + IntToStr(iCount);
end;

Extract First Name from "Surname, Name"

var
  sFullName, sName, sSurname: string;
  iCommaPos: Integer;
begin
  sFullName  := edtInput.Text;           // e.g. 'Smith, John'
  iCommaPos  := Pos(',', sFullName);
  sSurname   := Copy(sFullName, 1, iCommaPos - 1);
  sName      := Copy(sFullName, iCommaPos + 2, Length(sFullName));
  lblOut.Caption := 'Name: ' + sName + '  Surname: ' + sSurname;
end;