String in TypeScript

In TypeScript, strings are used to represent text data. They are a primitive data type and can be created using single quotes (‘), double quotes (“), or backticks (`).

Rules and Steps to define String

To define a string in TypeScript, you need to follow these rules and steps:

• Use the string keyword to define a variable or parameter as a string.
• Use single quotes (‘ ‘) or double quotes (” “) to enclose the string value.
• Use backticks ( ) to define a template string containing expressions and multiple lines.
• String values can be concatenated using the + operator or template strings.
• Use string methods to manipulate and work with string values.

Following these rules and steps, you can define and manipulate string values in TypeScript.

Declaring strings in TypeScript

In TypeScript, you can declare a string using the string keyword. For example:

let DataFlair_myString: string = 'Hello World';

In this example, we declare a string variable named DataFlair_myString and assign it the value “Hello, TypeScript!”. TypeScript is informed by the string keyword that this variable should only ever store string values.

TypeScript also supports template strings, which allow you to interpolate values directly into a string. To declare a template string, use the backtick (`) character instead of quotes. For example:

let DataFlair_myName: string = 'Alice';
let DataFlair_myTemplateString: string = `Hello, ${DataFlair_myName}`;

In this example, we declare a variable named DataFlair_myName with a value of “Alice”. It is a template string named DataFlair_myTemplateString that includes the value of DataFlair_myName. When you run this code, DataFlair_myTemplateString will be “Hello, Alice!”.

Working with strings in TypeScript

Once you have declared a string variable in TypeScript, you can work with it in various ways. For example, you can use string methods like indexOf, substring, and replace to manipulate the string’s contents.

You can also use string concatenation to combine multiple strings into one string. In TypeScript, you can concatenate strings using the + operator or template strings. For example:

let DataFlair_firstName: string = 'Alice';
let DataFlair_lastName: string = 'Smith';
let DataFlair_fullName: string = DataFlair_firstName + ' ' + DataFlair_lastName;
let DataFlair_templateFullName: string = `${DataFlair_firstName} ${DataFlair_lastName}`;

In this example, we declare two string variables named DataFlair_firstName and DataFlair_lastName, and use concatenation to create a DataFlair_fullName variable that holds the value “Alice Smith”. We also use a template string to create a DataFlair_templateFullName variable with the same value.

TypeScript also provides additional features for working with strings, such as string literals and string enums.

String literals allow you to define a set of strings that can be used as values for a variable. For example:

let DataFlair_color = 'red' | 'green' | 'blue';
let DataFlair_myColor = 'red';

In this example, we define a DataFlair_Color type that can only be one of three string literals: “red,” “green,” or “blue.” We then declare a variable named DataFlair_myColor and assign it the value “red.” If you try to assign a value that is not one of the defined string literals, TypeScript will give you an error.

String enums are similar to string literals but allow you to assign a numeric value to each string. For example:

enum DataFlair_direction = {
   Up = 'UP',
   Down = 'DOWN',
   Left = 'LEFT',
   Right = 'RIGHT'
}


let DataFlair_myDirection = DataFlair_direction.Up;

In this example, we define a DataFlair_Direction enum with four values; each assigned a string value. We then declare a variable named myDirection and assign it the DataFlair_Direction.Up. The value of DataFlair_myDirection will be the string “UP”, but you can also use the numeric values of the enum (0, 1, 2, and 3).

Using strings in functions and classes

Strings can also be used as function parameters, return types, class properties, and method parameters. Here’s an example of a function that takes a string parameter and returns a string:

function DataFlair_addHello(name: string): string {
 return 'Hello ' + name;
}

In this example, we define a function named DataFlair_addHello that takes a string parameter named name. The function uses a template string to concatenate “Hello, ” and name, and returns the resulting string.

Strings can also be used as properties and method parameters in classes. For example:

class DataFlair_Person {
 firstName: string;
 lastName: string;
 constructor(firstName: string, lastName: string) {
   this.firstName = firstName;
   this.lastName = lastName;
 }
 getFullName() {
   return this.firstName + ' ' + this.lastName;
 }
}


let DataFlair_myPerson: DataFlair_Person = new DataFlair_Person(
 'DataFlair',
 'Person'
);
console.log(DataFlair_myPerson.getFullName());

Output–

