ការប្រៀបធៀបកម្មវិធីពិនិត្យប្រភេទ Python៖ ការសន្និដ្ឋានរបស់កុងតឺន័រទទេ

ហេតុអ្វីបានជាធុងទទេបំបែកឧបករណ៍ពិនិត្យប្រភេទ Python — និងអ្វីដែលអ្នកអាចធ្វើបានអំពីវា

ប្រព័ន្ធវាយអក្សរបន្តិចម្តងៗរបស់ Python មានភាពចាស់ទុំគួរឱ្យកត់សម្គាល់ចាប់តាំងពី PEP 484 បានណែនាំប្រភេទជំនួយក្នុងឆ្នាំ 2015។ សព្វថ្ងៃនេះ អ្នកអភិវឌ្ឍន៍រាប់លាននាក់ពឹងផ្អែកលើឧបករណ៍ពិនិត្យប្រភេទឋិតិវន្តដើម្បីចាប់កំហុស មុនពេលវាដំណើរការផលិតកម្ម។ ប៉ុន្តែ​មាន​ជ្រុង​មួយ​ដែល​គួរ​ឱ្យ​ធុញ​ទ្រាន់​មួយ​នៃ​ប្រព័ន្ធ​ប្រភេទ​ដែល​នៅ​តែ​ធ្វើ​ដំណើរ​ឡើង​សូម្បី​តែ​វិស្វករ​ដែល​មាន​បទ​ពិសោធ៖ តើ​ធុង​ទទេ​មាន​ប្រភេទ​អ្វី? នៅពេលអ្នកសរសេរ x = [] ដោយគ្មានចំណារពន្យល់ អ្នកត្រួតពិនិត្យប្រភេទរបស់អ្នកត្រូវទាយ — ហើយអ្នកត្រួតពិនិត្យផ្សេងគ្នាទាយខុសគ្នា។ ភាពខុសគ្នានេះបង្កើតបញ្ហាពិតប្រាកដសម្រាប់ក្រុមដែលរក្សាមូលដ្ឋានកូដធំ ដែលការប្តូរ ឬរួមបញ្ចូលគ្នានូវឧបករណ៍ពិនិត្យប្រភេទអាចបង្ហាញកំហុសរាប់រយដែលមិនបានរំពឹងទុកក្នុងមួយយប់។

អត្ថបទនេះពន្យល់ពីរបៀបដែលឧបករណ៍ពិនិត្យប្រភេទ Python សំខាន់ៗចំនួនបួនដូចជា mypy, pyright, pytype, និង pyre — ដោះស្រាយការសន្និដ្ឋាននៃធុងទទេ មូលហេតុដែលពួកគេមិនយល់ស្រប និងយុទ្ធសាស្ត្រជាក់ស្តែងដែលអ្នកអាចអនុវត្តដើម្បីសរសេរប្រភេទ Python សុវត្ថិភាពដោយមិនគិតពីជម្រើសឧបករណ៍របស់អ្នក។

បញ្ហាស្នូល៖ ធុងទទេមានភាពមិនច្បាស់លាស់

សូម​ពិចារណា​អំពី​បន្ទាត់​ដែល​គ្មាន​កំហុស​របស់ Python៖ លទ្ធផល = []។ តើ លទ្ធផល ជា បញ្ជី [int] ទេ? បញ្ជី[str]? បញ្ជី[dict[str, Any]]? បើគ្មានបរិបទបន្ថែមទេ ពិតជាគ្មានវិធីដើម្បីដឹងទេ។ Python runtime មិនខ្វល់ទេ — បញ្ជីគឺខុសពីធម្មជាតិ — ប៉ុន្តែអ្នកត្រួតពិនិត្យប្រភេទឋិតិវន្តត្រូវកំណត់ប្រភេទជាក់លាក់មួយទៅគ្រប់អថេរដើម្បីធ្វើការងាររបស់ពួកគេ។ វាបង្កើតភាពតានតឹងជាមូលដ្ឋានរវាងភាពបត់បែនថាមវន្តរបស់ Python និងការធានាថាការវិភាគឋិតិវន្តព្យាយាមផ្តល់។

