Dart के पैटर्न और रिकॉर्ड के बारे में ज़्यादा जानें

1. परिचय

Dart 3 में, भाषा के लिए पैटर्न को शामिल किया गया है. यह व्याकरण की एक मुख्य कैटगरी है. Dart कोड लिखने के इस तरीके के अलावा, Dart 3 में भाषा से जुड़ी कई अन्य सुविधाएं भी शामिल हैं:

  • रिकॉर्ड, अलग-अलग तरह के डेटा को बंडल करने के लिए.
  • ऐक्सेस को कंट्रोल करने और पूरी तरह से जांच करने की सुविधा चालू करने के लिए, क्लास मॉडिफ़ायर (जैसे कि sealed).
  • बेहतर switch expressions, if-case statements, और guard clauses.

इन सुविधाओं से, Dart कोड लिखते समय आपको ज़्यादा विकल्प मिलते हैं. इस कोडलैब में, Google Antigravity के साथ मिलकर काम किया जाता है. इससे आपको यह सीखने को मिलता है कि अपने कोड को ज़्यादा छोटा, आसान, और ज़रूरत के हिसाब से बनाने के लिए, इसका इस्तेमाल कैसे किया जाए.

आपको क्या बनाना होगा

इस कोडलैब में, आपको Google Antigravity के साथ मिलकर एक ऐसा ऐप्लिकेशन बनाना होगा जो Flutter में स्ट्रक्चर्ड JSON दस्तावेज़ दिखाता हो. यह ऐप्लिकेशन, किसी बाहरी सोर्स से आने वाले JSON को सिम्युलेट करता है. इसमें दस्तावेज़ का मेटाडेटा (टाइटल और बदलाव की तारीख) और कॉन्टेंट ब्लॉक (हेडर, पैराग्राफ़, और चेकबॉक्स) शामिल होते हैं.

आपको Antigravity को डेटा को रिकॉर्ड में पैक करने के लिए प्रॉम्प्ट देना होगा, ताकि उसे ट्रांसफ़र किया जा सके और अनपैक किया जा सके. ऐसा वहां किया जा सकता है जहां आपके Flutter विजेट को इसकी ज़रूरत हो. साथ ही, JSON डेटा की पुष्टि करने और उसे लोकल वैरिएबल में बदलने के लिए पैटर्न का इस्तेमाल किया जा सकता है. इसके अलावा, हर कॉन्टेंट ब्लॉक के लिए सही विजेट बनाने के लिए, switch एक्सप्रेशन को sealed क्लास के साथ जोड़ा जा सकता है.

इस कोडलैब में बनाया गया फ़ाइनल ऐप्लिकेशन, जिसमें एक दस्तावेज़ दिखाया गया है. इसमें टाइटल, बदलाव की तारीख, हेडर, पैराग्राफ़, और एक चेकबॉक्स है

सीखने का आपका सफ़र

इस कोडलैब में, दस्तावेज़ व्यूअर बनाने का तरीका सिलसिलेवार तरीके से बताया गया है:

  1. अपना Flutter एनवायरमेंट सेट अप करना - अपने टारगेट प्लैटफ़ॉर्म के लिए, Flutter SDK और Google Antigravity को कॉन्फ़िगर करें.
  2. प्रोजेक्ट बनाना - Antigravity को lib/data.dart में मॉक JSON डेटा और lib/main.dart में स्टार्टर DocumentScreen के साथ patterns_codelab को स्कैफ़ोल्ड करने के लिए कहें.
  3. रिकॉर्ड बनाना और उन्हें रिटर्न करना - रिकॉर्ड का इस्तेमाल करके, गेटर से अलग-अलग टाइप की कई वैल्यू रिटर्न करें. साथ ही, इसके पोज़िशनल और नेम वाले फ़ील्ड पढ़ें.
  4. पैटर्न के साथ मैच और डिस्ट्रक्चर करना - पैटर्न वैरिएबल डिक्लेरेशन और फ़ील्ड शॉर्टहैंड का इस्तेमाल करके, रिकॉर्ड फ़ील्ड को सीधे लोकल वैरिएबल में अनपैक करें.
  5. डेटा निकालने के लिए पैटर्न का इस्तेमाल करना - रिफ़्यूटेबल if-case मैप पैटर्न का इस्तेमाल करके, नेस्ट किए गए JSON वैल्यू की पुष्टि करें और उन्हें सुरक्षित तरीके से निकालें.
  6. ऐप्लिकेशन को ज़्यादा पैटर्न के लिए तैयार करना - मैप पैटर्न और कलेक्शन-फ़ॉर लिस्ट लिटरल का इस्तेमाल करके, JSON कलेक्शन को Block इंस्टेंस में पार्स करें.
  7. दस्तावेज़ दिखाने के लिए पैटर्न का इस्तेमाल करना - लॉजिकल-or और वाइल्डकार्ड पैटर्न के साथ बेहतर switch स्टेटमेंट का इस्तेमाल करके, यूज़र इंटरफ़ेस (यूआई) में Block आइटम रेंडर करें.
  8. स्विच एक्सप्रेशन का इस्तेमाल करें - switch स्टेटमेंट को छोटे switch एक्सप्रेशन में बदलें, जो सीधे तौर पर वैल्यू दिखाता है.
  9. ऑब्जेक्ट पैटर्न का इस्तेमाल करें - Duration प्रॉपर्टी से मैच करें और when गार्ड क्लॉज़ लागू करें, ताकि किसी व्यक्ति के लिए आसानी से पढ़ी जा सकने वाली रिलेटिव तारीखों को फ़ॉर्मैट किया जा सके.
  10. एग्ज़ॉस्टिव स्विचिंग के लिए, किसी क्लास को सील करें - Block को sealed क्लास की हैरारकी में रीफ़ैक्टर करें, ताकि Dart ऐनलाइज़र हर ब्लॉक सबटाइप में एग्ज़ॉस्टिव स्विचिंग लागू कर सके.

