Strings are Immutable in JS

-

The immutability of strings in JavaScript

In JavaScript, strings are immutable, which means that once they are created, they cannot be changed. This means that any operation on a string will always return a new string rather than modifying the original string itself.

Example 1:

let str = "Hello";
let newStr = str.concat(" World");
console.log(str);     // Output: "Hello"
console.log(newStr);  // Output: "Hello World"

In the example above, the `concat()` method is used to concatenate the string " World" to the original string "Hello". However, the `concat()` method does not modify the original string, it returns a new string that contains the concatenated values.

Points to note:

1. Strings are immutable in JavaScript, meaning they cannot be changed after they are created.

2. Operations on strings always create new strings.

3. Methods like concat(), slice(), trim(), etc., that appear to modify strings actually return a new string instead.

4. The original string remains unchanged.

5. In JavaScript, strings are considered primitive values. This means they are immutable by nature.

Example 2:

let str1 = "JavaScript";
let str2 = str1.slice(0, 4);  // returns a new string "Java"
console.log(str1);  // Output: "JavaScript"
console.log(str2);  // Output: "Java"

In the example above, the `slice()` method is used to extract the substring "Java" from the original string "JavaScript". However, the `slice()` method does not modify the original string, it returns a new string that contains the extracted substring.

Immutability in Function Parameters:

When you pass a string to a function as an argument, the function cannot modify the original string. It can only work with a copy of the string.

function modifyString(s) {
    s = s.toUpperCase(); // Creates a new string inside the function
    return s;
}
 
let original = "abc";
let modified = modifyString(original);
console.log(original); // Output: "abc"
console.log(modified); // Output: "ABC"

Benefits of Immutability:

  • Predictability: Immutability leads to more predictable code behavior since you don't have to worry about unexpected changes to shared data.
  • Functional Programming: Immutability is a key concept in functional programming, enabling easier reasoning about code and minimizing side effects.
  • Performance Optimizations: Some JavaScript engines can optimize immutability patterns, making certain operations faster (like debugging).

Key takeaways:

  • String in JS are immutable, they cannot be changed once created.

  • Operations on strings always return a new string.

  • Methods like concat(), slice(), etc., do not modify the original string, they return a new string instead.

Comments

Post a Comment

Popular posts from this blog

Mastering JavaScript Output: Communicating with Users

-
JavaScript Output JavaScript output refers to the process of displaying or printing information to the user. It allows developers to communicate and present data in a variety of ways, such as through the browser console, alert boxes, or by manipulating the HTML content of a webpage. Displaying Output in the Browser Console The browser console is a built-in developer tool that allows you to log information, debug code, and view error messages. You can use the `console.log()` method to display output in the console. Here's an example: console. log ( "Hello, world!" ) ; The above code will print "Hello, world!" to the console. Alert Boxes Alert boxes are often used to display important messages or to prompt the user for input. You can use the `alert()` function to create an alert box. Here's an example: alert ( "Hello, world!" ) ; When the above code is executed, it will display an alert box with the message "Hello, world!". innerHTML JavaSc...
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

'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