បញ្ហាផ្សំជាមួយវចនានុក្រម និងសំណុំ។ តាមពិត {} ទទេត្រូវបានញែកជា dict មិនមែនជា សំណុំ ដែលបន្ថែមភាពមិនច្បាស់នៃវាក្យសម្ព័ន្ធនៅលើកំពូលនៃភាពមិនច្បាស់លាស់កម្រិតប្រភេទ។ និងកុងតឺន័រដែលដាក់ជាប់គ្នា — គិតថា defaultdict(list) ឬ results = {k: [] for k in keys} — រុញម៉ាស៊ីន inference ដល់ដែនកំណត់របស់វា។ ឧបករណ៍ពិនិត្យប្រភេទនីមួយៗបានបង្កើតនូវសរីរវិទ្យាផ្ទាល់ខ្លួនរបស់វា ហើយភាពខុសគ្នាគឺសំខាន់ជាងអ្នកអភិវឌ្ឍន៍ភាគច្រើនដឹង។

នៅក្នុងប្រព័ន្ធផលិតកម្មដែលកំពុងដំណើរការបន្ទុកការងារពិតប្រាកដ — ថាតើវាជា CRM គ្រប់គ្រងកំណត់ត្រាអតិថិជន ម៉ូឌុលវិក្កយបត្របង្កើតធាតុបន្ទាត់ ឬម៉ែត្រការប្រមូលផ្តុំបំពង់វិភាគ — ធុងទទេលេចឡើងជានិច្ចជាលំនាំចាប់ផ្តើម។ ការធ្វើឱ្យប្រភេទរបស់ពួកគេខុសមិនគ្រាន់តែបង្កើតការព្រមាន linter ប៉ុណ្ណោះទេ។ វា​អាច​បិទបាំង​កំហុស​ពិតប្រាកដ​ដែល​ឆ្លង​កាត់​ពេល​ដំណើរការ។

Mypy៖ ពន្យារការសន្និដ្ឋានដោយមានការពាក់ព័ន្ធណាមួយ

Mypy ដែលជាឧបករណ៍ពិនិត្យប្រភេទ Python ចាស់ជាងគេ និងត្រូវបានទទួលយកយ៉ាងទូលំទូលាយបំផុត ប្រើវិធីសាស្រ្តដែលងាយស្រួលប្រើចំពោះធុងទទេ។ នៅពេលដែលវាជួបប្រទះ x = [] នៅវិសាលភាពមុខងារ វាព្យាយាម ពន្យារការសម្រេចចិត្តប្រភេទ និងសន្និដ្ឋានប្រភេទធាតុពីការប្រើប្រាស់ជាបន្តបន្ទាប់។ ប្រសិនបើអ្នកសរសេរ x = [] តាមដោយ x.append(42) នោះ mypy នឹងសន្និដ្ឋាន list[int]។ យុទ្ធសាស្ត្រ "ចូលរួម" នេះដំណើរការល្អគួរឱ្យភ្ញាក់ផ្អើលសម្រាប់ករណីត្រង់ដែលកុងតឺន័រត្រូវបានផ្ទុកក្នុងវិសាលភាពដូចគ្នា។

ទោះជាយ៉ាងណាក៏ដោយ ឥរិយាបថរបស់ mypy ផ្លាស់ប្តូរយ៉ាងខ្លាំង អាស្រ័យលើបរិបទ និងការកំណត់ភាពតឹងរ៉ឹង។ នៅវិសាលភាពនៃម៉ូឌុល (កូដកម្រិតកំពូល) ឬនៅពេលដែលកុងតឺន័រត្រូវបានបញ្ជូនទៅកាន់មុខងារផ្សេងទៀត មុនពេលត្រូវបានបញ្ចូល នោះ mypy តែងតែត្រលប់ទៅ បញ្ជី [ណាមួយ] វិញ។ នៅក្រោមទង់ --តឹងរ៉ឹង វាបង្កឱ្យមានកំហុស ប៉ុន្តែនៅក្នុងរបៀបលំនាំដើម វាឆ្លងកាត់ដោយស្ងៀមស្ងាត់។ នេះមានន័យថាក្រុមដែលកំពុងដំណើរការ mypy ដោយគ្មានរបៀបតឹងរ៉ឹងអាចប្រមូលផ្តុំធុងរាប់សិបដែលវាយបញ្ចូលដោយប្រយោល ដែលដើរតួជាអ្នករត់គេចពីប្រព័ន្ធប្រភេទ ដោយកម្ចាត់គោលបំណងរបស់វា។

