String methods

-

String Methods

JavaScript provides several built-in methods for manipulating strings. These methods allow you to perform various operations on strings, such as extracting substrings, searching for specific characters or patterns, converting case, and more. In this guide, we will explore some of the most commonly used string methods in JavaScript, along with their syntax and examples.

1. length

  • Syntax: string.length
  • Description: 'Length' is not a method but a property in JavaScript. It allows you to retrieve the length of a string, i.e., the number of characters it contains.
  • It is a read-only property, so you cannot modify it.
  • Example:

const text = "Hello, World!";
const length = text.length;
 
console.log(length); // Output: 13

2. charAt(index)

  • Syntax: string.charAt(index)
  • Description: Returns the character at the specified index in the string.
  • Example:

const str = "Hello, World!";
console.log(str.charAt(0)); // Output: "H"
console.log(str.charAt(7)); // Output: "W"

3. charCodeAt(index)

  • Syntax: string.charCodeAt(index)
  • Description: Returns the Unicode value of the character at the specified index in the string.
  • Example:

const str = "Hello";
console.log(str.charCodeAt(0)); // Output: 72
console.log(str.charCodeAt(1)); // Output: 101

4. concat(str1, str2, ..., strN)

  • Syntax: string.concat(str1, str2, ..., strN)
  • Description: Combines the original string with one or more strings passed as arguments and returns a new string.
  • Example:

const str1 = "Hello";
const str2 = "World";
const result = str1.concat(", ", str2, "!");
console.log(result); // Output: "Hello, World!"

5. includes(searchString, position)

  • Syntax: string.includes(searchString, position)
  • Description: Checks if the string contains the specified substring. Optionally, you can pass the starting position for the search.
  • Example:

const str = "Hello, World!";
console.log(str.includes("Hello")); // Output: true
console.log(str.includes("world")); // Output: false (case-sensitive)

6. indexOf(searchValue, fromIndex)

  • Syntax: string.indexOf(searchValue, fromIndex)
  • Description: Returns the index of the first occurrence of the searchValue in the string. Optionally, you can specify a starting index for the search.
  • Example:

const str = "Hello, World!";
console.log(str.indexOf("o")); // Output: 4
console.log(str.indexOf("l", 3)); // Output: 3 (starts searching from index 3)

7. lastIndexOf(searchValue, fromIndex)

  • Syntax: string.lastIndexOf(searchValue, fromIndex)
  • Description: Returns the index of the last occurrence of the searchValue in the string. Optionally, you can specify a starting index for the search.
  • Example:

const str = "Hello, World!";
console.log(str.lastIndexOf("o")); // Output: 8
console.log(str.lastIndexOf("l", 3)); // Output: 2 (starts searching from index 3 backwards)

8. startsWith(searchString, position)

  • Syntax: string.startsWith(searchString, position)
  • Description: Checks if the string starts with the specified substring. Optionally, you can pass the starting position for the check.
  • Example:

const str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true
console.log(str.startsWith("World", 7)); // Output: true (starts checking from index 7)

9. endsWith(searchString, length)

  • Syntax: string.endsWith(searchString, length)
  • Description: Checks if the string ends with the specified substring. Optionally, you can pass the length of the substring to consider for the check.
  • Example:

const str = "Hello, World!";
console.log(str.endsWith("World!")); // Output: true
console.log(str.endsWith("Hello", 7)); // Output: true (considers the first 7 characters)

10. slice(startIndex, endIndex)

  • Syntax: string.slice(startIndex, endIndex)
  • Description: Extracts a portion of the string, starting from the startIndex up to, but not including, the endIndex. Negative indices count from the end of the string.
  • Example:

const str = "Hello, World!";
console.log(str.slice(7)); // Output: "World!"
console.log(str.slice(0, 5)); // Output: "Hello"
console.log(str.slice(-6, -1)); // Output: "World" (extracts from index -6 to -2)

11. substring(startIndex, endIndex)

  • Syntax: string.substring(startIndex, endIndex)
  • Description: Similar to slice(), extracts a portion of the string from startIndex up to, but not including, the endIndex. However, it does not support negative indices.
  • Example:

const str = "Hello, World!";
console.log(str.substring(7)); // Output: "World!"
console.log(str.substring(0, 5)); // Output: "Hello"

12. substr(startIndex, length)

  • Syntax: string.substr(startIndex, length)
  • Description: Extracts a substring from the startIndex of the specified length.
  • Example:

const str = "Hello, World!";
console.log(str.substr(7)); // Output: "World!"
console.log(str.substr(0, 5)); // Output: "Hello"

13. toLowerCase()

  • Syntax: string.toLowerCase()
  • Description: Converts the string to lowercase.
  • Example:

const str = "Hello, World!";
console.log(str.toLowerCase()); // Output: "hello, world!"

14. toUpperCase()

  • Syntax: string.toUpperCase()
  • Description: Converts the string to uppercase.
  • Example:
const str = "Hello, World!";
console.log(str.toUpperCase()); // Output: "HELLO, WORLD!"

15. trim()

  • Syntax: string.trim()
  • Description: Removes leading and trailing whitespaces from the string. But it can not remove the spaces inside a string.
  • Example:

