Bazel ट्यूटोरियल: C प्रोजेक्ट बनाएं

किसी समस्या की शिकायत करें सोर्स देखें रात · 7.3 · 7.2 · 7.1 · 7.0 · 6.5

परिचय

क्या Babel के लिए नए हैं? आप सही जगह पर हैं. Family Link की मदद से, बेज़ल को इस्तेमाल करने का आसान तरीका बताया गया है. इस ट्यूटोरियल में मुख्य शब्दों के बारे में बताया गया है का इस्तेमाल बेज़ल के हिसाब से किया गया है. साथ ही, ये आपको बेज़ल की बुनियादी बातों के बारे में जानकारी देती हैं वर्कफ़्लो. इसमें आपको अपनी ज़रूरत के लिए तीन टूल मिलेंगे. इसके बाद, आपको तीन चरण पूरे करने होंगे बढ़ती जटिलता के प्रोजेक्ट हैं और जानें कि वे कैसे और क्यों ज़्यादा जटिल होते हैं.

हालांकि Basel एक बिल्ड सिस्टम है, जो कई भाषाओं में वीडियो बनाने की सुविधा देता है. इस ट्यूटोरियल में C प्रोजेक्ट का इस्तेमाल उदाहरण के तौर पर किया गया है. के सामान्य दिशा-निर्देश और फ़्लो उपलब्ध कराता है, जो ज़्यादातर भाषाओं पर लागू होते हैं.

पूरा होने का अनुमानित समय: 30 मिनट.

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

अगर आपने अभी तक Basel का इस्तेमाल किया जा रहा है, तो उन्हें इंस्टॉल करने से शुरुआत करें पहले से मौजूद है. यह ट्यूटोरियल स्रोत नियंत्रण के लिए Git का इस्तेमाल करता है, इसलिए सबसे अच्छे नतीजों के लिए इंस्टॉल करें Git भी.

इसके बाद, नीचे दिए गए निर्देशों का पालन करें:

git clone https://github.com/bazelbuild/examples

इस ट्यूटोरियल के लिए सैंपल प्रोजेक्ट, examples/cpp-tutorial में है डायरेक्ट्री.

देखें कि इसे कैसे बनाया गया है:

examples
└── cpp-tutorial
    ├──stage1
    │  ├── main
    │  │   ├── BUILD
    │  │   └── hello-world.cc
    │  └── MODULE.bazel
    ├──stage2
    │  ├── main
    │  │   ├── BUILD
    │  │   ├── hello-world.cc
    │  │   ├── hello-greet.cc
    │  │   └── hello-greet.h
    │  └── MODULE.bazel
    └──stage3
       ├── main
       │   ├── BUILD
       │   ├── hello-world.cc
       │   ├── hello-greet.cc
       │   └── hello-greet.h
       ├── lib
       │   ├── BUILD
       │   ├── hello-time.cc
       │   └── hello-time.h
       └── MODULE.bazel

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

सारांश: परिचय

Basel (और Git) को इंस्टॉल करके और इस ट्यूटोरियल के लिए रिपॉज़िटरी की क्लोनिंग करके, आप बेज़ल के साथ आपके पहले बिल्ड की बुनियाद रखी है. अगले आइटम पर जाएं सेक्शन में कुछ शर्तें जोड़ें और अपने workspace.

शुरू करना

प्रोजेक्ट बनाने से पहले, आपको उसका फ़ाइल फ़ोल्डर सेट अप करना होगा. फ़ाइल फ़ोल्डर एक डायरेक्ट्री है, जिसमें आपके प्रोजेक्ट की सोर्स फ़ाइलें और Basel के बिल्ड आउटपुट मौजूद होते हैं. इसमें ये अहम फ़ाइलें भी शामिल होती हैं:

  • MODULE.bazel फ़ाइल, जो डायरेक्ट्री और उसके कॉन्टेंट की पहचान इस तौर पर करती है बेज़ल वर्कस्पेस और प्रोजेक्ट की डायरेक्ट्री के मूल में मौजूद है स्ट्रक्चर. बाहरी डिपेंडेंसी यहां भी तय की जाती है.
  • एक या एक से ज़्यादा BUILD फ़ाइलें भेजीं, जो बेज़ल को बताती हैं प्रोजेक्ट के अलग-अलग हिस्सों को कैसे बनाया जाए. इसमें एक डायरेक्ट्री है: जिस फ़ाइल फ़ोल्डर में BUILD फ़ाइल है वह package. (पैकेज के बारे में ज़्यादा जानकारी देखें.)

