Comprobar si una variable es una cadena en TypeScript

1. Tipos de TypeScript
2. Use el operador typeof para verificar si una variable es una cadena en TypeScript
3. Utilice el operador instanceof para comprobar si una variable es una cadena en TypeScript
4. Use Object.prototype para verificar si una variable es una cadena en TypeScript

Este artículo discutirá cómo verificar si una variable es una cadena en TypeScript.

Tipos de TypeScript

TypeScript es un superconjunto del lenguaje JavaScript donde la verificación de tipos se realiza en tiempo de compilación. Cada vez que se declara una variable, función o argumento, TypeScript nos permite asignar los tipos explícitamente, lo que ayuda a identificar los errores por adelantado.

// variable declaration and assignment
let stringTypeVariable: string = 'Hello world';
let booleanTypeVariable: boolean = true;
let numberTypeVariable: number = 10;

// function declaration
function calculateSum(numOne: number, numTwo: number): number {
    return numOne + numTwo;
}

el tipo de string en TypeScript

El tipo de cadena TypeScript contiene una colección de caracteres. Es un tipo de datos primitivo donde una secuencia de caracteres se envuelve entre comillas simples o dobles.

Los datos de texto se pueden almacenar en el tipo de cadena. Hay dos formas de almacenar cadenas en TypeScript:

1. Almacenar como un tipo primitivo
2. Almacenar como una instancia de objeto

Almacenar cadena como un tipo primitivo

Por lo general, el tipo de cadena primitivo contiene los literales de cadena. Las cadenas primitivas se recomiendan sobre instancias de objetos.

let stringTypeName: string = 'John Doe';
let stringTypeId: string = "User001";

Almacenar cadena como una instancia de objeto

TypeScript admite instancias de objetos String donde envuelve el tipo de cadena primitivo con métodos auxiliares adicionales. La instancia del objeto String tendrá el String.prototype en su cadena de prototipo.

let stringVal: String = new String('This is a String object');
let anotherStrVal: String = String('Another String object');

Hay algunas formas de verificar si una variable determinada contiene una cadena o no. Por lo general, el operador typeof se usa para verificar los tipos de cadenas primitivos, y el operador instanceof se puede usar con instancias de objetos String.

Aparte de eso, la propiedad Object.prototype se puede usar para verificar si el tipo dado es una cadena o no.

Use el operador typeof para verificar si una variable es una cadena en TypeScript

El typeof es un operador unario de TypeScript que devuelve el tipo de datos del operando especificado.

Sintaxis:

typeof <operand>

El operador devuelve una cadena que indica el tipo del operando.

Vamos a crear una cadena primitiva, userName.

let userName: string = 'Ricky hardy';

A continuación, utilizaremos el operador typeof para comprobar el tipo de datos de la variable userName. Imprimámoslo en la consola como se muestra a continuación:

console.log(typeof userName);

Producción :

string

Por lo tanto, el operador typeof se puede usar para verificar las cadenas de tipo primitivo dentro de un fragmento de código condicional, como se muestra a continuación:

if (typeof userName === 'string') {
    // logic to be executed when the type is a string
} else {
    // logic to be executed for non-string types
}

Utilice el operador instanceof para comprobar si una variable es una cadena en TypeScript

El operador instanceof opera en la cadena de prototipos de un objeto determinado y verifica si la propiedad del prototipo apareció allí. Comprueba si el objeto especificado es un hijo o una instancia de un constructor dado.

Sintaxis:

<object> instanceof <constructor/type>

Este operador devuelve un valor booleano. Además, el operador acepta solo instancias de objetos, no las primitivas.

Vamos a instanciar un nuevo objeto String, vehicleBrand.

let vehicleBrand: String = new String("AUDI");

A continuación, utilizaremos el operador instanceof para verificar si vehicleBrand es un tipo de cadena.

console.log(vehicleBrand instanceof String);

Producción :

true

Como era de esperar, el operador devuelve true porque vehicleBrand es un objeto String.

Use Object.prototype para verificar si una variable es una cadena en TypeScript

El Object.prototype también se puede usar como una forma más genérica de identificar tipos de cadenas en TypeScript. Esta propiedad contiene el método toString(), donde podemos usar el método call y verificar el tipo de prototipo de una variable específica.

Sintaxis:

Object.prototype.toString.call(<variable/object>);

Esto debería devolver una cadena en el siguiente formato:

"[object String]"
OR
"[object Array]"
OR
.
.
.

Vamos a crear una nueva variable, newStringValue.

let newStringValue: string = 'This is a new string';

A continuación, comprobaremos el tipo de constructor de variables newStringValue utilizando la propiedad Object.prototype.

console.log(Object.prototype.toString.call(newStringValue));

Producción :

[object String]

Como era de esperar, el tipo es una cadena.