អាកប្បកិរិយាដ៏ស្រទន់ពិសេសមួយ៖ កំណែ mypy មុនដល់ 0.990 ជួនកាលអាចសន្និដ្ឋាន បញ្ជី[មិនស្គាល់] ខាងក្នុង ហើយបន្ទាប់មកពង្រីកទៅ បញ្ជី[ណាមួយ] នៅលើកិច្ចការ។ ក្រោយ 0.990 ការសន្និដ្ឋានត្រូវបានរឹតបន្តឹង ប៉ុន្តែការផ្លាស់ប្តូរនេះបានបំបែកចំនួនដ៏គួរឱ្យភ្ញាក់ផ្អើលនៃមូលដ្ឋានកូដពិភពលោកពិត ដែលបានពឹងផ្អែកលើឥរិយាបថអនុញ្ញាតដោយមិនបានដឹងពីវា។ នេះគឺជាប្រធានបទដែលកើតឡើងដដែលៗ — ការផ្លាស់ប្តូរទៅលើការសន្និដ្ឋាននៃធុងទទេគឺស្ថិតក្នុងចំណោមការអាប់ដេតកម្មវិធីពិនិត្យប្រភេទដែលរំខានបំផុត ដោយសារគំរូមានគ្រប់ទីកន្លែង។

រក្សាសិទ្ធិ៖ ការសន្និដ្ឋានយ៉ាងតឹងរឹង និងប្រភេទ "មិនស្គាល់"

Pyright ដែលបង្កើតឡើងដោយ Microsoft និងផ្តល់ថាមពលដល់ Pylance នៅក្នុង VS Code ប្រកាន់ជំហរទស្សនវិជ្ជាខុសគ្នាជាមូលដ្ឋាន។ ជាជាងដោយស្ងៀមស្ងាត់ត្រឡប់ទៅ ណាមួយ សិទ្ធិបែងចែករវាង មិនស្គាល់ (ប្រភេទដែលមិនទាន់បានកំណត់) និង ណាមួយ (ជម្រើសមិនច្បាស់លាស់នៃការត្រួតពិនិត្យប្រភេទ)។ នៅពេលអ្នកសរសេរ x = [] ក្នុងទម្រង់តឹងរ៉ឹងរបស់ pyright វាសន្និដ្ឋាន list[Unknown] ហើយរាយការណ៍ពីការវិភាគ ដោយបង្ខំអ្នកឱ្យផ្តល់ចំណារពន្យល់។

Pyright ក៏កាន់តែឆេវឆាវផងដែរអំពី ការបង្រួមក្នុងវិសាលភាព។ ប្រសិនបើអ្នកសរសេរ៖

• x = [] អមដោយ x.append("hello") — pyright infers list[str]
• x = [] អមដោយ x.append(1) បន្ទាប់មក x.append("hello") — pyright infers list[int | str]
• x = [] បានបញ្ជូនដោយផ្ទាល់ទៅមុខងារដែលរំពឹងថា បញ្ជី[int] — pyright infers list[int] from the call-site context
• x = [] ត្រឡប់​ពី​មុខងារ​ដោយ​មិន​មាន​ចំណារ​ពន្យល់​ប្រភេទ​ត្រឡប់ — pyright រាយការណ៍​អំពី​កំហុស​ជាជាង​ការ​ស្មាន

ការសន្និដ្ឋានទ្វេទិសនេះ (ប្រើទាំងការប្រើប្រាស់ជាបន្តបន្ទាប់ និងប្រភេទដែលរំពឹងទុកពីគេហទំព័រហៅទូរសព្ទ) ធ្វើឱ្យមានភាពច្បាស់លាស់គួរឱ្យកត់សម្គាល់ជាង mypy សម្រាប់ធុងទទេ។ ការដោះដូរគឺជាការនិយាយដោយពាក្យសំដី៖ ទង់ទម្រង់តឹងរ៉ឹងរបស់ pyright បង្ហាញប្រហែល 30-40% បញ្ហាបន្ថែមទៀត នៅលើមូលដ្ឋានកូដដែលមិនមានកំណត់ចំណាំធម្មតាបើប្រៀបធៀបទៅនឹងរបៀបតឹងរឹងរបស់ mypy នេះបើយោងតាមការវិភាគពីរបាយការណ៍ចំណាកស្រុកប្រភពបើកចំហជាច្រើន។ សម្រាប់ក្រុមដែលបង្កើតប្រព័ន្ធ backend ស្មុគ្រស្មាញ — និយាយថា វេទិកាដែលគ្រប់គ្រងម៉ូឌុលដែលជាប់ទាក់ទងគ្នាចំនួន 207 ដែលលាតសន្ធឹងលើ CRM ការបើកប្រាក់បៀវត្សរ៍ និងការវិភាគ — ភាពតឹងរឹងរបស់ pyright ចាប់យកភាពមិនស៊ីសង្វាក់គ្នានៃចំណុចប្រទាក់ដែលងាយនឹងសន្និដ្ឋាន។

