🥇ទ្រឹស្ដីជំនួសឱ្យការទស្សនវិជ្ជា៖ ក្លាយជាអ្នកអភិវឌ្ឍន៍ផ្នែកខាងមុខកាន់តែប្រសើរ

ការបកប្រែ ក្លាយជាអ្នកអភិវឌ្ឍន៍ផ្នែកខាងមុខដែលល្អជាងមុនដោយប្រើមូលដ្ឋានគ្រឹះជំនួសឱ្យការស្រាវជ្រាវ

បទពិសោធន៍របស់យើងបង្ហាញថាអ្នកអភិវឌ្ឍន៍ដែលមិនមែនជាបច្ចេកទេស និងអ្នកអភិវឌ្ឍន៍ដែលបង្រៀនដោយខ្លួនឯង ជារឿយៗមិនពឹងផ្អែកលើគោលការណ៍ទ្រឹស្តីទេ ប៉ុន្តែនៅលើវិធីសាស្រ្តនៃទ្រឹស្តី។

Heuristics គឺជាគំរូ និងច្បាប់ដែលបង្ហាញឱ្យឃើញ ដែលអ្នកអភិវឌ្ឍន៍បានរៀនពីការអនុវត្ត។ ពួកគេប្រហែលជាមិនដំណើរការល្អឥតខ្ចោះ ឬក្នុងកម្រិតកំណត់នោះទេ ប៉ុន្តែពួកគេដំណើរការបានល្អគ្រប់គ្រាន់ ហើយមិនត្រូវការការគិតធ្ងន់ធ្ងរនោះទេ។ នេះគឺជាឧទាហរណ៍មួយចំនួននៃ heuristics៖

"ប្រើ $(document).ready(function(){}) សម្រាប់ការចាប់ផ្តើមកូដនៅលើគេហទំព័រ jQuery"
"រចនា var self = this តម្រូវឱ្យហៅវិធីសាស្ត្រក្នុងមុខងារហៅត្រឡប់"
msgstr "មុខងារព្រួញមិនមានសញ្ញាប្រមាណវិធី return»

ទន្ទឹមនឹងនោះ គោលការណ៍ទ្រឹស្តីអាចប្រើដើម្បីស្វែងរកដំណោះស្រាយចំពោះបញ្ហាផ្សេងៗ។ វាជាការពិតមិនប្រែប្រួល ហើយជារឿយៗកំណត់រចនាសម្ព័ន្ធនៃប្រតិបត្តិការនៃធាតុជាក់លាក់មួយ។ គោលការណ៍ទ្រឹស្តីរួមមានឧទាហរណ៍៖

សូមចំណាំថា យើងគ្រាន់តែដាក់ឧទាហរណ៍នៃ heuristics នៅក្នុងសញ្ញាសម្រង់ដើម្បីបញ្ជាក់អំពីលក្ខណៈសិល្បៈនៃ heuristics បើប្រៀបធៀបទៅនឹងភាពម៉ត់ចត់នៃក្របខ័ណ្ឌទ្រឹស្តី។ គ្មានឧទាហរណ៍ណាមួយដែលអាចអនុវត្តបានជាសាកលទេ ប៉ុន្តែពួកវាដំណើរការក្នុងស្ថានភាពគ្រប់គ្រាន់ដែលអ្នកអភិវឌ្ឍន៍ដែលប្រើពួកវាទទួលបានកូដការងារដោយមិនយល់ច្បាស់ពីរបៀបដែលវាដំណើរការ។

អាគុយម៉ង់នៅក្នុងការពេញចិត្តនៃវិធីសាស្រ្តទ្រឹស្តី

យើងបានរកឃើញជាញឹកញាប់ថាអ្នកអភិវឌ្ឍន៍ដែលមិនមែនជាបច្ចេកទេសមានការស្ទាក់ស្ទើរក្នុងការដោះស្រាយបញ្ហាដោយប្រើគោលការណ៍ទ្រឹស្តី។ នេះជាធម្មតាដោយសារតែពួកគេមិនមានឱកាសដើម្បីរៀនពួកគេពីដំបូងក្នុងអាជីពរបស់ពួកគេ ហើយដោយសារតែ heuristics ធ្វើការពេញចិត្ត ពួកគេបានបន្តប្រើប្រាស់វា។