आने वाले समय में, किसी डायरेक्ट्री को Baze Workspace के तौर पर इस्तेमाल करने के लिए, उस डायरेक्ट्री में MODULE.bazel नाम की खाली फ़ाइल है. इसके उद्देश्यों के लिए ट्यूटोरियल, एक MODULE.bazel फ़ाइल पहले से ही हर स्टेज में मौजूद है.

BUILD फ़ाइल को समझें

BUILD फ़ाइल में Basel के लिए कई अलग-अलग तरह के निर्देश होते हैं. हर BUILD फ़ाइल में कम से कम एक फ़ाइल होनी चाहिए नियम का इस्तेमाल निर्देशों के सेट के रूप में करता है, जो बेज़ल को बताता है कि आपकी पसंद के आउटपुट कैसे बनाए जाएं, जैसे कि एक्ज़ीक्यूटेबल बाइनरी इस्तेमाल किए जा सकते हैं. BUILD फ़ाइल में बिल्ड नियम के हर इंस्टेंस को टारगेट और किसी खास कीवर्ड पर ले जाता है सोर्स फ़ाइलों का सेट और डिपेंडेंसी. टारगेट यह कर सकता है अन्य टारगेट की भी ओर इशारा करता है.

cpp-tutorial/stage1/main डायरेक्ट्री में मौजूद BUILD फ़ाइल पर एक नज़र डालें:

cc_binary(
    name = "hello-world",
    srcs = ["hello-world.cc"],
)

हमारे उदाहरण में, hello-world टारगेट, Baze के बिल्ट-इन को इंस्टैंशिएट करता है cc_binary नियम. नियम बेज़ल को अपने समस्या से जुड़ी एक्ज़ीक्यूटेबल बाइनरी बनाने का निर्देश देता है, hello-world.cc> किसी डिपेंडेंसी के बिना सोर्स फ़ाइल का इस्तेमाल करना.

खास जानकारी: शुरू करना

अब आपको कुछ मुख्य शब्दों के बारे में पता है और आपको और आम तौर पर बेज़ल. अगले सेक्शन में, आपको अपने समाचार संगठन के लिए, प्रोजेक्ट का पहला चरण.

पहला चरण: एक ही टारगेट, एक पैकेज

यह प्रोजेक्ट का पहला हिस्सा बनाने का समय है. विज़ुअल रेफ़रंस के लिए, प्रोजेक्ट के पहले चरण के सेक्शन का स्ट्रक्चर यह है:

examples
└── cpp-tutorial
    └──stage1
       ├── main
       │   ├── BUILD
       │   └── hello-world.cc
       └── MODULE.bazel

cpp-tutorial/stage1 डायरेक्ट्री पर ले जाने के लिए, नीचे दिया गया तरीका अपनाएं:

cd cpp-tutorial/stage1

इसके बाद, चलाएं:

bazel build //main:hello-world

टारगेट लेबल में, //main: वाला हिस्सा, BUILD फ़ाइल की जगह होता है फ़ाइल फ़ोल्डर के रूट के मुताबिक है और hello-world इसमें टारगेट नाम है BUILD फ़ाइल.

बेज़ल कुछ ऐसा बनाते हैं जो कुछ ऐसा दिखता है:

INFO: Found 1 target...
Target //main:hello-world up-to-date:
  bazel-bin/main/hello-world
INFO: Elapsed time: 2.267s, Critical Path: 0.25s

आपने अभी-अभी अपना पहला Basel टारगेट बनाया है. Basel के प्रॉडक्ट की वजह से, bazel-bin डायरेक्ट्री, फ़ाइल फ़ोल्डर के रूट में है.

अब अपनी हाल ही में बनाई गई बाइनरी की जांच करें. इससे:

