hasValue

Paquete: @tiendana/utils

Verifica si un valor no es null, undefined, string vacío (''), o NaN. Para arrays, verifica que tengan al menos un elemento. Funciona como type guard en TypeScript.

Características

✅ Type guard TypeScript
✅ Manejo especial para arrays
✅ Detecta NaN correctamente
✅ Type narrowing automático

Firma

function hasValue<T>(
  value: T | null | undefined | '' | typeof NaN
): value is Exclude<T, null | undefined | '' | typeof NaN>

Parámetros

Parámetro	Tipo	Descripción	Requerido
value	T | null | undefined | '' | typeof NaN	Valor a verificar	✅

Retorno

Tipo: boolean

Retorna true si el valor tiene contenido válido:

• No es null
• No es undefined
• No es string vacío ''
• No es NaN
• Si es array, tiene al menos 1 elemento

Ejemplos de Uso

Validación Básica

import { hasValue } from '@tiendana/utils';

hasValue('hello');      // true
hasValue('');           // false
hasValue(null);         // false
hasValue(undefined);    // false
hasValue(0);            // true - 0 es valor válido
hasValue(false);        // true - false es valor válido
hasValue(NaN);          // false

Con Arrays

hasValue([1, 2, 3]);    // true
hasValue([]);           // false - array vacío no tiene valor
hasValue(['']);         // true - array con 1 elemento

Type Guard en TypeScript

function processValue(value: string | null | undefined) {
  if (hasValue(value)) {
    // TypeScript sabe que value es string aquí
    console.log(value.toUpperCase());
  }
}

En Validación de Formularios

function validateForm(data: FormData) {
  if (!hasValue(data.name)) {
    return 'El nombre es requerido';
  }
  
  if (!hasValue(data.email)) {
    return 'El email es requerido';
  }
  
  if (!hasValue(data.categories)) {
    return 'Debes seleccionar al menos una categoría';
  }
  
  return null; // válido
}

Con Valores Numéricos

const age = 0;
hasValue(age);          // true - 0 es un valor válido

const price = null;
hasValue(price);        // false

const quantity = NaN;
hasValue(quantity);     // false

Filtrar Arrays

const values = ['hello', null, '', undefined, 'world', NaN];
const valid = values.filter(hasValue);
// ['hello', 'world']

objHasValue

Variante para verificar objetos con propiedades.

Firma

function objHasValue<T>(
  value: T
): value is Exclude<T, null | undefined | '' | typeof NaN>

Uso

import { objHasValue } from '@tiendana/utils';

objHasValue({ name: 'Juan' });  // true - objeto con propiedades
objHasValue({});                // false - objeto vacío
objHasValue(null);              // false
objHasValue('text');            // false - no es objeto

Ejemplo Práctico

function processUser(user: User | null) {
  if (!objHasValue(user)) {
    throw new Error('Usuario inválido o vacío');
  }
  
  // TypeScript sabe que user es User válido aquí
  console.log(user.name);
}

Casos de Uso Comunes

• Validación de inputs: Verificar que campos de formulario tengan valor
• Type guards: Asegurar tipos en TypeScript antes de acceder a propiedades
• Validación de datos: Antes de procesar información de APIs
• Filtros de arrays: Remover valores nulos/vacíos
• Condiciones: En lugar de comparaciones verbosas como value !== null && value !== undefined

Notas Técnicas

• Arrays vacíos: hasValue([]) retorna false porque no tienen elementos
• Strings con espacios: hasValue(' ') retorna true - considera usar .trim() antes si necesitas validar strings con solo espacios
• Números: 0 y false son valores válidos y retornan true
• Type narrowing: TypeScript elimina automáticamente null/undefined del tipo después de la validación
• Performance: O(1) para todos los casos excepto arrays que es O(n) solo para obtener .length

Ver También

• objHasValue - Para verificar objetos con propiedades
• Patterns - Para validación con regex