कैसे करने के लिए फिल्टर एक टाइपप्रति सरणी के आधार पर हो सकता है-अपरिभाषित तारीख-के रूप में स्ट्रिंग मद वस्तु संपत्ति?

अपने प्रोजेक्ट में कहीं आप की तरह कुछ इस:

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

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

या यह (या विविधताओं तत्संबंधी):

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

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

_{या यह हो सकता है एक type के बजाय एक interface (बस सुनिश्चित करें कि आप का उपयोग कभी नहीं class का वर्णन करने के लिए JSON डेटा JSON के रूप में object डेटा नहीं किया जा सकता है एक class उदाहरण क्योंकि निर्माता चलाता है कभी नहीं).}

_{इसके अलावा, आप का उपयोग करना चाहिए camelCaseनहीं , PascalCaseके लिए , सदस्य गुण है । तो जैसे नामों का उपयोग करें createdOn के बजाय CreatedOn में अपने उत्पन्न JSON.}

सौभाग्य से आप की जरूरत नहीं है बदलने के लिए, प्रकार/इंटरफेस है, सिर्फ अपने को बदलने टाइपप्रति के लिए सुरक्षित रूप से जाँच करें .CreatedOn और है कि Date.parse वापस नहीं किया NaN. इस तरह की:

• के result.items ?? [] हिस्सा है, क्योंकि अपने पद का तात्पर्य result.items है nullable या हो सकता है-undefined.
• नोट का उपयोग करते समय map के साथ एक =>शैली समारोह है कि आप की जरूरत हो सकती है लपेटो करने के लिए वस्तु-literals में () तो जे एस इंजन नहीं है, की व्याख्या { और } ब्लॉक के रूप में सीमांकक.

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;
} );

हालांकि व्यक्तिगत रूप से मैं यह कर सकता हूँ के साथ एक प्रारंभिक filter और map कदम:

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 ) );

या सरलीकृत आगे:

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 );

एक भी बेहतर समाधान:

• यदि आप नियंत्रण में कर रहे हैं कि कैसे JSON उत्पन्न होता है, तो आप सुनिश्चित कर सकते हैं कि कुछ (या सभी) आइटम गुण हमेशा हो जाएगा सेट (और इसलिए कभी नहीं undefined या nullहै ), तो आप की गारंटी कर सकते हैं कि सभी 3 गुण हमेशा से रहे हैं सेट (कभी नहीं null या undefined) तो अद्यतन अपने प्रकार/इंटरफेस करने के लिए, इस:

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

  • नोट camelCase गुण.
  • अचल स्थिति डेटा का एक बड़ा लाभ है, तो सुनिश्चित करें कि अपने इंटरफेस गुणों के सभी कर रहे हैं readonly, सभी सरणियों हैं readonly T[]है , और है कि गुण ही कर रहे हैं के साथ एनोटेट ? या | null या | undefined के रूप में उपयुक्त के बजाय बस यह सोचते हैं एक ही रास्ता या अन्य.

• तो सुनिश्चित करें कि आप का उपयोग करें strictNullChecks में अपने tsconfig.json या tsc विकल्प! - वास्तव में, बस का उपयोग करें strict हमेशा!

• भी बदलने पर विचार अपने JSON डीटीओ से एक का उपयोग कर string प्रतिनिधित्व की एक तारीख (वहाँ रहे हैं किसी भी गारंटी के बारे में समयक्षेत्र?) करने के लिए जा रहा है एक natively पठनीय यूनिक्स टाइमस्टैम्प (मिलीसेकेंड में), कि जिस तरह से आप कर सकते हैं के साथ समस्याओं से बचने Date.parse पूरी तरह से:

उदाहरण के लिए:

परिणाम है.सीएस:

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

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

परिणाम है.टीएस:

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 );

...कि जिस तरह से यह एक एकल लाइन काम है ।

ऊपर बनाया जा सकता है, और भी आसान के रूप में यूनिक्स टाइमस्टैम्प कर रहे हैं बस integers हैं कि सीधे तुलनीय है, तो new Date() से बचा जा सकता है अंदर filterकी तरह है , तो:

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

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

मान लें आप परिभाषित इंटरफेस की तरह इस...

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

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

और आप फ़िल्टर करना चाहते हैं कि आइटम के लिए कर रहे हैं पुराने की तुलना में 90 दिन (छोड़कर उन के साथ कोई CreatedOn), तो यह प्रयास करें

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)

टाइपप्रति खेल का मैदान डेमो

कोड याद आ रही है ) के फिल्टर समारोह

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