bazel-bin/main/hello-world

इससे "Hello world" प्रिंट हो जाता है दिखाई देगा.

यहां पहले चरण का डिपेंडेंसी ग्राफ़ दिया गया है:

हैलो-वर्ल्ड के लिए डिपेंडेंसी ग्राफ़, एक ही सोर्स के साथ एक टारगेट दिखाता है फ़ाइल से लिए जाते हैं.

खास जानकारी: पहला चरण

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

दूसरा चरण: कई बिल्ड टारगेट

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

यह वह डायरेक्ट्री है जिसके साथ दूसरे चरण के लिए काम किया जा रहा है:

    ├──stage2
    │  ├── main
    │  │   ├── BUILD
    │  │   ├── hello-world.cc
    │  │   ├── hello-greet.cc
    │  │   └── hello-greet.h
    │  └── MODULE.bazel

cpp-tutorial/stage2/main डायरेक्ट्री में मौजूद BUILD फ़ाइल पर एक नज़र डालें:

cc_library(
    name = "hello-greet",
    srcs = ["hello-greet.cc"],
    hdrs = ["hello-greet.h"],
)

cc_binary(
    name = "hello-world",
    srcs = ["hello-world.cc"],
    deps = [
        ":hello-greet",
    ],
)

इस BUILD फ़ाइल के साथ, Baज़ेन ने पहले hello-greet लाइब्रेरी बनाई (इसका इस्तेमाल करके बेज़ेल का बिल्ट-इन cc_library नियम), फिर hello-world बाइनरी. hello-world टारगेट में deps एट्रिब्यूट से यह पता चलता है बेज़ल बताना कि hello-world को बनाने के लिए hello-greet लाइब्रेरी की ज़रूरत है बाइनरी.

प्रोजेक्ट का नया वर्शन बनाने से पहले, आपको डायरेक्ट्री में, इसे चलाकर cpp-tutorial/stage2 डायरेक्ट्री पर स्विच किया जा सकता है:

cd ../stage2

अब इस जाने-पहचाने निर्देश का इस्तेमाल करके नई बाइनरी बनाई जा सकती है:

bazel build //main:hello-world

एक बार फिर, बेज़ल कुछ इस तरह पेश करते हैं:

INFO: Found 1 target...
Target //main:hello-world up-to-date:
  bazel-bin/main/hello-world
INFO: Elapsed time: 2.399s, Critical Path: 0.30s

अब अपनी हाल ही में बनाई गई बाइनरी की जांच की जा सकती है. इससे, एक और "Hello world" नतीजा मिलता है:

bazel-bin/main/hello-world

अगर अब hello-greet.cc में बदलाव किया जाता है और प्रोजेक्ट को फिर से बनाया जाता है, तो सिर्फ़ Basel का इस्तेमाल किया जाएगा उस फ़ाइल को फिर से कंपाइल करता है.

डिपेंडेंसी ग्राफ़ में देखा जा सकता है कि hello-world, hello-greet नाम का अतिरिक्त इनपुट:

`हैलो-वर्ल्ड` के लिए डिपेंडेंसी ग्राफ़, इसके बाद डिपेंडेंसी में हुए बदलाव दिखाता है फ़ाइल में बदलाव किया गया है.

खास जानकारी: दूसरा चरण