Pytype និង Pyre៖ ផ្លូវដែលមានការធ្វើដំណើរតិចជាងមុន

ប្រភេទ pytype របស់ Google ប្រហែលជាវិធីសាស្រ្តជាក់ស្តែងបំផុត។ ជំនួសឱ្យការទាមទារចំណារពន្យល់ ឬត្រលប់ទៅ ណាមួយ pytype ប្រើ ការវិភាគកម្មវិធីទាំងមូល ដើម្បីតាមដានពីរបៀបដែលកុងតឺន័រត្រូវបានប្រើប្រាស់ឆ្លងកាត់ព្រំដែនមុខងារ។ ប្រសិនបើអ្នកបង្កើតបញ្ជីទទេនៅក្នុងមុខងារមួយ ហើយបញ្ជូនវាទៅមួយទៀតដែលបន្ថែមចំនួនគត់ នោះ pytype ជាញឹកញាប់អាចសន្និដ្ឋាន list[int] ដោយមិនមានចំណារពន្យល់អ្វីទាំងអស់។ ការសន្និដ្ឋានឆ្លងមុខងារនេះមានតម្លៃថ្លៃក្នុងការគណនា - pytype គឺយឺតជាង mypy ឬ pyright យ៉ាងខ្លាំងនៅលើ codebases ធំៗ - ប៉ុន្តែវាបង្កើតផលវិជ្ជមានមិនពិតតិចជាងនៅលើ code unnotated ។

Pytype ក៏ណែនាំគោលគំនិតនៃ "ប្រភេទផ្នែក" សម្រាប់ធុងទទេ។ [] ដែលទើបបង្កើតថ្មីទទួលបានប្រភេទផ្នែកមួយដែលត្រូវបានកែលម្អជាលំដាប់ ដោយសារអ្នកត្រួតពិនិត្យជួបប្រទះការប្រើប្រាស់កាន់តែច្រើន។ នេះ​ជា​គំនិត​ដ៏​ស្រស់​ស្អាត ប៉ុន្តែ​អាច​បង្កើត​សារ​កំហុស​ដែល​ច្របូកច្របល់​នៅពេល​ប្រភេទ​ផ្នែក​មិន​អាច​ដោះស្រាយ​បាន​ពេញលេញ ដូចជា​នៅពេល​ធុង​ទទេ​ហូរ​តាម​មុខងារ​ជាច្រើន​ដោយ​មិន​ត្រូវ​បាន​បញ្ចូល។

Meta's pyre ទន្ទឹមនឹងនោះ ខិតទៅជិតឥរិយាបថរបស់ mypy ប៉ុន្តែជាមួយនឹងលំនាំដើមតឹងជាង។ Pyre ចាត់ទុក x = [] ជា បញ្ជី [មិនស្គាល់] ហើយទាមទារចំណារពន្យល់ក្នុងបរិបទភាគច្រើន។ កន្លែងដែល pyre បែងចែកដោយខ្លួនវាផ្ទាល់គឺនៅក្នុងការគ្រប់គ្រងវចនានុក្រមទទេដែលប្រើជា kwargs ដែលជាគំរូទូទៅនៅក្នុងក្របខ័ណ្ឌគេហទំព័រ។ Pyre មានតក្កវិជ្ជាករណីពិសេសដើម្បីសន្និដ្ឋានប្រភេទវចនានុក្រមពីបរិបទអាគុយម៉ង់ពាក្យគន្លឹះ កាត់បន្ថយបន្ទុកចំណារពន្យល់ក្នុងក្របខ័ណ្ឌកូដដែលធ្ងន់។ ដោយសារកម្មវិធីបណ្តាញទំនើបភាគច្រើនពាក់ព័ន្ធនឹងការប្រើប្រាស់ធ្ងន់នៃការពន្លាវចនានុក្រមសម្រាប់ការកំណត់រចនាសម្ព័ន្ធ និងការគ្រប់គ្រងសំណើ ការអនុវត្តជាក់ស្តែងនេះផ្តល់ភាគលាភ។

ផលប៉ះពាល់លើពិភពលោកពិត៖ នៅពេលដែលការសន្និដ្ឋានខុសគ្នាត្រង់ខាំ