आपको क्या सीखने को मिलेगा

  • Dart 3 लैंग्वेज की सुविधाओं का इस्तेमाल करके, Flutter दस्तावेज़ व्यूअर को बार-बार बनाने और उसे पसंद के मुताबिक बनाने के लिए, Google Antigravity के साथ मिलकर काम करने का तरीका.
  • अलग-अलग टाइप की कई वैल्यू को स्टोर करने और उन्हें रिटर्न करने वाला रिकॉर्ड बनाने का तरीका.
  • रिकॉर्ड, मैप, और ऑब्जेक्ट से डेटा को मैच करने, उसकी पुष्टि करने, और उसे डिस्ट्रक्चर करने के लिए, पैटर्न इस्तेमाल करने का तरीका.
  • पैटर्न से मैच होने वाली वैल्यू को नए लोकल वैरिएबल से कैसे बाइंड करें.
  • switch स्टेटमेंट की बेहतर सुविधाओं, switch एक्सप्रेशन, गार्ड क्लॉज़ (when), और if-case स्टेटमेंट को इस्तेमाल करने का तरीका.
  • sealed क्लास के साथ एग्ज़ॉस्टिवनेस चेकिंग का फ़ायदा कैसे लें, ताकि यह पक्का किया जा सके कि हर केस को switch स्टेटमेंट या switch एक्सप्रेशन में हैंडल किया गया है.

ज़रूरी शर्तें

इस कोडलैब में यह माना गया है कि आपको Flutter और Dart के बारे में कुछ जानकारी है. अगर आपको लगता है कि आपको कुछ चीज़ें याद नहीं हैं, तो यहां दिए गए संसाधनों की मदद से बुनियादी बातों को फिर से समझें:

2. अपना Flutter एनवायरमेंट सेट अप करना

संपादक

इस कोडलैब में, Google Antigravity का इस्तेमाल एआई-फ़र्स्ट डेवलपमेंट एनवायरमेंट के तौर पर किया जाता है. हर चरण में, Antigravity को अपने ऐप्लिकेशन के कॉम्पोनेंट जनरेट करने या उन्हें बेहतर बनाने के लिए प्रॉम्प्ट दें. साथ ही, जनरेट किए गए कोड में Dart 3 के मुख्य पैटर्न और रिकॉर्ड के कॉन्सेप्ट की समीक्षा करें. इसके अलावा, आपके पास अलग-अलग वैरिएंट एक्सप्लोर करने का विकल्प भी है.

Flutter इंस्टॉल करना

Flutter SDK टूल को इंस्टॉल करने के बारे में अप-टू-डेट निर्देश, हमेशा docs.flutter.dev पर उपलब्ध होते हैं.

इस कोडलैब के लिए, यह सॉफ़्टवेयर इंस्टॉल करें:

  1. Flutter SDK
  2. Google Antigravity में Dart और Flutter का आधिकारिक प्लगइन चालू होना चाहिए. यह प्लगइन, प्लगइन Marketplace में Build with Google सेक्शन में उपलब्ध है.
  3. आपके चुने गए डेवलपमेंट टारगेट के लिए कंपाइलर सॉफ़्टवेयर. उदाहरण के लिए, Windows को टारगेट करने के लिए Visual Studio, macOS या iOS को टारगेट करने के लिए Xcode या वेब को टारगेट करने के लिए Chrome.

यह पुष्टि करने के लिए कि आपका एनवायरमेंट, चुने गए डिप्लॉयमेंट टारगेट के लिए सेट अप किया गया है, flutter doctor चलाएं:

flutter doctor

3. प्रोजेक्ट बनाना

पैटर्न, रिकॉर्ड, और Dart 3 की अन्य सुविधाओं के बारे में जानने से पहले, Antigravity को दो Dart फ़ाइलों वाला Flutter प्रोजेक्ट बनाने के लिए कहें. इस कोडलैब में, इन फ़ाइलों को बेहतर बनाया जाएगा:

  • lib/data.dart, जिसमें मॉक JSON दस्तावेज़ और Document डेटा क्लास शामिल है.
  • lib/main.dart, जिसमें दस्तावेज़ को रेंडर करने वाले Flutter विजेट शामिल हैं.

प्रोजेक्ट बनाने के लिए, Antigravity को प्रॉम्प्ट दें

  1. Google Antigravity लॉन्च करें और वह खाली डायरेक्ट्री खोलें जहां आपको अपना प्रोजेक्ट बनाना है. ऐसा पाथ चुनें जिसके लिए खास सुविधाओं के ऐक्सेस की ज़रूरत न हो या जिसमें स्पेस न हों. जैसे, आपकी होम डायरेक्ट्री या C:\src\ में मौजूद कोई फ़ोल्डर.
  2. Antigravity एजेंट के चैट पैनल में, Flutter प्रोजेक्ट बनाने और lib/data.dart और lib/main.dart को सेट अप करने के लिए, यह प्रॉम्प्ट भेजें:
Create a new empty Flutter project named `patterns_codelab` with a minimum Dart SDK constraint of `^3.0.0`, and add the `material_ui` package. Create `lib/data.dart` with a `Document` class that decodes a multi-line `documentJson` constant (containing a `"metadata"` object with `"title": "My Document"` and `"modified": "2023-05-10"`, and a `"blocks"` list with an `"h1"` header `"Section 1"`, a `"p"` paragraph `"Lorem ipsum dolor sit amet, consectetur adipiscing elit."`, and an unchecked `"checkbox"` `"Learn Dart 3"`) into a `final Map<String, Object?> _json` field. Then update `lib/main.dart` (importing `package:material_ui/material_ui.dart`) to run a `DocumentApp` widget whose home is `DocumentScreen(document: Document())`, rendering a `Scaffold` with placeholder `'Title goes here'` and `'Body goes here'` text.

जनरेट किए गए कोड को समझना

pubspec.yaml में SDK टूल का कम से कम वर्शन

flutter create में --empty फ़्लैग पास करने से, डिफ़ॉल्ट काउंटर ऐप्लिकेशन बॉयलरप्लेट के बिना, एक छोटा Flutter प्रोजेक्ट बनता है. pubspec.yaml में, SDK टूल के वर्शन की पाबंदी, कैरेट सिंटैक्स का इस्तेमाल करके Dart 3 या इसके बाद के वर्शन के बारे में बताती है:

environment:
  sdk: ^3.0.0

lib/data.dart में आने वाले JSON का मॉकअप बनाना

मान लें कि किसी प्रोग्राम को किसी बाहरी सोर्स से डेटा मिल रहा है, जैसे कि कोई I/O स्ट्रीम या एचटीटीपी अनुरोध. lib/data.dart में, documentJson आने वाले JSON पेलोड को कई लाइनों वाली स्ट्रिंग के साथ मॉक करता है. साथ ही, Document कंस्ट्रक्टर, jsonDecode का इस्तेमाल करके इसे _json में पार्स करता है:

import 'dart:convert';