अब आपने दो टारगेट के साथ प्रोजेक्ट बना लिया है. hello-world टारगेट बनाता है और एक अन्य टारगेट (//main:hello-greet) पर निर्भर है, जो दो अतिरिक्त सोर्स फ़ाइलें बनाता है. अगले सेक्शन में, इसे और बेहतर बनाएं और एक अन्य पैकेज जोड़ें.

तीसरा चरण: एक से ज़्यादा पैकेज

यह अगला चरण, Android स्मार्टवॉच के लिए Android घड़ी के विजेट पर एक और लेयर जोड़ता है. साथ ही, Android TV की मदद से एक प्रोजेक्ट तैयार करता है एक से ज़्यादा पैकेज शामिल हैं. एक नज़र में cpp-tutorial/stage3 डायरेक्ट्री:

└──stage3
   ├── main
   │   ├── BUILD
   │   ├── hello-world.cc
   │   ├── hello-greet.cc
   │   └── hello-greet.h
   ├── lib
   │   ├── BUILD
   │   ├── hello-time.cc
   │   └── hello-time.h
   └── MODULE.bazel

देखा जा सकता है कि अब दो सब-डायरेक्ट्री हैं और हर डायरेक्ट्री में एक BUILD है फ़ाइल से लिए जाते हैं. इसलिए, बैज के लिए, अब फ़ाइल फ़ोल्डर में दो पैकेज शामिल हैं: lib और main.

lib/BUILD फ़ाइल पर एक नज़र डालें:

cc_library(
    name = "hello-time",
    srcs = ["hello-time.cc"],
    hdrs = ["hello-time.h"],
    visibility = ["//main:__pkg__"],
)

और main/BUILD फ़ाइल पर:

cc_library(
    name = "hello-greet",
    srcs = ["hello-greet.cc"],
    hdrs = ["hello-greet.h"],
)

cc_binary(
    name = "hello-world",
    srcs = ["hello-world.cc"],
    deps = [
        ":hello-greet",
        "//lib:hello-time",
    ],
)

मुख्य पैकेज में hello-world का टारगेट, hello-time के टारगेट पर निर्भर करता है lib पैकेज में (इसलिए लक्ष्य लेबल //lib:hello-time) - Basel को पता है इसे deps एट्रिब्यूट की मदद से इस्तेमाल किया जाता है. इसे डिपेंडेंसी में देखा जा सकता है ग्राफ़:

`हैलो-वर्ल्ड` के लिए डिपेंडेंसी ग्राफ़, दिखाता है कि मुख्य पैकेज में टारगेट `लिब` में लक्ष्य पर निर्भर करता है पैकेज.

कैंपेन को कामयाब बनाने के लिए, lib/BUILD में //lib:hello-time का टारगेट बनाएं यह एट्रिब्यूट, main/BUILD में मौजूद टारगेट को साफ़ तौर पर दिखता है. ऐसा इसलिए है क्योंकि डिफ़ॉल्ट रूप से लक्ष्य केवल उन्हीं अन्य लक्ष्यों को दिखाई देते हैं BUILD फ़ाइल. लाइब्रेरी जैसी समस्याओं से बचने के लिए, Baze टारगेट की गई विज़िबिलिटी का इस्तेमाल करता है इसमें, लागू करने की जानकारी शामिल है जो सार्वजनिक एपीआई में लीक हो रही है.

अब प्रोजेक्ट का यह फ़ाइनल वर्शन बनाएं. cpp-tutorial/stage3 पर स्विच करें निर्देशिका को चलाकर देखें:

cd  ../stage3

एक बार फिर से, नीचे दिया गया निर्देश चलाएं:

bazel build //main:hello-world

बेज़ल कुछ ऐसा बनाते हैं जो कुछ ऐसा दिखता है:

INFO: Found 1 target...
Target //main:hello-world up-to-date:
  bazel-bin/main/hello-world
INFO: Elapsed time: 0.167s, Critical Path: 0.00s

अब आखिरी Hello world मैसेज के लिए, इस ट्यूटोरियल की आखिरी बाइनरी की जांच करें:

bazel-bin/main/hello-world

खास जानकारी: तीसरा चरण

अब आपने प्रोजेक्ट को तीन लक्ष्यों के साथ दो पैकेज के तौर पर बना लिया है और इन दोनों के बीच एक-दूसरे की निर्भरता होती है. इससे आपको आगे बढ़ने और आने वाले समय में खुद को बेहतर बनाने में मदद मिलती है प्रोजेक्ट पर काम किया. अगले सेक्शन में, जानें कि बेज़ल का सफ़र.

अगले चरण

अब आपने Basel का इस्तेमाल करके, अपना पहला बेसिक बिल्ड पूरा कर लिया है. हालांकि, यह शुरू करें. Basel के साथ सीखने के लिए, यहां कुछ और संसाधन दिए गए हैं:

बिल्डिंग बनाने के लिए शुभकामनाएं!