ភាពខុសគ្នារវាងអ្នកត្រួតពិនិត្យប្រភេទអាចហាក់ដូចជាសិក្សារហូតដល់អ្នកជួបប្រទះពួកវានៅក្នុងមូលដ្ឋានកូដផលិតកម្ម។ ពិចារណាលើគំរូទូទៅនៅក្នុងកម្មវិធីអាជីវកម្ម៖ ការចាប់ផ្ដើមរចនាសម្ព័ន្ធទិន្នន័យដែលទទួលបានការបញ្ចូលតាមលក្ខខណ្ឌ។

ធុងទទេដ៏គ្រោះថ្នាក់បំផុតមិនមែនជាទង់អ្នកត្រួតពិនិត្យប្រភេទនោះទេ ពួកវាជាឧបករណ៍ដែលឆ្លងកាត់ដោយស្ងៀមស្ងាត់ជាមួយនឹងប្រភេទ ណាមួយ ដែលអនុញ្ញាតឱ្យទិន្នន័យមិនឆបគ្នាប្រមូលផ្តុំដោយគ្មានការព្រមានរហូតដល់មុខងារចុះក្រោមគាំងនៅពេលដំណើរការជាមួយនឹង កំហុសប្រភេទ ដែលស្ទើរតែមិនអាចតាមដានត្រឡប់ទៅប្រភពដើមរបស់វា។

ឧទាហរណ៍ជាក់ស្តែង៖ ក្រុមមួយនៅឯការចាប់ផ្ដើម fintech បានរាយការណ៍ថាចំណាយពេល បីថ្ងៃដើម្បីដោះស្រាយបញ្ហាផលិតកម្ម ដែលបញ្ជីទទេដែលបានចាប់ផ្តើមនៅក្នុងមុខងារដំណើរការការទូទាត់ត្រូវបានសន្មតថាជា បញ្ជី [ណាមួយ] ដោយ mypy ។ បញ្ជីនេះត្រូវបានគេសន្មត់ថាមានវត្ថុ ទសភាគ សម្រាប់ចំនួនរូបិយប័ណ្ណ ប៉ុន្តែផ្លូវកូដមួយត្រូវបានបន្ថែមតម្លៃ float ជំនួសវិញ។ ការសន្និដ្ឋានដ៏ស្រាលរបស់ Mypy បានអនុញ្ញាតដោយស្ងៀមស្ងាត់។ កំហុស​នេះ​បាន​លេច​ឡើង​តែ​នៅ​ពេល​មាន​កំហុស​បង្គត់​នៅ​ក្នុង​លេខ​នព្វន្ធ​ដែល​បណ្តាល​ឱ្យ​មាន​ការ​ខុស​គ្នា 0.01 ដុល្លារ​លើ​វិក្កយបត្រ​ចំនួន 12,000 ដុល្លារ។ ប្រសិនបើ​ពួកគេ​បាន​ប្រើ​ព្យញ្ជនៈ​ក្នុង​ទម្រង់​តឹងរ៉ឹង ឬ​គ្រាន់តែ​កំណត់ចំណាំ​បញ្ជី​ទទេ​ជា បញ្ជី [ទសភាគ] នោះ​កំហុស​នឹង​ត្រូវ​បាន​ចាប់​បាន​នៅ​ពេល​អភិវឌ្ឍន៍។

នៅ Mewayz ជាកន្លែងដែលវេទិកាដំណើរការវិក្កយបត្រ ការគណនាប្រាក់បៀវត្សរ៍ និងការវិភាគហិរញ្ញវត្ថុនៅទូទាំងគណនីអ្នកប្រើប្រាស់ 138,000+ ប្រភេទនៃគម្លាតសុវត្ថិភាពប្រភេទនេះមិនមែនជាទ្រឹស្តីទេ វាជាភាពខុសគ្នារវាងដំណើរការបើកប្រាក់បៀវត្សរ៍ត្រឹមត្រូវ និងការគណនាថ្លៃដើមឡើងវិញ។ វិន័យវាយអក្សរដ៏តឹងរ៉ឹងជុំវិញការចាប់ផ្តើមកុងតឺន័រគឺជាការអនុវត្តវិស្វកម្ម "គួរឱ្យធុញ" មួយក្នុងចំណោមការអនុវត្តវិស្វកម្មដែលការពារឧប្បត្តិហេតុផលិតកម្មដ៏គួរឱ្យរំភើប។