const str = "   Hello, World!    ";
console.log(str.trim()); // Output: "Hello, World!"

16. split(separator, limit)

  • Syntax: string.split(separator, limit)
  • Description: Splits the string into an array of substrings based on the specified separator. Optionally, you can specify a limit for the number of splits.
  • Example:

const str = "apple,banana,orange";
const fruitsArray = str.split(",");
console.log(fruitsArray); // Output: ["apple", "banana", "orange"]
 
const sentence = "JavaScript is awesome and JavaScript is fun.";
const wordsArray = sentence.split(" ", 3);
console.log(wordsArray); // Output: ["JavaScript", "is", "awesome"]

17. replace(searchValue, replaceValue)

  • Syntax: string.replace(searchValue, replaceValue)
  • Description: The `replace` method replaces a specified substring or pattern with another substring.
  • Example:

const text = "Hello, World!";
const newText = text.replace("World", "JavaScript");
 
console.log(newText); // Output: Hello, JavaScript!

Key Takeaways

  1. charAt(index): Returns the character at the specified index in the string.
  2. charCodeAt(index): Returns the Unicode value of the character at the specified index in the string.
  3. concat(str1, str2, ..., strN): Combines the original string with one or more strings passed as arguments and returns a new string.
  4. includes(searchString, position): Checks if the string contains the specified substring. Optionally, you can pass the starting position for the search.
  5. indexOf(searchValue, fromIndex): Returns the index of the first occurrence of the searchValue in the string. Optionally, you can specify a starting index for the search.
  6. lastIndexOf(searchValue, fromIndex): Returns the index of the last occurrence of the searchValue in the string. Optionally, you can specify a starting index for the search.
  7. startsWith(searchString, position): Checks if the string starts with the specified substring. Optionally, you can pass the starting position for the check.
  8. endsWith(searchString, length): Checks if the string ends with the specified substring. Optionally, you can pass the length of the substring to consider for the check.
  9. slice(startIndex, endIndex): Extracts a portion of the string, starting from the startIndex up to, but not including, the endIndex.
  10. substring(startIndex, endIndex): Similar to slice(), extracts a portion of the string from startIndex up to, but not including, the endIndex. Does not support negative indices.
  11. substr(startIndex, length): Extracts a substring from the startIndex of the specified length.
  12. toLowerCase(): Converts the string to lowercase.
  13. toUpperCase(): Converts the string to uppercase.
  14. trim(): Removes leading and trailing whitespaces from the string.
  15. split(separator, limit): Splits the string into an array of substrings based on the specified separator. Optionally, you can specify a limit for the number of splits.
  16. string.length: Returns the number of characters in the string.

Comments

Post a Comment

Popular posts from this blog

Limitations of JavaScript

-
Introduction to Limitations of JavaScript JavaScript is a widely used programming language that runs on all major web browsers. It is known for its versatility and ability to create dynamic and interactive web pages. However, like any programming language, JavaScript has its limitations. In this learning guide, we will explore the limitations of JavaScript to help you better understand its strengths and weaknesses. 1. Performance Limitations JavaScript is an interpreted language , which means that it is executed line by line at run-time. This can result in slower performance compared to compiled languages like C++ or Java. Additionally, JavaScript is a single-threaded language , meaning that it can only execute one operation at a time. This can lead to performance bottlenecks when dealing with computationally intensive tasks or handling large amounts of data. // Example of slow performance in JavaScript for ( var i = 0 ; i < 1000000000 ; i ++ ) { // Perform some computati...
Read more

'for in' Loop

-
Introduction to JavaScript 'for in' Loop The `for in` loop is a type of loop in JavaScript that is used to iterate over the properties of an object. It is often used when you need to loop through the keys or properties of an object and perform some action on each one. Unlike other loops like `for` and `while`, the `for in` loop is specifically designed to work with objects. Syntax The syntax for the `for in` loop is as follows: for   ( variable  in  object )   {    // code to be executed } The `variable` represents a temporary variable that will hold the key of each property in the object. The `object` is the object that you want to iterate over. Example Let's take a look at an example to understand how the `for in` loop works: const  person  =   {   name :   'John' ,   age :   30 ,   gender :   'male' } ;   for ...
Read more

What is JIT compiler? Is JavaScript compiled or interpreted or both?

-
What is JIT compiler? A Just-In-Time (JIT) compiler is a type of compiler that dynamically converts programming code into machine code at runtime, just before the code is executed. Unlike traditional compilers that convert the entire program ahead of time, a JIT compiler optimizes and compiles code on-the-fly, as it is needed. The primary advantage of a JIT compiler is that it can make the execution of code significantly faster compared to an interpreter. It achieves this by analyzing the code at runtime, identifying hotspots (frequently executed portions of code), and applying various optimization techniques to generate highly efficient machine code specific to the underlying hardware. JIT compilers are commonly used in programming languages such as Java and JavaScript, where the execution speed of the code is crucial. So is JavaScript Compiled or Interpreted? JavaScript is generally considered an interpreted language . Traditionally, JavaScript code is executed by an interpreter, wh...
Read more