ទោះជាយ៉ាងណាក៏ដោយ ទោះបីជាមានភាពស្មុគស្មាញជាក់ស្តែងក៏ដោយ ការរៀនទ្រឹស្តីអាចមានប្រយោជន៍ខ្លាំងណាស់។ ដើម្បីអ្វី? ដោយសារតែទ្រឹស្តីនឹងអនុញ្ញាតឱ្យអ្នកមានអារម្មណ៍ថាមានទំនុកចិត្តថាដំណោះស្រាយរបស់អ្នកដំណើរការ ហើយក៏អាចទទួលបានចម្លើយដោយឯករាជ្យចំពោះសំណួរថ្មីៗ ដោយមិនចាំបាច់ស្វែងរកដំណោះស្រាយពីអ្នកដ៏ទៃ។ ក្នុងរយៈពេលខ្លី ក្បួនដោះស្រាយការពន្យល់អាចហាក់ដូចជាដំណោះស្រាយដ៏សាមញ្ញ និងរហ័ស ប៉ុន្តែជារឿយៗនឹងនាំទៅរកដំណោះស្រាយតិចជាងឧត្តមគតិ - ប្រសិនបើមានទាំងអស់។

ជាងនេះទៅទៀត ដោយការពឹងផ្អែកលើទ្រឹស្តី អ្នកនឹងមិនអាចរៀនដោះស្រាយបញ្ហាពិតប្រាកដបានទេ។ ប្រហែលជាញឹកញាប់ណាស់ អ្នកនឹងអាចស្វែងរកដំណោះស្រាយដែលកំពុងដំណើរការ ប៉ុន្តែមិនយូរមិនឆាប់ អ្នកនឹងឈានដល់ទីបញ្ចប់ដែលអ្នកនឹងមិនឃើញផ្លូវចេញ។ អ្នកសរសេរកម្មវិធី C&P ពឹងផ្អែកលើ heuristics នៅក្នុងការងាររបស់ពួកគេ។

លក្ខណៈវិនិច្ឆ័យកម្រិតជំនាញអ្នកអភិវឌ្ឍន៍

នៅពេលសម្ភាសអ្នកអភិវឌ្ឍន៍ Frontend យើងផ្តល់ឱ្យពួកគេនូវបញ្ហាប្រឈមក្នុងការសរសេរកម្មវិធី ហើយប្រាប់ពួកគេថាពួកគេមានសេរីភាពក្នុងការប្រើប្រាស់ប្រភពណាមួយ មិនថា Google ឬ Stack Overflow ។ វិធីនេះអ្នកអាចកំណត់យ៉ាងងាយស្រួលថាតើអ្នកអភិវឌ្ឍន៍ជាអ្នកដើរតាមទ្រឹស្ដី ឬអ្នកដើរតាមទ្រឹស្ដី។

ទីមួយ ដោយគ្មានករណីលើកលែងណាមួយ ចម្លងកូដពីឧទាហរណ៍ដែលសមរម្យច្រើន ឬតិចពី Stack Overflow ។ លុះត្រាតែលេខកូដមិនដំណើរការដូចការគ្រោងទុក ពួកគេនឹងចាប់ផ្តើមកែប្រែវាឱ្យសមនឹងខ្លួនគេ។ ជារឿយៗពួកគេបរាជ័យក្នុងការធ្វើបែបនេះ។

ក្រោយមកទៀតមាននិន្នាការស្វែងរកចម្លើយនៅក្នុងឯកសារ API ។ នៅទីនោះពួកគេស្វែងរកព័ត៌មានអំពីចំនួនប៉ារ៉ាម៉ែត្រដែលមុខងារជាក់លាក់មួយយក ឬវាក្យសម្ព័ន្ធជាក់លាក់នៃទម្រង់ពង្រីកនៃទ្រព្យសម្បត្តិ CSS ដែលចង់បាន។

រួចហើយនៅក្នុងប្រាំនាទីដំបូងនៃការសម្ភាសន៍ អ្នកអាចកំណត់បានយ៉ាងត្រឹមត្រូវថាតើអ្នកសរសេរកម្មវិធីប្រភេទណាជាបេក្ខជន។

ឧទាហរណ៍:

សូមលើកយក Developer Bill ជាឧទាហរណ៍។ គាត់បានចូលរៀនវគ្គបណ្តុះបណ្តាលជាច្រើន ដោះស្រាយបញ្ហា JavaScript មួយចំនួន និងសរសេរគេហទំព័រនៅពេលទំនេររបស់គាត់ ប៉ុន្តែគាត់មិនបាន "ពិតជា" សិក្សា JavaScript ទេ។