class Document {
  final Map<String, Object?> _json;
  Document() : _json = jsonDecode(documentJson);
}

lib/main.dart में DocumentApp और DocumentScreen के लिए स्कैफ़ोल्डिंग

lib/main.dart में, Antigravity दो स्टेटलेस विजेट तय करता है:

  • DocumentApp, यूज़र इंटरफ़ेस (यूआई) की थीम सेट करने के लिए, मटीरियल डिज़ाइन (package:material_ui/material_ui.dart) सेट अप करता है.
  • DocumentScreen, Scaffold विजेट का इस्तेमाल करके पेज का विज़ुअल लेआउट उपलब्ध कराता है:
class DocumentScreen extends StatelessWidget {
  final Document document;

  const DocumentScreen({required this.document, super.key});

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('Title goes here')),
      body: const Column(children: [Center(child: Text('Body goes here'))]),
    );
  }
}

ऐप्लिकेशन को चलाना और टेस्ट करना

ऐप्लिकेशन को अपने चुने गए टारगेट प्लैटफ़ॉर्म पर चलाएं. जैसे, Chrome, macOS, Windows, Linux, iOS या Android. आपको एक ऐप्लिकेशन फ़्रेम दिखेगा, जिसमें DocumentScreen में तय किया गया प्लेसहोल्डर title और body टेक्स्ट दिखेगा:

स्टार्टर ऐप्लिकेशन, जिसमें ऐप्लिकेशन बार में 'टाइटल यहां डालें' और मुख्य हिस्से में 'मुख्य हिस्सा यहां डालें' दिख रहा है

4. रिकॉर्ड बनाना और उन्हें वापस करना

इस चरण में, एक ही गेटर कॉल से कई वैल्यू दिखाने के लिए, रिकॉर्ड का इस्तेमाल किया जाता है. इसके बाद, रिकॉर्ड के फ़ील्ड को DocumentScreen में ऐक्सेस किया जाता है, ताकि उन्हें यूज़र इंटरफ़ेस (यूआई) में दिखाया जा सके.

Antigravity को कोई रिकॉर्ड वापस करने और पढ़ने के लिए प्रॉम्प्ट देना

Antigravity में यह प्रॉम्प्ट भेजें:

In `lib/data.dart`, add a `metadata` getter to `Document` with return type `(String, {DateTime modified})` that returns a hardcoded record `('My Document', modified: DateTime.now())`. In `lib/main.dart`, call `document.metadata` inside `DocumentScreen.build`, display the positional title field (`metadataRecord.$1`) in the `AppBar`, and display `'Last modified ${metadataRecord.modified}'` in the body.

जनरेट किए गए कोड को समझना

Document.metadata से रिकॉर्ड वापस करना

lib/data.dart में, metadata गेटर दो फ़ील्ड वाला रिकॉर्ड दिखाता है. इनमें से एक फ़ील्ड का टाइप String और दूसरे का टाइप DateTime होता है:

  (String, {DateTime modified}) get metadata {
    const title = 'My Document';
    final now = DateTime.now();

    return (title, modified: now);
  }

रिटर्न स्टेटमेंट, दोनों वैल्यू को ब्रैकेट में रखकर एक नया रिकॉर्ड बनाता है: (title, modified: now). पहला फ़ील्ड पोज़िशनल है और इसका कोई नाम नहीं है. वहीं, दूसरे फ़ील्ड का नाम modified है.

पोज़िशनल और नाम वाले रिकॉर्ड फ़ील्ड ऐक्सेस करना

lib/main.dart में, DocumentScreen.build document.metadata को metadataRecord को असाइन करता है और पहले से मौजूद रिकॉर्ड गेटर का इस्तेमाल करके इसके फ़ील्ड को पढ़ता है:

  @override
  Widget build(BuildContext context) {
    final metadataRecord = document.metadata;

    return Scaffold(
      appBar: AppBar(title: Text(metadataRecord.$1)),
      body: Column(
        children: [
          Center(child: Text('Last modified ${metadataRecord.modified}')),
        ],
      ),
    );
  }
  • पोज़िशनल फ़ील्ड (बिना नाम वाला फ़ील्ड, जैसे कि title) पाने के लिए, रिकॉर्ड पर गेटर $ का इस्तेमाल करें. यह $1 से शुरू होता है और नाम वाले फ़ील्ड को छोड़ देता है.
  • modified जैसे नाम वाले फ़ील्ड में, पोज़िशनल गेटर नहीं होता. इन्हें सीधे इनके फ़ील्ड के नाम से ऐक्सेस किया जाता है, जैसे कि metadataRecord.modified.

उदाहरण के लिए, नाम वाले और पोज़िशनल फ़ील्ड को मिलाने वाले रिकॉर्ड में, पोज़िशनल गेटर सिर्फ़ बिना नाम वाले फ़ील्ड को नंबर देते हैं:

var record = (named: 'v', 'y', named2: 'x', 'z');
print(record.$1); // prints y
print(record.$2); // prints z

रिकॉर्ड में मौजूद हर फ़ील्ड का स्टैटिक टाइप बना रहता है: Text() को String के तौर पर metadataRecord.$1 मिलता है, जबकि metadataRecord.modified एक DateTime है जो स्ट्रिंग इंटरपोलेशन का इस्तेमाल करके String में बदल जाता है.

ऐप्लिकेशन को चलाना और टेस्ट करना

स्क्रीन पर टाइटल और मौजूदा टाइमस्टैंप देखने के लिए, ऐप्लिकेशन को हॉट रीलोड करें:

ऐप्लिकेशन बार में 'मेरा दस्तावेज़' और मुख्य हिस्से में पिछली बार किए गए बदलाव का टाइमस्टैंप दिखाने वाला ऐप्लिकेशन

5. पैटर्न के साथ मैच और डिस्ट्रक्चर करना

रिकॉर्ड, अलग-अलग तरह के डेटा को बेहतर तरीके से इकट्ठा कर सकते हैं और उन्हें पास कर सकते हैं. अब पैटर्न का इस्तेमाल करके, DocumentScreen में कोड को बेहतर बनाया जाएगा.

पैटर्न, एक ऐसा स्ट्रक्चर होता है जिसमें एक या उससे ज़्यादा वैल्यू हो सकती हैं. जैसे, ब्लूप्रिंट. पैटर्न की तुलना असल वैल्यू से की जाती है, ताकि यह पता लगाया जा सके कि वे मैच करते हैं या नहीं. जब कोई पैटर्न मैच होता है, तो वह मैच होने वाली वैल्यू को डीस्ट्रक्चर कर सकता है. इसके लिए, वह वैल्यू से डेटा निकालकर उसे लोकल वैरिएबल से बाइंड करता है.

