Create Extension Method in typescript - String.IsNullOrEmpty()

-

How to Create Extension Method using Typescript in Angular Application - String.IsNullOrEmpty()

Step 1 : Create typings.d.ts (declaration file) in the application and declare the method in interface like below.

HTML 
interface StringConstructor {
    isNullOrEmpty(value: string): boolean;
}

Step 2 : Create extension.ts file in the application and implement the method like below.

HTML 
String.isNullOrEmpty = function (value: string): boolean {
  return value === undefined || value.trim() === '' || value === null;
};

Step 3 : Usage of the Method in the component or class file.

HTML 
import './extensions';

export class TestComponent implements OnInit {

  public ngOnInit(): void {

  let abc;

  console.log(String.isNullOrEmpty(abc));

  }

}

Step 4 : Output like below.


Comments

Post a Comment

Popular posts from this blog

Send API POST Request in MS SQL Server

-
To send an API POST request in MS SQL Server using multipart/form-data, you can use the following T-SQL code: Example of content type : multipart/form-data SQL DECLARE @url VARCHAR(200) = 'https://example.com/api'; DECLARE @boundary VARCHAR(50) = '---------------------------' + CAST(NEWID() AS VARCHAR(36)); DECLARE @param1Name VARCHAR(50) = 'name'; DECLARE @param1Value VARCHAR(50) = 'John Doe'; DECLARE @param2Name VARCHAR(50) = 'email'; DECLARE @param2Value VARCHAR(50) = 'johndoe@example.com'; DECLARE @param3Name VARCHAR(50) = 'file'; DECLARE @param3Value VARBINARY(MAX) = (SELECT BulkColumn FROM OPENROWSET(BULK 'C:\path\to\file.txt', SINGLE_BLOB) AS x); DECLARE @param4Name VARCHAR(50) = 'description'; DECLARE @param4Value VARCHAR(200) = 'This is a sample file'; DECLARE @formData NVARCHAR(MAX) = N'--' + @boundary + CHAR(13) + CHAR(10) + ...
Read more

Use immutable data structures to avoid unnecessary change detection In Angular

-
In Angular, change detection is triggered whenever there is a change in the component's data or state. This can be a performance bottleneck if the component's data is updated frequently, and the component has a lot of child components or bindings. One way to optimize change detection is to use immutable data structures. Immutable data structures are data structures that cannot be modified once they are created. Instead, when a change is made to the data, a new instance of the data structure is created with the updated values. Here's an example of how to use immutable data structures in Angular: HTML import { Component } from '@angular/core'; import { List } from 'immutable'; @Component({ selector: 'app-list', template: ` {{ item }} ` }) export class ListComponent { items = List (['item 1', 'item 2', 'item 3']); addItem() { // The...
Read more

Angular CLI Commands - Cheat Sheet

-
Image
Angular CLI (Command Line Interface) is one of the powerful tool that allows you to perform a lot of actions in an Angular project by using simple commands. We can use the CLI tool directly in a command shell, or indirectly through an interactive UI such as Angular Console.  The Best Advantage is that, can avoid manual process to create lot of stuff like create components, directives, feature modules, services... etc.  It automatically recompiles the source code files and refreshes the app in the browser.  Let's see, how to install CLI tool and what are those CLI commands. Installing the CLI is very quite easy. All we need to do, is to run the below command in Terminal or Console. It will install the CLI tool globally with respective version. Here we need to know two things before installing the CLI tool. We can install latest version or any version released by angular team based on your project need. Check the Versions list.✋ Angular CLI Setup  1. Globally - To ins...
Read more

Difference of High-Level Design (HLD) and Low-Level Design (LLD)

-
High-Level Design (HLD) and Low-Level Design (LLD) are software design concepts that are not specific to any programming language. However, to illustrate the differences between HLD and LLD, we can use C# programming language examples. Suppose we are designing a software system that involves creating a payment gateway application in C#.  Here are examples of HLD and LLD for this system: High-Level Design (HLD): Define the functional requirements of the payment gateway system, such as processing payment transactions, handling errors, and providing a user interface. Identify the non-functional requirements, such as performance, scalability, and security. Identify the key components of the payment gateway system, such as payment processing engine, database, user interface, and error handling. Create an architecture diagram that shows how these components will fit together to form the payment gateway system. In HLD, the focus is on defining the system's overall structure and architectu...
Read more

Restrict Special Characters in Windows Application using c#