ថ្ងៃមួយ Bill មកជួបវត្ថុដូចនេះ៖

const usersById = {
    "5": { "id": "5", "name": "Adam", "registered": true },
    "27": { "id": "27", "name": "Bobby", "registered": true },
    "32": { "id": "32", "name": "Clarence", "registered": false },
    "39": { "id": "39", "name": "Danielle", "registered": true },
    "42": { "id": "42", "name": "Ekaterina", "registered": false }
}

វត្ថុបែបនេះអាចបង្ហាញបញ្ជីអ្នកប្រើប្រាស់ និងថាតើពួកគេបានចុះឈ្មោះសម្រាប់ព្រឹត្តិការណ៍ជាក់លាក់មួយឬអត់។

ចូរនិយាយថា Bill ត្រូវការដើម្បីទាញយកបញ្ជីនៃអ្នកប្រើប្រាស់ដែលបានចុះឈ្មោះ។ នៅក្នុងពាក្យផ្សេងទៀត, ត្រងពួកវាចេញ។ គាត់បានឆ្លងកាត់កូដដែលវិធីសាស្ត្រ .filter() ប្រើដើម្បីត្រងបញ្ជី។ ដូច្នេះគាត់ព្យាយាមអ្វីមួយដូចជា៖

const attendees = usersById.filter(user => user.registered);

ហើយនេះគឺជាអ្វីដែលគាត់ទទួលបាន៖

TypeError: usersById.filter is not a function

Bill គិតថា "នេះគឺជាប្រភេទមិនសមហេតុសមផលមួយចំនួន" ដោយសារតែគាត់បានឃើញកូដនៅក្នុងនោះ។ .filter() ដើរតួជាតម្រង។

បញ្ហាគឺថាលោក Bill ពឹងផ្អែកលើវិធីសាស្រ្ត heuristic ។ គាត់មិនយល់នោះទេ។ filter គឺជាវិធីសាស្រ្តដែលកំណត់លើអារេ usersById - វត្ថុធម្មតាដែលមិនមានវិធីសាស្រ្ត filter.

ច្រឡំ Bill Googles "តម្រង javascript" គាត់បានរកឃើញការលើកឡើងជាច្រើននៃអារេ ហើយដឹងថាគាត់ត្រូវការបង្វិល usersById ទៅអារេមួយ។ បន្ទាប់មកតាមការស្នើសុំ "javascript ប្រែក្លាយវត្ថុទៅជាអារេ» គាត់រកឃើញឧទាហរណ៍នៅលើ Stack Overflow ដោយប្រើ Object.keys(). បន្ទាប់ពីនេះគាត់ព្យាយាម៖

const attendees = Object.keys(usersById).filter(user => user.registered);

លើកនេះគ្មានកំហុសត្រូវបានបង្ហាញឡើយ ប៉ុន្តែចំពោះការភ្ញាក់ផ្អើលរបស់លោក Bill វាល attendees នៅតែទទេ។

ចំណុចនោះគឺថា Object.keys() ត្រឡប់សោរបស់វត្ថុ ប៉ុន្តែមិនមែនតម្លៃរបស់វាទេ។ សំខាន់គឺឈ្មោះនៃអថេរ user ងាយយល់ច្រឡំព្រោះវាមិនមែនជាវត្ថុ userនិងអ្នកកំណត់អត្តសញ្ញាណ នោះគឺខ្សែអក្សរ។ ចាប់តាំងពីគុណលក្ខណៈ registered មិនត្រូវបានកំណត់សម្រាប់ខ្សែ, filter វាយតម្លៃធាតុនីមួយៗថាមិនពិត ហើយអារេចេញមកទទេ។

Bill ពិនិត្យមើលយ៉ាងដិតដល់នូវចម្លើយនៅលើ Stack Overflow ហើយធ្វើការផ្លាស់ប្តូរដូចខាងក្រោម៖

const attendees = Object.keys(usersById).filter(id => usersById[id].registered);

លើកនេះលទ្ធផលគឺប្រសើរជាង៖ ["5", "27", "39"]. ប៉ុន្តែលោក Bill ចង់ទទួលបានវត្ថុរបស់អ្នកទស្សនា មិនមែនអត្តសញ្ញាណប័ណ្ណរបស់ពួកគេទេ។