रिकॉर्ड को तोड़ने के लिए, Antigravity को प्रॉम्प्ट दें

Antigravity में यह प्रॉम्प्ट भेजें:

Refactor `DocumentScreen.build` in `lib/main.dart` to destructure `document.metadata` directly into local `title` and `modified` variables using the record pattern shorthand `final (title, :modified) = document.metadata;`, and use `title` and `modified` in the `AppBar` and body `Text` widgets.

जनरेट किए गए कोड को समझना

किसी रिकॉर्ड को लोकल वैरिएबल में डिस्ट्रक्चर करना

रिकॉर्ड को किसी अस्थायी वैरिएबल में सेव करने और $1 और .modified को पढ़ने के बजाय, आप पैटर्न वैरिएबल डिक्लेरेशन को शुरू कर सकते हैं:

  @override
  Widget build(BuildContext context) {
    final (title, :modified) = document.metadata;

    return Scaffold(
      appBar: AppBar(title: Text(title)),
      body: Column(children: [Center(child: Text('Last modified $modified'))]),
    );
  }

रिकॉर्ड पैटर्न (title, :modified) (जो (title, modified: modified) का शॉर्टहैंड है) में दो वैरिएबल पैटर्न शामिल हैं. ये metadata से मिले रिकॉर्ड के फ़ील्ड से मैच करते हैं:

  • एक्सप्रेशन, पैटर्न से मैच करता है. इसकी वजह यह है कि नतीजे में दो फ़ील्ड वाला एक रिकॉर्ड मिलता है. इनमें से एक फ़ील्ड पोज़िशनल है और दूसरे का नाम modified है.
  • मैच होने की वजह से, वैरिएबल डिक्लेरेशन पैटर्न, एक्सप्रेशन को डिस्ट्रक्चर करता है. साथ ही, उसकी वैल्यू को ऐक्सेस करता है और उन्हें एक ही टाइप और नाम वाले नए लोकल वैरिएबल से बाइंड करता है: String title और DateTime modified.
  • जब नाम वाले फ़ील्ड का नाम और उसे भरने वाले वैरिएबल का नाम एक जैसा हो, तो :modified को modified: modified के शॉर्टहैंड के तौर पर इस्तेमाल किया जाता है. अगर आपको किसी दूसरे नाम वाला लोकल वैरिएबल चाहिए, तो modified: localModified लिखें.

ऐप्लिकेशन को चलाना और टेस्ट करना

ऐप्लिकेशन को हॉट रीलोड करें, ताकि यह पुष्टि की जा सके कि नतीजा पिछले चरण जैसा ही है. अब कोड को ज़्यादा छोटा और आसानी से पढ़ा जा सकने वाला बनाया गया है.

6. डेटा एक्सट्रैक्ट करने के लिए पैटर्न का इस्तेमाल करना

कुछ मामलों में, पैटर्न सिर्फ़ मैच और डिस्ट्रक्चर नहीं करते. वे इस बात पर भी फ़ैसला ले सकते हैं कि कोड क्या करता है. यह फ़ैसला इस आधार पर लिया जाता है कि पैटर्न मैच होता है या नहीं. इन्हें रिफ़्यूटेबल पैटर्न कहा जाता है.

पिछले चरण में इस्तेमाल किया गया वैरिएबल डिक्लेरेशन पैटर्न, इरिफ़्यूटेबल पैटर्न है: वैल्यू, पैटर्न से मैच होनी चाहिए. ऐसा न होने पर, कंपाइल के समय गड़बड़ी होगी और डिस्ट्रक्चरिंग नहीं होगी. ठीक उसी तरह जैसे किसी वैरिएबल को किसी दूसरे टाइप की वैल्यू असाइन नहीं की जा सकती.

दूसरी ओर, रिफ़्यूटेबल पैटर्न का इस्तेमाल कंट्रोल फ़्लो के संदर्भों में किया जाता है:

  • उन्हें उम्मीद है कि तुलना की जाने वाली कुछ वैल्यू मैच नहीं होंगी.
  • इनका मकसद, वैल्यू मैच होने या न होने के आधार पर, कंट्रोल फ़्लो पर असर डालना होता है.
  • अगर वे मैच नहीं होते हैं, तो वे गड़बड़ी के साथ एग्ज़ीक्यूशन में रुकावट नहीं डालते. वे बस अगले स्टेटमेंट या ब्रांच पर चले जाते हैं.
  • वे वैरिएबल को डिस्ट्रक्चर और बाइंड कर सकते हैं. ये वैरिएबल सिर्फ़ उस ब्रांच में इस्तेमाल किए जा सकते हैं जहां वे मैच करते हैं.

Antigravity को मैप पैटर्न के साथ मेटाडेटा पार्स करने के लिए कहें

Antigravity में यह प्रॉम्प्ट भेजें:

Update the `metadata` getter in `lib/data.dart` to read and validate the JSON structure using an `if-case` map pattern (`if (_json case {'metadata': {'title': String title, 'modified': String localModified}})`) that returns `(title, modified: DateTime.parse(localModified))` and throws a `FormatException('Unexpected JSON')` otherwise.

जनरेट किए गए कोड को समझना

मैन्युअल JSON वैलिडेशन और मैप पैटर्न की तुलना करना

पैटर्न मैचिंग के बिना, _json से नेस्ट की गई वैल्यू को पढ़ने और उनकी पुष्टि करने के लिए, नेस्ट की गई कई जांचों और साफ़ तौर पर टाइप कास्ट की ज़रूरत होती है:

  (String, {DateTime modified}) get metadata {
    if (_json.containsKey('metadata')) {
      final metadataJson = _json['metadata'];
      if (metadataJson is Map) {
        final title = metadataJson['title'] as String;
        final localModified = DateTime.parse(
          metadataJson['modified'] as String,
        );
        return (title, modified: localModified);
      }
    }
    throw const FormatException('Unexpected JSON');
  }

if-case स्टेटमेंट (Dart 3 में पेश किया गया) में, मैप पैटर्न का इस्तेमाल करके, यह पुष्टि की जा सकती है कि JSON का स्ट्रक्चर सही है या नहीं. साथ ही, एक ही चरण में वैल्यू निकाली जा सकती हैं:

  (String, {DateTime modified}) get metadata {
    if (_json case {
      'metadata': {'title': String title, 'modified': String localModified},
    }) {
      return (title, modified: DateTime.parse(localModified));
    } else {
      throw const FormatException('Unexpected JSON');
    }
  }