ការអនុវត្តល្អបំផុតសម្រាប់ការចាប់ផ្តើមកុងតឺន័រការពារ

មិនថាប្រភេទឧបករណ៍ពិនិត្យប្រភេទណាដែលក្រុមរបស់អ្នកប្រើនោះទេ មានយុទ្ធសាស្ត្រជាក់ស្តែងដើម្បីលុបបំបាត់ភាពមិនច្បាស់លាស់នៃធុងទទេទាំងស្រុង។ គោលដៅគឺកុំពឹងផ្អែកលើការសន្និដ្ឋានសម្រាប់ធុងទទេ — ធ្វើឱ្យប្រភេទច្បាស់លាស់ ដូច្នេះលេខកូដរបស់អ្នកអាចចល័តបាននៅគ្រប់ឧបករណ៍ពិនិត្យទាំងអស់ ហើយភាពស៊ាំនឹងការផ្លាស់ប្តូរអាកប្បកិរិយាការសន្និដ្ឋានរវាងកំណែ។

1. តែងតែកំណត់ចំណាំអថេរធុងទទេ។ សរសេរ លទ្ធផល៖ list[int] = [] ជំនួសឱ្យ លទ្ធផល = []។ ការចំណាយលើពាក្យសំដីតូចតាចគឺមានភាពធ្វេសប្រហែសបើប្រៀបធៀបទៅនឹងពេលវេលាបំបាត់កំហុសដែលបានរក្សាទុក។ ការអនុវត្តតែមួយនេះលុបបំបាត់ប្រហែល 80% នៃបញ្ហាការសន្និដ្ឋានរបស់ធុងទទេ។
2. ប្រើមុខងាររោងចក្រសម្រាប់កុងតឺន័រស្មុគស្មាញ។ ជំនួសឱ្យ ឃ្លាំងសម្ងាត់ = {} សូមសរសេរមុខងារដូចជា def make_cache() -> dict[str, list[UserRecord]]៖ ត្រឡប់ {}។ ចំណារពន្យល់ប្រភេទត្រឡប់មកវិញធ្វើឱ្យប្រភេទដែលមានបំណងមិនច្បាស់លាស់ និងធ្វើឯកសារដោយខ្លួនឯង។
3. ចូលចិត្ត​អ្នក​បង្កើត​ដែល​វាយ​បញ្ចូល​លើ​ព្យញ្ជនៈ​សម្រាប់​ប្រភេទ​ដែល​មិន​សំខាន់។ សរសេរ items: set[int] = set() ជាជាង​ការ​ពឹង​ផ្អែក​លើ set comprehension inference។ សម្រាប់ defaultdict និង Counter តែងតែផ្តល់ប៉ារ៉ាម៉ែត្រប្រភេទ៖ counts: Counter[str] = Counter()។
4. កំណត់រចនាសម្ព័ន្ធរបៀបតឹងរ៉ឹងរបស់អ្នកពិនិត្យប្រភេទរបស់អ្នកសម្រាប់កូដថ្មី។ ទាំង mypy និង pyright គាំទ្រក្នុងមួយឯកសារ ឬក្នុងមួយថត។ បើកការត្រួតពិនិត្យយ៉ាងតឹងរ៉ឹងលើម៉ូឌុលថ្មី ខណៈពេលដែលកំពុងផ្លាស់ប្តូរកូដកេរ្តិ៍ដំណែលបន្តិចម្តងៗ។ វាការពារការប្រមូលផ្តុំនៃធុងដែលវាយបញ្ចូលដោយប្រយោលថ្មី។
5. បន្ថែមការប្រៀបធៀបអ្នកត្រួតពិនិត្យប្រភេទទៅនឹងបំពង់ CI របស់អ្នក។ ការដំណើរការទាំង mypy និង pyright នៅលើ codebase របស់អ្នកអាចចាប់យកភាពខុសគ្នានៃការសន្និដ្ឋានដំបូង។ ប្រសិនបើលំនាំឆ្លងកាត់អ្នកត្រួតពិនិត្យមួយ ប៉ុន្តែបរាជ័យមួយផ្សេងទៀត វាជាសញ្ញាថាប្រភេទនេះមិនច្បាស់លាស់គ្រប់គ្រាន់។

រូបភាពធំជាងនេះ៖ វាយបញ្ចូលការត្រួតពិនិត្យជាការអនុវត្តក្រុម