ដើម្បីស្វែងយល់ពីរបៀបត្រងអ្នកចូលទស្សនា រំខាន Bill ស្វែងរក "តម្រងវត្ថុ javascript", ពិនិត្យលទ្ធផលស្វែងរកនៅលើ Stack Overflow ហើយរកឃើញ ចម្លើយនេះ។ ជាមួយនឹងលេខកូដខាងក្រោម៖

Object.filter = (obj, predicate) => 
    Object.keys(obj)
          .filter( key => predicate(obj[key]) )
          .reduce( (res, key) => (res[key] = obj[key], res), {} );

Bill ចម្លងបន្ទាត់ទាំងនេះ ហើយព្យាយាម៖

const attendees = Object.filter(usersById, user => user.registered);

អ្វីគ្រប់យ៉ាងដំណើរការ - ទោះបីជាវាមិនច្បាស់ពីមូលហេតុក៏ដោយ។ Bill មិនយល់ថាវាសម្រាប់អ្វីនោះទេ។ reduce និងរបៀបដែលវាត្រូវបានប្រើ។ លើសពីនេះទៅទៀត Bill មិនយល់ថាគាត់គ្រាន់តែកំណត់សម្រាប់វត្ថុសកល Object វិធីសាស្រ្តមិនស្តង់ដារថ្មី។

ប៉ុន្តែ Bill មិនខ្វល់ - វាដំណើរការ! គាត់មិនបានចាប់អារម្មណ៍នឹងផលវិបាកនៅឡើយទេ។

តើ Bill ធ្វើអ្វីខុស?

លោក Bill បានសាកល្បងវិធីសាស្រ្ដដើម្បីដោះស្រាយបញ្ហា ហើយជួបប្រទះបញ្ហាដូចខាងក្រោម៖

ការប្រើប្រាស់ .filter() នៅលើអថេរ Bill បានទទួល TypeError. គាត់មិនយល់នោះទេ។ filter មិនត្រូវបានរកឃើញនៅលើវត្ថុធម្មតា។
គាត់បានដាក់ពាក្យ Object.keys()ដើម្បី "បង្វែរវត្ថុទៅជាអារេ" ប៉ុន្តែនេះមិននាំមកនូវលទ្ធផលណាមួយទេ។ គាត់ត្រូវការបង្កើតអារេនៃតម្លៃវត្ថុ។
សូម្បីតែបន្ទាប់ពីទទួលបានតម្លៃ និងប្រើប្រាស់ពួកវាជាលក្ខខណ្ឌសម្រាប់ត្រងក៏ដោយ គាត់បានទទួលតែឧបករណ៍កំណត់អត្តសញ្ញាណជំនួសឱ្យវត្ថុអ្នកប្រើប្រាស់ដែលភ្ជាប់ជាមួយឧបករណ៍កំណត់អត្តសញ្ញាណទាំងនោះ។ នេះគឺដោយសារតែអារេដែលបានត្រងមានលេខសម្គាល់ មិនមែនជាវត្ថុរបស់អ្នកប្រើទេ។
យូរៗទៅ Bill បានបោះបង់ចោលវិធីសាស្រ្តនេះ ហើយបានរកឃើញដំណោះស្រាយការងារនៅលើអ៊ីនធឺណិត។ ទោះយ៉ាងណាក៏ដោយ គាត់នៅតែមិនយល់ពីរបៀបដែលវាដំណើរការ ហើយគាត់នឹងមិនខ្ជះខ្ជាយពេលវេលាក្នុងការស្វែងរកវាទេ ព្រោះគាត់មានកិច្ចការផ្សេងៗទៀតដែលត្រូវធ្វើ។

នេះគឺជាឧទាហរណ៍សិប្បនិម្មិតមួយ ប៉ុន្តែយើងបានឃើញអ្នកអភិវឌ្ឍន៍ដោះស្រាយបញ្ហាតាមរបៀបដូចគ្នាជាច្រើនដង។ ដើម្បីដោះស្រាយវាឱ្យមានប្រសិទ្ធភាព អ្នកត្រូវដកខ្លួនចេញពីវិធីសាស្រ្ដ និងសិក្សាទ្រឹស្ដី។

ចូរយើងចុះទៅមូលដ្ឋាន

ប្រសិនបើ Bill ជាអ្នកជំរុញនៃវិធីសាស្រ្តទ្រឹស្តី ដំណើរការនឹងមើលទៅដូចនេះ៖