case का मुख्य हिस्सा सिर्फ़ तब लागू होता है, जब मैप पैटर्न _json में मौजूद डेटा से मैच करता हो. इस पैटर्न से यह पुष्टि होती है कि:

  • _json, Map टाइप का है और यह null नहीं है.
  • _json में 'metadata' कुंजी है.
  • _json['metadata'], नॉन-नल Map टाइप भी है.
  • _json['metadata'] में 'title' और 'modified' कुंजियां शामिल हैं.
  • title और localModified, String की ऐसी वैल्यू हैं जो शून्य नहीं हैं.

अगर वैल्यू इनमें से किसी भी शर्त से मैच नहीं होती है, तो पैटर्न मैच नहीं होता और एक्ज़ीक्यूशन else क्लॉज़ पर चला जाता है. अगर मैच हो जाता है, तो पैटर्न, मैप से title और modified स्ट्रिंग को अलग कर देता है और उन्हें नए लोकल वैरिएबल से बाइंड कर देता है.

पैटर्न की पूरी सूची देखने के लिए, dart.dev पर पैटर्न से जुड़ा दस्तावेज़ देखें.

ऐप्लिकेशन को चलाना और टेस्ट करना

ऐप्लिकेशन को हॉट रीलोड करें. अब Last modified टाइमस्टैंप, DateTime.now() के बजाय documentJson से "2023-05-10" दिखाता है. साथ ही, _json पर unused_field चेतावनी नहीं दिखती.

7. ऐप्लिकेशन को ज़्यादा पैटर्न के लिए तैयार करना

अब तक, आपने JSON डेटा के metadata हिस्से को हैंडल किया है. इस चरण में, आपको lib/data.dart में Block क्लास और getBlocks() मेथड जोड़ना होगा. इससे documentJson से blocks सूची को पार्स किया जा सकेगा, ताकि इसे आपके यूज़र इंटरफ़ेस (यूआई) में रेंडर किया जा सके.

Antigravity को blocks सूची पार्स करने के लिए कहें

Antigravity में यह प्रॉम्प्ट भेजें:

In `lib/data.dart`, add a `Block` class with `final String type` and `final String text` fields and a `factory Block.fromJson(Map<String, dynamic> json)` constructor that uses an `if-case` map pattern (`{'type': final type, 'text': final text}`) to return a `Block` or throw a `FormatException('Unexpected JSON format')`. Then add a `List<Block> getBlocks()` method to `Document` that matches `_json` against `{'blocks': List blocksJson}` and returns `[for (final blockJson in blocksJson) Block.fromJson(blockJson)]` (or throws a `FormatException('Unexpected JSON format')`).

जनरेट किए गए कोड को समझना

मैप पैटर्न (Block.fromJson) में अतिरिक्त कुंजियों को अनदेखा किया जा रहा है

lib/data.dart में, Block.fromJson() फ़ैक्ट्री कंस्ट्रक्टर, मैप पैटर्न के साथ if-case स्टेटमेंट का इस्तेमाल करता है, ताकि 'type' और 'text' को निकाला जा सके:

class Block {
  final String type;
  final String text;
  Block(this.type, this.text);

  factory Block.fromJson(Map<String, dynamic> json) {
    if (json case {'type': final type, 'text': final text}) {
      return Block(type, text);
    } else {
      throw const FormatException('Unexpected JSON format');
    }
  }
}

ध्यान दें कि documentJson ("type": "checkbox") के तीसरे ब्लॉक में, "checked": false कुंजी भी शामिल है. इसके बारे में पैटर्न में नहीं बताया गया है. मैप पैटर्न तब भी मैच होते हैं, जब मैप में ऐसी अतिरिक्त कुंजियां हों जो पैटर्न में शामिल नहीं हैं. ये आपकी तय की गई कुंजियों की पुष्टि करते हैं और उन्हें निकालते हैं. साथ ही, मैप में मौजूद किसी भी अतिरिक्त एंट्री को अनदेखा करते हैं.

Document.getBlocks में सूची को एक्सट्रैक्ट किया जा रहा है

Document में, getBlocks() तरीका यह पुष्टि करता है कि _json में 'blocks' सूची है और List बनाता है:

  List<Block> getBlocks() {
    if (_json case {'blocks': List blocksJson}) {
      return [for (final blockJson in blocksJson) Block.fromJson(blockJson)];
    } else {
      throw const FormatException('Unexpected JSON format');
    }
  }

if-case स्टेटमेंट से यह पुष्टि होती है कि _json['blocks'] एक List है और इसे blocksJson से बाइंड करता है. पैटर्न के बिना, आपको साफ़ तौर पर कास्ट या toList() की ज़रूरत होगी. लिस्ट लिटरल के अंदर, कलेक्शन for, blocksJson पर बार-बार लागू होता है, ताकि Block ऑब्जेक्ट की सूची बनाई जा सके.

ऐप्लिकेशन को चलाना और टेस्ट करना

ऐप्लिकेशन को हॉट रीलोड करें, ताकि यह पुष्टि की जा सके कि ऐनालाइज़र या रनटाइम से जुड़ी कोई गड़बड़ी न हो. अगले चरण में, पार्स किए गए Block आइटम स्क्रीन पर रेंडर किए जाएंगे.

8. दस्तावेज़ दिखाने के लिए पैटर्न का इस्तेमाल करना

आपने JSON डेटा को डिस्ट्रक्चर और फिर से कंपोज़ करने के लिए, if-case स्टेटमेंट और रिफ़्यूटेबल पैटर्न का इस्तेमाल किया है. अब आपको switch स्टेटमेंट पर, खंडन किए जा सकने वाले पैटर्न लागू करने होंगे, ताकि lib/main.dart में हर Block को स्टाइल और रेंडर किया जा सके.

दस्तावेज़ के ब्लॉक रेंडर करने के लिए, Antigravity को प्रॉम्प्ट देना

Antigravity में यह प्रॉम्प्ट भेजें:

In `lib/main.dart`, create a `BlockWidget` `StatelessWidget` that takes a `required Block block` and uses a `switch` statement on `block.type` to assign `textStyle` (`displayMedium` for `'h1'`, `bodyMedium` for `'p' || 'checkbox'`, and `bodySmall` for the wildcard `_`), rendering `Text(block.text, style: textStyle)` inside an 8px-margin `Container`. Then update `DocumentScreen.build` to call `document.getBlocks()` and display `'Last modified: $modified'` above an `Expanded` `ListView.builder` that renders a `BlockWidget` for each block.