This example defines a DataFlair_Person class with firstName and lastName string properties. The class also has a constructor that assigns two string parameters to the properties. Finally, the class has a getFullName method that returns a string using a template string to concatenate the two properties.

We then declare a variable named DataFlair_myPerson that creates a new DataFlair_Person object with a first name of “Alice” and a last name of “Jones”. We call the getFullName method on the DataFlair_myPerson object and log the resulting string to the console.

Single and Double Quote

In TypeScript, strings can be created using either single quotes (‘) or double quotes (“). Both types of quotes can be used interchangeably, and there is no functional difference between them.

For example:

const DataFlair_str1 = 'Hello, world!';
const DataFlair_str2 = 'Hello, world!';


console.log(DataFlair_str1 === DataFlair_str2); // true

Output–

It’s important to note that when using quotes inside a string, the opposite type of quote must be used to enclose the string. For example:

const DataFlair_str = "She said, 'Hello, world!'";

console.log(DataFlair_str); // "She said, 'Hello, world!'"

Output-

Alternatively, backticks (`) can be used to create template literals, which allow for the insertion of variables and expressions directly into a string using ${}. For example:

const DataFlair_name = 'John';
const age = 30;

const message = `My name is ${DataFlair_name} and I am ${age} years old.`;

console.log(message); // "My name is John and I am 30 years old."

Output–

Template literals can also span multiple lines without the need for escape characters or concatenation.

Multiline String

In TypeScript, a multiline string is a string that spans multiple lines and can contain line breaks, tabs, and other special characters without requiring escape sequences.

Multiline strings are denoted by enclosing them in backticks ( ) instead of single quotes (‘ ‘) or double quotes (” “).

For example:

const DataFlair_message = `This is a
multiline string
that spans multiple lines.`;

In this example, the backticks allow the string to span multiple lines without using the newline character (“\n”).

Multiline strings can also include expressions using the ${} syntax, allowing for easy interpolation.

For example:

const DataFlair_firstName = 'John';
const DataFlair_lastName = 'Doe';
const fullName = `My name is ${DataFlair_firstName} ${DataFlair_lastName}.`;

In this example, the fullName string includes the values of the DataFlair_firstName and DataFlair_lastName variables using the ${} syntax.

Methods

TypeScript provides several built-in methods for working with strings, such as:

• length: Returns the length of the string.
• charAt(index: number): string: Returns the character at the specified index.
• concat(…strings: string[]): string: Combines two or more strings.
• indexOf(searchValue: string, fromIndex?: number): number: Returns the index of the first occurrence of the specified substring, or -1 if not found.
• lastIndexOf(searchValue: string, fromIndex?: number): number: Returns the index of the last occurrence of the specified substring, or -1 if not found.
• replace(searchValue: string | RegExp, replaceValue: string): string: Replaces the first occurrence of searchValue with replaceValue.
• slice(start?: number, end?: number): string: Extracts a portion of the string.
• split(separator: string | RegExp, limit?: number): string[]: Splits the string into an array of substrings.
• substr(start: number, length?: number): string: Extracts a portion of the string starting at start and optionally extends length characters.
• toLowerCase(): string: Converts the string to lowercase.
• toUpperCase(): string: Converts the string to uppercase.

For example:

const DataFlair_str = 'Hello, world!';


console.log(DataFlair_str.length); // 13
console.log(DataFlair_str.charAt(0)); // "H"
console.log(DataFlair_str.concat(' Welcome')); // "Hello, world! Welcome"
console.log(DataFlair_str.indexOf('world')); // 7
console.log(DataFlair_str.replace('world', 'everyone')); // "Hello, everyone!"
console.log(DataFlair_str.slice(0, 5)); // "Hello"
console.log(DataFlair_str.split(' ')); // ["Hello,", "world!"]
console.log(DataFlair_str.substr(0, 5)); // "Hello"
console.log(DataFlair_str.toLowerCase()); // "hello, world!"
console.log(DataFlair_str.toUpperCase()); // "HELLO, WORLD!"

Output–

These are just a few of the many string methods available in TypeScript. Understanding and utilizing these methods can greatly simplify string manipulation tasks in your code.

Conclusion

Strings are a fundamental part of programming in TypeScript, and understanding how to work with them is essential to building robust and maintainable code. TypeScript provides various tools and features for working with strings, including strong typing, string methods, template strings, string literals, and string enums. By mastering these tools, you can create powerful and expressive code that is easier to read, write, and maintain.