កំណត់ធាតុបញ្ចូលដែលបានផ្តល់ឱ្យ និងកំណត់លទ្ធផលដែលចង់បាន - ទាក់ទងនឹងលក្ខណៈសម្បត្តិរបស់វា៖ “ខ្ញុំមានវត្ថុដែលកូនសោជាខ្សែតំណាងឱ្យលេខសម្គាល់ ហើយតម្លៃរបស់វាជាវត្ថុតំណាងឱ្យអ្នកប្រើ។ ខ្ញុំចង់ទទួលបានអារេដែលតម្លៃនឹងជាវត្ថុអ្នកប្រើ - ប៉ុន្តែមានតែវត្ថុអ្នកប្រើដែលបានចុះឈ្មោះប៉ុណ្ណោះ"
ស្វែងយល់ពីរបៀបធ្វើម្តងទៀតតាមរយៈវត្ថុមួយ៖ "ខ្ញុំដឹងថាខ្ញុំអាចទទួលបានអារេនៃគ្រាប់ចុចនៅក្នុងវត្ថុមួយដោយការហៅទូរសព្ទ Object.keys(). ខ្ញុំចង់ទទួលបានអារេមួយព្រោះអារេគាំទ្រការធ្វើឡើងវិញ".
ដឹងថាវិធីសាស្ត្រនេះអាចជួយទទួលបានកូនសោ ហើយអ្នកត្រូវបំប្លែងសោទៅជាតម្លៃ ហើយចងចាំអំពី map គឺជាវិធីសាស្ត្រជាក់ស្តែងសម្រាប់បង្កើតអារេថ្មីដោយបំប្លែងតម្លៃនៃអារេមួយទៀត៖
```
Object.keys(usersById).map(id => usersById[id])
```
សូមមើលថាឥឡូវនេះអ្នកមានអារេដែលអាចត្រងបាននៃវត្ថុផ្ទាល់ខ្លួនដែលមានតម្លៃជាក់ស្តែងដែលអ្នកចង់ត្រង៖
```
Object.keys(usersById).map(id => usersById[id]).filter(user => user.registered)
```

ប្រសិនបើ Bill បានទៅតាមផ្លូវនេះ គាត់អាចធ្វើការឱ្យយើង។

ហេតុអ្វីបានជាមនុស្សមិនងាកទៅរកទ្រឹស្តីញឹកញាប់ជាងនេះ?

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

ដើម្បីជៀសវាងកំហុសបែបនេះ តែងតែចាប់ផ្តើមជាមួយទ្រឹស្តី។ នៅដំណាក់កាលនីមួយៗនៃដំណើរការ សូមគិតអំពីទិន្នន័យដែលអ្នកកំពុងដោះស្រាយ។ ជំនួសឱ្យការពឹងផ្អែកលើលំនាំដែលធ្លាប់ស្គាល់គ្រប់ពេល សូមពិចារណាប្រភេទទិន្នន័យបឋម៖ អារេ វត្ថុ ខ្សែអក្សរ។ល។ នៅពេលអ្នកប្រើមុខងារ ឬវិធីសាស្រ្ត ពិនិត្យមើលឯកសារ ដើម្បីធានាថាអ្នកដឹងច្បាស់ថាប្រភេទទិន្នន័យដែលវាគាំទ្រ អាគុយម៉ង់អ្វីដែលវាត្រូវការ និងលទ្ធផលរបស់វាជាអ្វី។

ជាមួយនឹងវិធីសាស្រ្តនេះ អ្នកនឹងអាចស្វែងរកដំណោះស្រាយដែលមានប្រសិទ្ធភាពនៅពេលសាកល្បងលើកដំបូង។ អ្នកអាចប្រាកដថាភាពត្រឹមត្រូវរបស់វា ពីព្រោះអ្នកបានជ្រើសរើសសកម្មភាពរបស់អ្នកជាពិសេសដោយផ្អែកលើការបញ្ចូលដែលបានផ្តល់ឱ្យ និងទិន្នន័យលទ្ធផលដែលចង់បាន។ ចូលទៅក្នុងមូលដ្ឋាននៃប្រតិបត្តិការនីមួយៗ (ប្រភេទទិន្នន័យ និងតម្លៃត្រឡប់មកវិញ) ជាជាងភាសាអាជីវកម្មមិនច្បាស់លាស់ (ដូចជា "អ្នកប្រើប្រាស់ដែលបានចុះឈ្មោះ")។

ប្រភព៖ www.habr.com