जनरेट किए गए कोड को समझना

switch स्टेटमेंट में पैटर्न मैचिंग

lib/main.dart में, BlockWidget.build ने तीन पैटर्न वाली सुविधाओं का इस्तेमाल करके, block.type को चालू किया:

class BlockWidget extends StatelessWidget {
  final Block block;

  const BlockWidget({required this.block, super.key});

  @override
  Widget build(BuildContext context) {
    TextStyle? textStyle;
    switch (block.type) {
      case 'h1':
        textStyle = Theme.of(context).textTheme.displayMedium;
      case 'p' || 'checkbox':
        textStyle = Theme.of(context).textTheme.bodyMedium;
      case _:
        textStyle = Theme.of(context).textTheme.bodySmall;
    }

    return Container(
      margin: const EdgeInsets.all(8),
      child: Text(block.text, style: textStyle),
    );
  }
}
  1. कॉन्सटैंट स्ट्रिंग पैटर्न (case 'h1':): अगर block.type, कॉन्सटैंट 'h1' के बराबर है, तो यह मैच होता है.
  2. लॉजिकल-या पैटर्न (case 'p' || 'checkbox':): अगर block.type, सबपैटर्न 'p' या 'checkbox' में से किसी एक से मैच करता है, तो यह मैच करता है. (&& का इस्तेमाल करने वाले लॉजिकल-ऐंड पैटर्न भी काम करते हैं.)
  3. वाइल्डकार्ड पैटर्न (case _:): यह किसी वैरिएबल को बाइंड किए बिना, किसी भी वैल्यू से मैच करता है. switch स्टेटमेंट में, case _:, default: क्लॉज़ की तरह काम करता है. हालांकि, यह अब भी इस्तेमाल किया जा सकता है, लेकिन इसमें ज़्यादा शब्दों का इस्तेमाल होता है. साथ ही, इसका इस्तेमाल किसी भी पैटर्न कॉन्टेक्स्ट में किया जा सकता है. जैसे, दूसरे रिकॉर्ड फ़ील्ड को खारिज करने के लिए var (title, _) = document.metadata;.

DocumentScreen में ब्लॉक किए गए संपर्कों की सूची देखना

DocumentScreen.build में, document.getBlocks() को कॉल करने पर, Expanded ListView.builder पॉप्युलेट होता है. यह हर आइटम के लिए BlockWidget बनाता है:

    final (title, :modified) = document.metadata;
    final blocks = document.getBlocks();

    return Scaffold(
      appBar: AppBar(title: Text(title)),
      body: Column(
        children: [
          Text('Last modified: $modified'),
          Expanded(
            child: ListView.builder(
              itemCount: blocks.length,
              itemBuilder: (context, index) {
                return BlockWidget(block: blocks[index]);
              },
            ),
          ),
        ],
      ),
    );

ऐप्लिकेशन को चलाना और टेस्ट करना

स्क्रीन पर रेंडर किए गए documentJson के ब्लॉक देखने के लिए, ऐप्लिकेशन को हॉट रीलोड करें:

ऐप्लिकेशन में दस्तावेज़ का शीर्षक, पैराग्राफ़ टेक्स्ट, और JSON डेटा के ब्लॉक सेक्शन से Dart 3 टेक्स्ट दिख रहा है

9. स्विच एक्सप्रेशन का इस्तेमाल करना

पैटर्न की मदद से, switch और case में ज़्यादा बेहतर तरीके से काम किया जा सकता है. Dart 3 में switch expressions को शामिल किया गया है, ताकि उन्हें ज़्यादा जगहों पर इस्तेमाल किया जा सके. जैसे, वैरिएबल इनिशलाइज़र, रिटर्न स्टेटमेंट, और विजेट ट्री. ये एक्सप्रेशन, पैटर्न केस की सीरीज़ का आकलन करते हैं और सीधे तौर पर वैल्यू जनरेट करते हैं.

Antigravity को switch एक्सप्रेशन में बदलने के लिए कहें

Antigravity में यह प्रॉम्प्ट भेजें:

Refactor `BlockWidget.build` in `lib/main.dart` to replace the `switch` statement on `block.type` with a `switch` expression that assigns `textStyle` directly.

जनरेट किए गए कोड को समझना

switch एक्सप्रेशन सिंटैक्स

lib/main.dart में, BlockWidget.build अब सीधे switch एक्सप्रेशन से textStyle असाइन करता है:

  @override
  Widget build(BuildContext context) {
    final textStyle = switch (block.type) {
      'h1' => Theme.of(context).textTheme.displayMedium,
      'p' || 'checkbox' => Theme.of(context).textTheme.bodyMedium,
      _ => Theme.of(context).textTheme.bodySmall,
    };

    return Container(
      margin: const EdgeInsets.all(8),
      child: Text(block.text, style: textStyle),
    );
  }

switch एक्सप्रेशन, switch स्टेटमेंट से मिलता-जुलता दिखता है. हालांकि, सिंटैक्स में तीन अंतर होते हैं:

  • यह हर पैटर्न से पहले case कीवर्ड को हटा देता है.
  • यह हर पैटर्न को उसके एक्सप्रेशन की मुख्य जानकारी से अलग करने के लिए, : के बजाय => का इस्तेमाल करता है.
  • यह केस को कॉमा (,) से अलग करता है. साथ ही, इसका इस्तेमाल वहां किया जा सकता है जहां एक्सप्रेशन की ज़रूरत हो.

ऐप्लिकेशन को चलाना और टेस्ट करना

ऐप्लिकेशन को हॉट रीलोड करें, ताकि यह पुष्टि की जा सके कि दस्तावेज़ के ब्लॉक, अपनी उम्मीद के मुताबिक टेक्स्ट स्टाइल के साथ रेंडर होते रहें.

10. ऑब्जेक्ट पैटर्न का इस्तेमाल करना

Dart एक ऑब्जेक्ट-ओरिएंटेड भाषा है. इसके पैटर्न, Dart के सभी ऑब्जेक्ट पर लागू होते हैं. इस चरण में, आपको ऑब्जेक्ट पैटर्न से मैच करना होगा और ऑब्जेक्ट गेटर को डिस्ट्रक्चर करना होगा. साथ ही, when गार्ड क्लॉज़ को जोड़ना होगा, ताकि किसी व्यक्ति के लिए आसानी से पढ़ी जा सकने वाली रिलेटिव मॉडिफ़िकेशन डेट (जैसे, "today", "yesterday" या "2 weeks ago") दिखाई जा सके.