ការសន្និដ្ឋានរបស់កុងតឺន័រទទេគឺជាអតិសុខុមប្រាណនៃបញ្ហាប្រឈមធំជាងនៅក្នុងប្រព័ន្ធប្រភេទរបស់ Python៖ ភាពតានតឹងរវាងភាពងាយស្រួល និងសុវត្ថិភាព។ ទស្សនវិជ្ជារបស់ Python នៃ "យើងទាំងអស់គ្នាជាមនុស្សពេញវ័យដែលយល់ព្រម" ដំណើរការយ៉ាងស្អាតសម្រាប់ការធ្វើគំរូ និងស្គ្រីប ប៉ុន្តែប្រព័ន្ធផលិតកម្មដែលបម្រើអ្នកប្រើប្រាស់រាប់ពាន់នាក់ត្រូវការការធានាខ្លាំងជាងនេះ។ ការពិតដែលថាអ្នកត្រួតពិនិត្យប្រភេទសំខាន់ៗចំនួនបួនមិនយល់ស្របលើអ្វីមួយដែលជាមូលដ្ឋានដូចជាប្រភេទនៃ [] គូសបញ្ជាក់ថាប្រព័ន្ធអេកូវាយអក្សរ Python នៅតែចាស់ទុំ។

សម្រាប់ក្រុមវិស្វករដែលបង្កើតវេទិកាស្មុគស្មាញ — មិនថាអ្នកកំពុងគ្រប់គ្រងសេវាកម្មខ្នាតតូចមួយក្តាប់តូច ឬប្រព័ន្ធរួមបញ្ចូលគ្នាដែលមានម៉ូឌុលទំនាក់ទំនងរាប់រយដូចជាប្រព័ន្ធប្រតិបត្តិការអាជីវកម្មរបស់ Mewayz — ដំបូន្មានជាក់ស្តែងគឺត្រង់៖ កុំពឹងផ្អែកលើការសន្និដ្ឋានសម្រាប់ធុងទទេ ជ្រើសរើសឧបករណ៍ពិនិត្យប្រភេទ ហើយកំណត់រចនាសម្ព័ន្ធវាយ៉ាងតឹងរ៉ឹង ហើយចាត់ទុកប្រភេទចំណារពន្យល់ដែលអាចកើតមានជាម៉ាស៊ីន។ ការចំណាយពេលប្រាំនាទីក្នុងការសរសេរ បញ្ជី [វិក្កយបត្រ] ជំនួសឱ្យ [] នឹងជួយសង្រ្គោះអ្នកជាច្រើនម៉ោងក្នុងការបំបាត់កំហុសនៅពេលមាត្រដ្ឋានកូដមូលដ្ឋានរបស់អ្នក។

ដូចដែល PEP 696 (ប៉ារ៉ាម៉ែត្រប្រភេទលំនាំដើម) និង PEP 695 (វាក្យសម្ព័ន្ធប៉ារ៉ាម៉ែត្រប្រភេទ) បន្តដំណើរការនៅក្នុងកំណែ Python ថ្មីជាងនេះ ergonomics នៃការវាយមិនច្បាស់លាស់នឹងបន្តប្រសើរឡើង។ គម្លាតរវាង Python "annotated" និង "unannotated" នឹងរួមតូច។ ប៉ុន្តែរហូតមកដល់ថ្ងៃនោះ ប្រភេទកុងតឺន័រច្បាស់លាស់នៅតែជាការអនុវត្តដែលមាន ROI ខ្ពស់បំផុតនៅក្នុងប្រអប់ឧបករណ៍របស់អ្នកអភិវឌ្ឍន៍ Python ដែលជាវិន័យតូចមួយដែលបង់ការប្រាក់រួមនៅគ្រប់ម៉ូឌុល រាល់ការរត់ និងរាល់ការដាក់ពង្រាយផលិតកម្ម។

សំណួរដែលគេសួរញឹកញាប់

ហេតុ​អ្វី​បាន​ជា​មិន​អាច​វាយ​អ្នក​ពិនិត្យ​យល់ព្រម​លើ​ប្រភេទ​នៃ​បញ្ជី​ទទេ?

