delete Operator

-

JavaScript delete Operator

The `delete` operator is used in JavaScript to delete properties from an object or remove elements from an array. It allows you to remove a specific property or element and modify the structure of an object or array dynamically.

Deleting Object Properties

To delete a property from an object, you can use the `delete` operator followed by the object's property name:

const person = { name: 'John', age: 30 };
 
delete person.age;
 
console.log(person); // { name: 'John' }

In the example above, the `delete` operator is used to remove the `age` property from the `person` object. After deleting the property, the output will only include the `name` property.

Deleting Array Elements

To remove an element from an array, you can use the `delete` operator as well. However, be aware that using `delete` will remove the element but will not change the length of the array:

const numbers = [1, 2, 3, 4, 5];
 
delete numbers[2];
 
console.log(numbers); // [1, 2, empty, 4, 5]
 
console.log(numbers.length); // 5

In the example above, the `delete` operator is used to remove the element at index 2 from the `numbers` array. The output shows that the element is replaced with `empty`, indicating that the element has been deleted. However, the length of the array remains the same.

To completely remove an element and change the length of the array, you can use the `splice` method:

const numbers = [1, 2, 3, 4, 5];
 
numbers.splice(2, 1);
 
console.log(numbers); // [1, 2, 4, 5]
 
console.log(numbers.length); // 4

In this example, the `splice` method is used to remove one element at index 2 from the `numbers` array. The output shows that the array is modified, and the length is reduced by one.

Deleting Variable

It's important to note that the `delete` operator cannot delete variables declared with the `var`, `let`, or `const` keywords.

let x = 10;
 
var y = 20;
 
 
 
delete x; // false
 
delete y; // false
 
 
 
console.log(x); // 10
 
console.log(y); // 20

In the example above, attempting to delete variables `x` and `y` using the `delete` operator will return `false`, and the variables will not be deleted.

Deleting Built-in Object Properties

The `delete` operator can also be used to delete properties of built-in JavaScript objects, such as the `global` object (`window` in browsers):

delete window.document; // true
 
console.log(window.document); // undefined

In this example, the `delete` operator is used to delete the `document` property of the `window` object. After deleting the property, the output shows that the property is no longer accessible.

Key Takeaways

  • The `delete` operator is used to delete properties from objects or remove elements from arrays.

  • When used with objects, the `delete` operator removes the specified property.

  • When used with arrays, the `delete` operator removes the specified element but does not change the array's length.

  • Variables declared with `var`, `let`, or `const` cannot be deleted using the `delete` operator.

  • The `delete` operator can also be used to delete properties of built-in JavaScript objects.

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