Antigravity को ऑब्जेक्ट पैटर्न के साथ रिलेटिव तारीखों को फ़ॉर्मैट करने के लिए प्रॉम्प्ट देना

Antigravity में यह प्रॉम्प्ट भेजें:

Add a `String formatDate(DateTime dateTime)` function in `lib/main.dart` that computes `final difference = dateTime.difference(DateTime.now())` and returns a `switch` expression matching `Duration` object patterns: `'today'` for `0` days, `'tomorrow'` for `1` day, `'yesterday'` for `-1` days, `'${days ~/ 7} weeks from now'` when `days > 7`, `'${days.abs() ~/ 7} weeks ago'` when `days < -7`, `'${days.abs()} days ago'` when `isNegative: true`, and `'$days days from now'` for any remaining `Duration(inDays: final days)`. Update `DocumentScreen.build` to format `modified` with `formatDate(modified)` and display `'Last modified: $formattedModifiedDate'`.

जनरेट किए गए कोड को समझना

Duration ऑब्जेक्ट पैटर्न की मदद से, गेटर को डिस्ट्रक्चर करना

lib/main.dart में, formatDate dateTime और DateTime.now() के बीच Duration का हिसाब लगाता है और difference को चालू करता है:

String formatDate(DateTime dateTime) {
  final today = DateTime.now();
  final difference = dateTime.difference(today);

  return switch (difference) {
    Duration(inDays: 0) => 'today',
    Duration(inDays: 1) => 'tomorrow',
    Duration(inDays: -1) => 'yesterday',
    Duration(inDays: final days) when days > 7 => '${days ~/ 7} weeks from now',
    Duration(inDays: final days) when days < -7 =>
      '${days.abs() ~/ 7} weeks ago',
    Duration(inDays: final days, isNegative: true) => '${days.abs()} days ago',
    Duration(inDays: final days) => '$days days from now',
  };
}

हालांकि, Duration(inDays: ...) एक कंस्ट्रक्टर कॉल की तरह दिखता है, लेकिन पैटर्न के संदर्भ में यह एक ऑब्जेक्ट पैटर्न है. इससे यह पुष्टि होती है कि वैल्यू Duration है. साथ ही, यह difference पर inDays और isNegative गेटर को कॉल करता है:

  • पहले तीन केस, difference.inDays से मैच करने के लिए, कॉन्स्टेंट सबपैटर्न (0, 1, और -1) का इस्तेमाल करते हैं. साथ ही, 'today', 'tomorrow' या 'yesterday' दिखाते हैं.
  • आखिरी दो केस, एक दिन से ज़्यादा की अवधि को हैंडल करते हैं. इसके लिए, inDays को final days से बाइंड किया जाता है: अगर isNegative, बूलियन कॉन्स्टेंट true से मैच करता है, तो तारीख पुरानी है ('${days.abs()} days ago'); अगर ऐसा नहीं है, तो बाकी केस पॉज़िटिव ड्यूरेशन ('$days days from now') को कैप्चर करता है.

when गार्ड क्लॉज़ की मदद से, मैच होने वाले नतीजों को फ़िल्टर करना

सात दिनों से ज़्यादा की अवधि को हफ़्तों के तौर पर फ़ॉर्मैट करने के लिए, बीच के दो मामलों में गार्ड क्लॉज़ जोड़े जाते हैं:

    Duration(inDays: final days) when days > 7 => '${days ~/ 7} weeks from now',
    Duration(inDays: final days) when days < -7 =>
      '${days.abs() ~/ 7} weeks ago',
  • गार्ड क्लॉज़, केस पैटर्न के बाद when कीवर्ड का इस्तेमाल करता है. इसका इस्तेमाल if-case स्टेटमेंट, switch स्टेटमेंट, और switch एक्सप्रेशन में किया जा सकता है.
  • यह पैटर्न मैच होने और उसके वैरिएबल (days) बाइंड होने के बाद, किसी भी बूलियन कंडीशन का आकलन करता है.
  • अगर गार्ड एक्सप्रेशन की वैल्यू false है, तो पैटर्न को अमान्य माना जाता है. साथ ही, एक्ज़ीक्यूशन switch से बाहर निकलने के बजाय, अगले केस पर चला जाता है.

ऐप्लिकेशन को चलाना और टेस्ट करना

DocumentScreen में, बदलाव की तारीख को फ़ॉर्मैट करके देखने के लिए, ऐप्लिकेशन को हॉट रीलोड करें. "Last modified: 2 weeks ago" देखने के लिए, documentJson में "modified" को दो हफ़्ते पहले की तारीख में बदलकर देखें:

formatDate फ़ंक्शन का इस्तेमाल करके, बदलाव की तारीख दिखाने वाला ऐप्लिकेशन

11. पूरी तरह से स्विच करने के लिए, क्लास को सील करना

ध्यान दें कि पिछले चरण में formatDate को आखिर में वाइल्डकार्ड (_) केस की ज़रूरत नहीं थी. इसकी वजह यह है कि Duration(inDays: final days), Duration की हर संभावित वैल्यू को शामिल करता है. जब switch में मौजूद हर संभावित वैल्यू को हैंडल किया जाता है, तो इसे एग्ज़ॉस्टिव स्विच कहा जाता है.

Dart 3 में, sealed क्लास मॉडिफ़ायर, क्लास की हैरारकी के लिए एग्ज़ॉस्टिवनेस चेकिंग को एक्सटेंड करता है. इस आखिरी चरण में, Block को तीन सबक्लास (HeaderBlock, ParagraphBlock, और CheckboxBlock) वाली sealed सुपरक्लास में फिर से फ़ैक्टर किया जाएगा. साथ ही, हर ब्लॉक टाइप को रेंडर करने के लिए, BlockWidget में पूरी जानकारी देने वाले switch एक्सप्रेशन का इस्तेमाल किया जाएगा. इसमें CheckboxBlock के लिए इंटरैक्टिव Checkbox लाइन भी शामिल है.

Antigravity को Block को सील करने और सभी ब्लॉक सब-टाइप को रेंडर करने के लिए प्रॉम्प्ट दें

Antigravity में यह प्रॉम्प्ट भेजें:

In `lib/data.dart`, refactor `Block` into a `sealed class Block` with three subclasses (`HeaderBlock(this.text)`, `ParagraphBlock(this.text)`, and `CheckboxBlock(this.text, this.isChecked)`) and replace `Block.fromJson` (`Map<String, Object?> json`) with a `switch` expression matching map patterns for `'h1'`, `'p'`, and `'checkbox'`. Then update `BlockWidget.build` in `lib/main.dart` to use an exhaustive `switch (block)` expression directly as the `Container`'s `child`, destructuring `HeaderBlock(:final text)`, `ParagraphBlock(:final text)`, and `CheckboxBlock(:final text, :final isChecked)` (rendering a `Row` with a `Checkbox` and `Text` for `CheckboxBlock`).

जनरेट किए गए कोड को समझना

lib/data.dart में sealed क्लास हैरारकी को मॉडल करना

lib/data.dart में, Block को sealed क्लास मॉडिफ़ायर के साथ मार्क किया गया है. साथ ही, इसे HeaderBlock, ParagraphBlock, और CheckboxBlock ने एक्सटेंड किया है:

sealed class Block {
  Block();

  factory Block.fromJson(Map<String, Object?> json) {
    return switch (json) {
      {'type': 'h1', 'text': String text} => HeaderBlock(text),
      {'type': 'p', 'text': String text} => ParagraphBlock(text),
      {'type': 'checkbox', 'text': String text, 'checked': bool checked} =>
        CheckboxBlock(text, checked),
      _ => throw const FormatException('Unexpected JSON format'),
    };
  }
}

class HeaderBlock extends Block {
  final String text;
  HeaderBlock(this.text);
}

class ParagraphBlock extends Block {
  final String text;
  ParagraphBlock(this.text);
}

class CheckboxBlock extends Block {
  final String text;
  final bool isChecked;
  CheckboxBlock(this.text, this.isChecked);
}

sealed कीवर्ड का मतलब है कि Block को सिर्फ़ उसी लाइब्रेरी में एक्सटेंड या लागू किया जा सकता है (lib/data.dart). Dart ऐनलाइज़र को Block के लिए, डायरेक्ट सब-टाइप के पूरे और क्लोज़्ड सेट के बारे में पता होता है. इसलिए, यह पुष्टि कर सकता है कि Block इंस्टेंस पर मौजूद कोई भी switch, हर सब-टाइप को हैंडल करता है या नहीं.

BlockWidget में ऑब्जेक्ट-पैटर्न स्विचिंग की सुविधा

lib/main.dart में, BlockWidget.build सीधे तौर पर switch (block) एक्सप्रेशन को Container की child प्रॉपर्टी में पास करता है. यह ऑब्जेक्ट पैटर्न के साथ हर सबक्लास से मैच करता है और :final शॉर्टहैंड का इस्तेमाल करके इसके फ़ील्ड को डिस्ट्रक्चर करता है:

class BlockWidget extends StatelessWidget {
  final Block block;

  const BlockWidget({required this.block, super.key});

  @override
  Widget build(BuildContext context) {
    return Container(
      margin: const EdgeInsets.all(8),
      child: switch (block) {
        HeaderBlock(:final text) => Text(
          text,
          style: Theme.of(context).textTheme.displayMedium,
        ),
        ParagraphBlock(:final text) => Text(text),
        CheckboxBlock(:final text, :final isChecked) => Row(
          children: [
            Checkbox(value: isChecked, onChanged: (_) {}),
            Text(text),
          ],
        ),
      },
    );
  }
}

ऐप्लिकेशन को चलाना और टेस्ट करना

ऐप्लिकेशन को हॉट रीलोड करें, ताकि पहली बार Material Checkbox विजेट के साथ रेंडर किया गया चेकबॉक्स ब्लॉक देखा जा सके:

ऐप्लिकेशन में दस्तावेज़ का शीर्षक, पैराग्राफ़ का टेक्स्ट, और Dart 3 के बारे में जानें चेकबॉक्स दिख रहा है. इस चेकबॉक्स पर सही का निशान नहीं लगा है

12. बधाई हो

बधाई हो! आपने Google Antigravity के साथ मिलकर, Flutter दस्तावेज़ व्यूअर बनाया. इसमें Dart 3 के रिकॉर्ड, पैटर्न, बेहतर switch एक्सप्रेशन, और sealed क्लास का इस्तेमाल किया गया.

आपने क्या बनाया है

  • रिकॉर्ड के साथ कई वैल्यू रिटर्न करना: Document.metadata से पोज़िशनल और नाम वाले फ़ील्ड ((String, {DateTime modified})) रिटर्न किए गए और उन्हें final (title, :modified) = document.metadata; के साथ लोकल वैरिएबल में साफ़ तौर पर डिस्ट्रक्चर किया गया.
  • JSON की सुरक्षित पुष्टि और डेटा निकालना: टाइप की पुष्टि करने, कुंजियों की जांच करने, और एक ही एक्सप्रेशन में वैल्यू निकालने के लिए, नेस्ट किए गए मैप पैटर्न के साथ if-case स्टेटमेंट और switch एक्सप्रेशन का इस्तेमाल किया गया है.
  • एक्सप्रेसिव यूज़र इंटरफ़ेस (यूआई) ब्रांचिंग: रिलेटिव टाइमस्टैंप को फ़ॉर्मैट करने और इनलाइन विजेट बनाने के लिए, switch एक्सप्रेशन, ऑब्जेक्ट पैटर्न (Duration(inDays: final days)), और when गार्ड क्लॉज़ का इस्तेमाल किया गया.
  • कंपाइल के समय पूरी तरह से जांच करना: दस्तावेज़ के कॉन्टेंट ब्लॉक को sealed class Block हैरारकी (HeaderBlock, ParagraphBlock, और CheckboxBlock) के तौर पर मॉडल किया गया है, ताकि कंपाइलर यह पक्का कर सके कि हर ब्लॉक टाइप रेंडर हो.

आगे क्या करना है?

ज़्यादा पैटर्न टाइप, रिकॉर्ड की सुविधाएं, और क्लास मॉडिफ़ायर के बारे में जानने के लिए, Dart का आधिकारिक दस्तावेज़ देखें:

रेफ़रंस के लिए दस्तावेज़

इस कोडलैब में शामिल हर सुविधा के लिए, भाषा की खास जानकारी पाने के लिए, Dart भाषा के डिज़ाइन से जुड़े ओरिजनल दस्तावेज़ देखें: