Cómo filtrar un Manuscrito de matriz basada en la tal vez-indefinido fecha-como-cadena elemento de la propiedad del objeto?

En alguna parte de tu proyecto, tendrás algo como esto:

interface Result {
    readonly items: readonly ResultItem[] | null;
}

interface ResultItem {
    readonly Name       : string;
    readonly CreatedOn  : string | undefined;
    readonly Description: string;
}

o esta (o variaciones de los mismos):

type Result = {
    items?: ResultItem[];
}

interface ResultItem {
    Name       : string;
    CreatedOn? : string;
    Description: string;
}

_{O puede ser un type en lugar de una interface (sólo asegúrese de que usted nunca se uso class para describir datos en JSON, como JSON object los datos no puede ser un class instancia porque el constructor no se ejecuta nunca).}

_{También, usted debe utilizar camelCase, no PascalCasepara las propiedades de miembro. Así que el uso de nombres como createdOn en lugar de CreatedOn en su generados JSON.}

Afortunadamente, Usted no necesita cambiar el/tipos de interfaces, acaba de cambiar su Manuscrito a la seguridad de verificación .CreatedOn y que Date.parse no volver NaN. Así:

• El result.items ?? [] parte es porque tu post implica result.items se aceptan valores null o tal vez-undefined.
• Nota cuando se utiliza map con un =>-función de estilo que usted puede necesitar para envolver objetos literales en () así que el JS motor no interpretar el { y } como delimitadores de bloque.

const result: Result = ...

const currentDate = new Date();

const newResult = (result.items ?? []).filter( e => {
    if( typeof e.CreatedOn === 'string' ) {
        const parsed = Date.parse( e.CreatedOn );
        if( !isNaN( parsed ) ) {
            return ( currentDate - parsed ) > 90;
        }
    }
    return false;
} );

Aunque personalmente me gustaría hacerlo con una inicial filter y map pasos:

const items       = result.items ?? [];
const currentDate = new Date();

const newResult = items
    .filter( e => typeof e.CreatedOn === 'string' )
    .map( e => ( { ...e, CreatedOn2: Date.parse( e.CreatedOn ) } ) )
    .filter( e => !isNaN( e.CreatedOn2 ) )
    .filter( e => ( currentDate - e.CreatedOn2 ) > 90 ) );

o simplificar más:

const items       = result.items ?? [];
const currentDate = new Date();

const newResult = items
    .filter( e => typeof e.CreatedOn === 'string' )
    .map( e => Object.assign( e, { createdOn2: Date.parse( e.CreatedOn ) )
    .filter( e => !isNaN( e.CreatedOn2 ) && ( currentDate - e.CreatedOn2 ) > 90 );

Una solución aún mejor:

• Si usted está en control de cómo el JSON que se genera, a continuación, usted puede asegurar que algunos (o todos) de las propiedades de elemento siempre (y por lo que nunca undefined o null), así que si usted puede garantizar que todos los 3 propiedades son siempre de ajuste (nunca null o undefined), a continuación, actualizar su/tipos de interfaces para esto:

  interface ResultItem {
      readonly name       : string;
      readonly createdOn  : string;
      readonly description: string;
  }
  

  • Nota la camelCase propiedades.
  • La inmutabilidad de datos es una gran ventaja, así que asegúrese de que su interfaz propiedades son todos readonly, de todas las matrices son readonly T[]y que propiedades sólo están anotados con ? o | null o | undefined como apropiada en lugar de simplemente asumir de una manera o de otra.

• Así que asegúrese de usar strictNullChecks en su tsconfig.json o tsc opciones! - en realidad, sólo tiene que utilizar strict siempre!

• También considere la posibilidad de cambiar su JSON DTO del uso de un string representación de una Fecha (¿hay alguna gurantees sobre la zona horaria?) para ser una forma nativa legible timestamp de Unix (en milisegundos), de esa manera usted puede evitar problemas con Date.parse totalmente:

por ejemplo:

Resultado.cs:

public class ResultItem
{
    [JsonProperty( "createdOn" )]
    public DateTimeOffset CreatedOn { get; }

    [JsonProperty( "createdOnUnix" )]
    public Int64 CreatedOnUnix => this.CreatedOn.ToUnixTimeMilliseconds();
}

Resultado.ts:

interface ResultItem {
    readonly createdOn    : string;
    readonly createdOnUnix: number;
}

const ninetyDaysAgo = new Date();
ninetyDaysAgo.setDate( ninetyDaysAgo.getDate() - 90 );

const newResult = items.filter( e => new Date( e.createdOnUnix ) < ninetyDaysAgo );

...que el camino es de una sola línea de trabajo.

Lo anterior puede ser aún más simple como Unix marcas de tiempo son sólo números enteros que son directamente comparables, por lo que new Date() se puede evitar en el interior de la filter, así:

const ninetyDaysAgo = new Date();
ninetyDaysAgo.setDate( ninetyDaysAgo.getDate() - 90 );
const ninetyDaysAgoUnix = ninetyDaysAgo.getTime();

const newResult = items.filter( e => e.createdOnUnix < ninetyDaysAgoUnix );

Asumiendo que usted tiene interfaces definidas como este...

interface Item {
  Name: string,
  Description: string,
  CreatedOn?: string // note the optional "?"
}

interface Result {
  items?: Item[] // also optional according to your code
}

y desea filtrar los elementos que son más de 90 días (excluyendo aquellos que no CreatedOn), a continuación, intente esto

interface ItemWithDate extends Omit<Item, "CreatedOn"> {
  CreatedOn?: Date // real dates, so much better than strings
}

const result: Result = { /* whatever */ }

const items: ItemWithDate[] = result.items?.map(({ CreatedOn, ...item }) => ({
  ...item,
  CreatedOn: CreatedOn ? new Date(CreatedOn) : undefined
})) ?? []

const dateThreshold = new Date()
dateThreshold.setDate(dateThreshold.getDate() - 90)

const newItems = items.filter(({ CreatedOn }) =>
  CreatedOn && CreatedOn < dateThreshold)

Transcripción De Juegos Demo

código falta ) de la función de filtro

var currentDate = new Date();
var newResult = result.items?.filter(function(i) {
    return ((currentDate - Date.parse(i.CreatedOn)) > 90);
}  ) //<= misss