នៅពេលអ្នកសរសេរ `x = []` អ្នកត្រួតពិនិត្យប្រភេទត្រូវតែសន្និដ្ឋានប្រភេទដោយគ្មានការណែនាំច្បាស់លាស់។ អ្នកត្រួតពិនិត្យផ្សេងគ្នាប្រើយុទ្ធសាស្ត្រផ្សេងៗគ្នា៖ ខ្លះសន្មតថា `list[Any]` (បញ្ជីនៃអ្វីទាំងអស់) ខណៈពេលដែលអ្នកផ្សេងទៀតអាចសន្និដ្ឋានប្រភេទជាក់លាក់ជាង ប៉ុន្តែមិនត្រឹមត្រូវដូចជា `list[None]`។ កង្វះ​ស្តង់ដារ​សកល​នេះ ជា​មូលហេតុ​ដែល​ពួកគេ​មិន​យល់ស្រប។ សម្រាប់គម្រោងដែលប្រើឧបករណ៍ពិនិត្យច្រើន ភាពមិនស៊ីសង្វាក់គ្នានេះអាចជាការឈឺក្បាលដ៏សំខាន់ ដោយបំបែកការវិភាគនៅក្នុងឧបករណ៍មួយដែលឆ្លងកាត់ក្នុងឧបករណ៍ផ្សេងទៀត។

តើអ្វីជាវិធីសាមញ្ញបំផុតដើម្បីជួសជុលកំហុសធុងទទេ?

ដំណោះស្រាយត្រង់បំផុតគឺផ្តល់ចំណារពន្យល់ប្រភេទច្បាស់លាស់។ ជំនួសឱ្យ `my_list = []` សរសេរ `my_list: list[str] = []` ដើម្បីប្រកាសយ៉ាងច្បាស់អំពីប្រភេទដែលមានបំណង។ វាលុបបំបាត់ភាពមិនច្បាស់លាស់ទាំងអស់សម្រាប់កម្មវិធីពិនិត្យប្រភេទ ដោយធានានូវអាកប្បកិរិយាជាប់លាប់នៅលើឧបករណ៍ផ្សេងៗដូចជា mypy, Pyright និង Pyre ។ ការអនុវត្តនេះត្រូវបានណែនាំសម្រាប់ការចាប់ផ្តើមកុងតឺន័រទទេទាំងអស់ដើម្បីការពារកំហុសក្នុងការសន្និដ្ឋាន។

តើខ្ញុំអាចគ្រប់គ្រងធុងទទេក្នុងនិយមន័យថ្នាក់ដោយរបៀបណា?

នេះ​ជា​បញ្ហា​ទូទៅ​ព្រោះ​ការ​ពន្យល់​នៅ​ក្នុង​ថ្នាក់​តម្រូវ​ឱ្យ​មាន​ការ​ដោះស្រាយ​ពិសេស។ អ្នកត្រូវតែប្រើការនាំចូល `from __future__ import annotations` ឬចំណារពន្យល់ `ClassVar` ប្រសិនបើបញ្ជីនេះមានបំណងធ្វើជាគុណលក្ខណៈថ្នាក់។ ឧទាហរណ៍ `class MyClass: my_list: ClassVar[list[str]] = []`។ បើគ្មាននេះទេ អ្នកត្រួតពិនិត្យប្រភេទអាចពិបាកក្នុងការសន្និដ្ឋានប្រភេទឱ្យបានត្រឹមត្រូវ ដែលនាំឱ្យមានកំហុស។

តើ​មាន​ឧបករណ៍​សម្រាប់​ជួយ​គ្រប់គ្រង​បញ្ហា​វាយ​អក្សរ​ទាំងនេះ​ក្នុង​គម្រោង​ធំៗ​ដែរ​ឬ​ទេ?

បាទ/ចាស អ្នកត្រួតពិនិត្យប្រភេទកម្រិតខ្ពស់ដូចជា Pyright (ដែលផ្តល់ថាមពលដល់ Pylance ក្នុង VS Code) គឺល្អជាពិសេសក្នុងការដោះស្រាយការសន្និដ្ឋានស្មុគស្មាញ។ សម្រាប់មូលដ្ឋានកូដធំ វេទិកាដូចជា Mewayz (ផ្តល់ជូនម៉ូឌុលវិភាគចំនួន 207 សម្រាប់ $19/ខែ) អាចផ្តល់នូវការត្រួតពិនិត្យប្រភេទស៊ីជម្រៅ ស៊ីសង្វាក់គ្នា និងជួយពង្រឹងការអនុវត្តចំណារពន្យល់ទូទាំងក្រុមទាំងមូលរបស់អ្នក ដោយកាត់បន្ថយភាពមិនស៊ីសង្វាក់គ្នាដែលបានពិភាក្សានៅក្នុងអត្ថបទ។