-
Image
Example : In this application it will remove all the special characters when we trying to copy paste the special characters. Lets see how it is possible with Copy,paste. Please follow these steps : 1. Create a New Windows Form with the name of 'Form1', and take one label with the name of 'lblName' and one textbox with the name of 'txtName' and one button with the name of 'btnValidate'. Please see below image. 2. Add a code in TextChanged event for that textbox. Here my textbox name is 'txtName' in that I have added a event like . private void txtName_TextChanged(object sender, EventArgs e) {       txtName.Text = RemoveSpecialCharacters(txtName.Text); } 3. In that event you observed method name of 'RemoveSpecialCharacters'.Basically it will remove all the special characters when you are copy paste in to the textbox.       private string RemoveSpecialCharacters(String inString)       ...
Read more

Map Operator in RxJs

-
The map operator in RxJS is used to transform the emissions of an Observable stream. It applies a function to each emitted value and returns a new Observable with the transformed values. The original values are not modified. The map operator is often used in combination with other operators to create complex data flows. Advantages of the map operator in RxJS include: Transformation of data : The map operator allows you to transform the data emitted by an Observable, which can be very useful for manipulating the data in the way you need it. Efficiency : The map operator is an efficient way to modify data, as it does not modify the original data and creates a new Observable with the transformed data. Composability : The map operator is a composable operator, which means you can combine it with other operators to create more complex data flows. Clarity : Using the map ope...
Read more

Clean Architecture in a C#

-
Clean Architecture is a software design pattern that separates the application into independent layers, where each layer has a specific responsibility and interacts with other layers through well-defined interfaces. The main goal of clean architecture is to create a flexible, testable, and maintainable software system. By following this architecture, we have created a flexible, testable, and maintainable software system. The domain layer is independent of any external dependencies and frameworks, making it easy to test and change without affecting other layers. The application layer contains the use cases or application-specific logic, which is decoupled from the infrastructure Here's an example of how to implement Clean Architecture in a C# project: 1. Domain Layer: This layer contains the business logic and domain-specific entities. It should be independent of any external dependencies and frameworks. C# ...
Read more

Implementing DIP (Dependency Inversion Principle) in .NET Core project

-
Dependency Inversion Principle (DIP) is one of the SOLID principles that states that high-level modules should not depend on low-level modules, instead both should depend on abstractions. In .NET Core, we can implement DIP using various techniques such as Dependency Injection, Inversion of Control (IoC), and Service Locator. Here's a simple example of how to implement DIP using Dependency Injection in a .NET Core project: By following below steps, we can implement DIP in our .NET Core project using Dependency Injection. 1. Define interfaces for the low-level modules (dependencies) that the high-level module needs to use. For example: public interface ILogger {     void Log( string message); } public interface IDataProvider {     string GetData(); } 2. Create implementations for these interfaces.  For example: public class FileLogger : ILogger {     public void Log( string message)     {         // cod...
Read more

RxJs Operators in Angular

-
RxJS (Reactive Extensions for JavaScript) is a library for reactive programming using Observables, which are a way to represent asynchronous data streams. RxJS provides a set of operators that can be used to transform, filter, combine, and manipulate these data streams. In RxJS, operators are functions that take one or more observables as input, and return a new observable. These operators can be chained together to create complex data stream transformations. RxJS operators have several advantages and disadvantages that are worth considering: Advantages: Composable : RxJS operators are composable, which means they can be combined in a variety of ways to create complex data stream transformations. This allows for a high degree of flexibility and modularity in reactive programming applications. Asynchronous : RxJS operators are designed to handle asynchronous data streams, which are common in modern web applications. This makes them well-suited for tasks like handling user input, making ...
Read more

Aggregation and Association and Composition and Its differences with examples

-
 Aggregation, association, and composition are object-oriented programming concepts that define relationships between classes or objects. Here are their definitions and differences: 1. Aggregation: Aggregation is a relationship where one object has a reference to another object, but the referenced object can exist independently of the object that references it. The object that references the other is known as the container or owner, while the referenced object is known as the contained or member object. Here are a few examples of aggregation in C#: Example - 1 : A university has many departments, and each department has many students. In this case, the Department class is the container, and the Student class is the contained object. Here's an example code: public class Department {     public List<Student> Students { get ; set ; } } public class Student {     public string Name { get ; set ; } } Example - 2 : A car has an engine, and the engine can ...
Read more