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

Tightly Coupled and Loosely Coupled in .NET Core with example

-
In .NET Core, tight coupling and loose coupling refer to the way software components are designed and connected to each other. Tight coupling in .NET Core means that two or more software components are highly dependent on each other, making it difficult to modify or replace one component without affecting the others. This can lead to maintenance and testing challenges, as well as reduced flexibility and scalability. Loose coupling in .NET Core, on the other hand, means that software components are designed to be independent and have minimal interdependence. This is achieved by using interfaces, dependency injection, and other techniques to reduce the direct dependencies between components. Loose coupling allows components to be more easily replaced, modified, or extended without affecting the rest of the system. Summary, loose coupling is generally preferred in .NET Core because it makes software more flexible, maintainable, and scalable. Advant...
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

Export to Excel in Angular 6 | 7 | 8 | 9 | 10

-
Image
How to export the data in excel in Angular In Angular, we have different types libraries to export the data into excel file in different formats like (.xlsx, .xls, .csv). No need to communicate the server to export the data in excel file. Here we need to know about two famous angular libraries to export the data in excel file.  1. xlsx is a library to generate excel file in different formats with graphical design. Click here xslx ✋  to know more information about this library. 2. file-saver is a library to save the files in client side.  Click here file-saver ✋  to know more information about this library.  The main advantage of using this approach is, it will improve the performance to your application. In this post, We can see how to implement the export to excel functionality using xlsx library in Angular. Step 1 :   To create new application using angular cli, open Visual Studio code tool and open the terminal...
Read more

Create Custom Form Control for ng-select in Angular

-
Image
How to Create Custom Form Control in Angular  Why we create custom form control ? Normally, we used to create custom form control for re-usability.  The best advantage is that to add common functionality and features in this custom form control and extend the functionality as per our need and requirement.  And we can use everywhere into the application. But this example will tell you how to create custom form control to extend the functionality of  angular ng-select component.  We are adding a feature for this control, multi selection along with checkbox. Before that, we need to know what is the basic syntax of creating custom form control in angular. So, we start by implementing the ControlValueAccessor interface from @angular/forms into the component. This interface has three functions that need to be implemented and one optional functional. writeValue(obj: any): void { } registerOnChange(fn: any): void ...
Read more

Recommended Visual Studio Code Extensions for Angular Development

-
Every Angular Developer should know these recommended VS Code Extensions. I guess most of the developers using the Visual Studio Code tool for coding. There are large number of extensions are available in market place. But I choose necessary extensions, which is related to angular development. It will speed up your work when you're doing development. Extensions can help to improve productivity and code quality for Angular development in VS Code. By automating tasks and enforcing best practices, these extensions can help developers to create better code more quickly and with fewer errors. Angular Language Service - Provides rich editing experience for Angular templates with autocompletion, diagnostics, and jump-to-definition features. Angular Snippets - Provides a collection of Angular snippets to quickly insert common code structures, such as components, directives, and services. Angular Console - Provides a GUI tool for generating and managing Angular projects and associated fi...
Read more

Content Negotiation in Web API with example

-
Content negotiation in Web API C# refers to the process of determining the best format for data exchange between the client and the server. It allows the client to specify the format they prefer to receive data in, and the server will send the data in that format if it's available. In Web API C#, content negotiation is done through the use of media formatters. A media formatter is responsible for serializing and deserializing the data in a specific format, such as JSON, XML, or plain text. The process of content negotiation in Web API C# involves the following steps: The client sends a request to the server and specifies the media type it prefers to receive the response in, through the Accept header in the HTTP request. The server receives the request and examines the Accept header to determine the media type requested by the client. The server then looks for a media formatter that can serialize the response in th...
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

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