ความแตกต่างระหว่างการพึ่งพา, devDependencies และ peerDependencies ในไฟล์ npm package.json คืออะไร?

2028

เอกสารนี้ตอบคำถามของฉันไม่ดีมาก ฉันไม่เข้าใจคำอธิบายเหล่านั้น ใครสามารถพูดด้วยคำพูดที่ง่ายกว่านี้ได้บ้าง อาจจะมีตัวอย่างถ้ามันยากที่จะเลือกคำง่ายๆ?

EDITยังเพิ่มpeerDependenciesซึ่งมีความเกี่ยวข้องอย่างใกล้ชิดและอาจทำให้เกิดความสับสน

node.js  npm 
— Vitalii Korsakov
แหล่งที่มา
48
หมายเหตุยังมีoptionalDependenciesตอนนี้
— Aidan Feldman
118
@AidanFeldman "optionalDependencies" เป็นเพลงโปรดของฉันประจำวัน
— Nick Bull
1
เอกสาร npm บอกว่า: "การพึ่งพา": แพ็คเกจที่แอปพลิเคชันของคุณต้องการในการผลิต "devDependencies": แพ็คเกจที่จำเป็นสำหรับการพัฒนาและทดสอบในท้องถิ่นเท่านั้น ดูลิงค์: docs.npmjs.com/…
— Deke

คำตอบ:

2365

สรุปความแตกต่างของพฤติกรรมที่สำคัญ:

  • dependencies มีการติดตั้งบนทั้งสอง:

    • npm install จากไดเรกทอรีที่มี package.json
    • npm install $package ในไดเรกทอรีอื่น ๆ

  • devDependencies คือ:

    • ติดตั้งในnpm installไดเรกทอรีที่มีอยู่package.jsonเว้นแต่คุณจะผ่าน--productionธง (ไปตอบคำตอบของ Gayan Charith )
    • ไม่ได้ติดตั้งไว้ในnpm install "$package"ไดเรกทอรีอื่น ๆ เว้นแต่คุณจะให้--devตัวเลือกแก่มัน
    • ไม่ได้ติดตั้งแบบต่อเนื่อง

  • peerDependencies:

    • ก่อน 3.0: จะถูกติดตั้งเสมอหากไม่มีและเพิ่มข้อผิดพลาดหากมีการใช้การอ้างอิงที่ไม่เข้ากันหลายเวอร์ชัน
    • คาดว่าจะเริ่มใน 3.0 (ยังไม่ได้ทดสอบ): ส่งคำเตือนหากไม่มีnpm installและคุณต้องแก้ปัญหาการพึ่งพาตนเองด้วยตนเอง เมื่อทำงานหากการอ้างอิงหายไปคุณจะได้รับข้อผิดพลาด (กล่าวถึงโดย@nextgentech )

  • ความไว (กล่าวถึงโดยBen Hutchison ):

    • dependencies ได้รับการติดตั้งแบบต่อเนื่อง: ถ้า A ต้องการ B และ B ต้องการ C ดังนั้น C จะได้รับการติดตั้งมิฉะนั้น B จะใช้งานไม่ได้และ A

    • devDependenciesไม่ได้ติดตั้งแบบต่อเนื่อง เช่นเราไม่จำเป็นต้องทดสอบ B เพื่อทดสอบ A ดังนั้นการอ้างอิงการทดสอบของ B จึงถูกยกเลิก

ตัวเลือกที่เกี่ยวข้องไม่ได้กล่าวถึงที่นี่:

devDependencies

dependenciesจะต้องเรียกใช้devDependenciesเพื่อการพัฒนาเท่านั้นเช่น: การทดสอบหน่วย, การแพร่กระจาย CoffeeScript เป็น JavaScript, การลดขนาด, ...

หากคุณกำลังจะพัฒนาแพ็คเกจคุณดาวน์โหลดมัน (เช่นผ่านgit clone) ไปที่รูทของมันซึ่งมีpackage.jsonและรัน:

npm install

เนื่องจากคุณมีแหล่งที่มาจริงเป็นที่ชัดเจนว่าคุณต้องการที่จะพัฒนาดังนั้นโดยค่าเริ่มต้นทั้งสองdependencies(เนื่องจากคุณต้องแน่นอนวิ่งไปสู่การพัฒนา) และdevDependencyติดตั้งการอ้างอิง

อย่างไรก็ตามหากคุณเป็นเพียงผู้ใช้ที่ต้องการติดตั้งแพคเกจเพื่อใช้งานคุณจะทำจากไดเรกทอรีใด ๆ :

npm install "$package"

dependenciesในกรณีที่คุณตามปกติไม่ต้องการพึ่งพาการพัฒนาเพื่อให้คุณเพียงแค่ได้รับสิ่งที่จำเป็นในการใช้แพคเกจ:

หากคุณต้องการติดตั้งแพ็กเกจการพัฒนาจริง ๆ ในกรณีนั้นคุณสามารถตั้งdevค่าตัวเลือกการกำหนดค่าtrueเป็นได้จากบรรทัดคำสั่งเป็น:

npm install "$package" --dev

ตัวเลือกนี้เป็นfalseค่าเริ่มต้นเนื่องจากเป็นกรณีที่พบได้น้อยกว่ามาก

peerDependencies

(ทดสอบก่อน 3.0)

ที่มา: https://nodejs.org/en/blog/npm/peer-dependencies/

ด้วยการอ้างอิงปกติคุณสามารถมีการพึ่งพาได้หลายเวอร์ชัน: มันเป็นการติดตั้งภายในnode_modulesการพึ่งพา

เช่นถ้าdependency1และdependency2ทั้งคู่ขึ้นอยู่กับdependency3เวอร์ชันที่แตกต่างกันแผนผังโครงการจะมีลักษณะดังนี้:

root/node_modules/
                 |
                 +- dependency1/node_modules/
                 |                          |
                 |                          +- dependency3 v1.0/
                 |
                 |
                 +- dependency2/node_modules/
                                            |
                                            +- dependency3 v2.0/

อย่างไรก็ตามปลั๊กอินเป็นแพ็คเกจที่ปกติไม่ต้องการแพ็คเกจอื่นซึ่งเรียกว่าโฮสต์ในบริบทนี้ แทน:

  • จำเป็นต้องใช้ปลั๊กอินโดยโฮสต์
  • ปลั๊กอินเสนออินเทอร์เฟซมาตรฐานที่โฮสต์คาดว่าจะค้นหา
  • เฉพาะโฮสต์เท่านั้นที่จะถูกเรียกโดยผู้ใช้โดยตรงดังนั้นจะต้องมีรุ่นเดียว

เช่นถ้าdependency1และdependency2เพื่อนพึ่งdependency3ต้นไม้โครงการจะมีลักษณะ:

root/node_modules/
                 |
                 +- dependency1/
                 |
                 +- dependency2/
                 |
                 +- dependency3 v1.0/

สิ่งนี้เกิดขึ้นแม้ว่าคุณจะไม่เคยพูดถึงdependency3ในpackage.jsonไฟล์ของคุณ

ฉันคิดว่านี่เป็นตัวอย่างของรูปแบบการออกแบบInversion of Control

ตัวอย่างต้นแบบของการพึ่งพาเพียร์คือ Grunt โฮสต์และปลั๊กอิน

ตัวอย่างเช่นในปลั๊กอิน Grunt เช่นhttps://github.com/gruntjs/grunt-contrib-uglifyคุณจะเห็นว่า:

  • grunt คือ peer-dependency
  • require('grunt')ภายใต้เท่านั้นtests/: โปรแกรมไม่ได้ใช้จริง

จากนั้นเมื่อผู้ใช้จะใช้ปลั๊กอินเขาจะต้องมีปลั๊กอินGruntfileโดยการเพิ่มgrunt.loadNpmTasks('grunt-contrib-uglify')บรรทัด แต่ก็คือgruntผู้ใช้จะโทรโดยตรง

สิ่งนี้จะไม่ทำงานถ้าปลั๊กอินแต่ละอันต้องการ Grunt เวอร์ชั่นที่แตกต่าง

คู่มือ

ฉันคิดว่าเอกสารประกอบตอบคำถามได้ค่อนข้างดีบางทีคุณอาจไม่คุ้นเคยกับโหนด / ผู้จัดการแพ็คเกจอื่น ๆ ฉันอาจเข้าใจเพราะฉันรู้เพียงเล็กน้อยเกี่ยวกับ Ruby bundler

กุญแจสำคัญคือ:

สิ่งเหล่านี้จะถูกติดตั้งเมื่อทำการลิงก์ npm หรือการติดตั้ง npm จากรูทของแพ็คเกจและสามารถจัดการได้เหมือนกับพารามิเตอร์การกำหนดค่า npm อื่น ๆ ดู npm-config (7) สำหรับข้อมูลเพิ่มเติมในหัวข้อ

และภายใต้ npm-config (7) ค้นหาdev:

Default: false
Type: Boolean

Install dev-dependencies along with packages.
— Ciro Santilli 冠状法轮功审查六四法轮功法轮功
แหล่งที่มา
5
อา. ฉันเห็นว่าฉันเข้าใจผิด คำตอบของคุณอ่านราวกับว่าnpm install packageเป็นคำสั่งที่คุณใช้ในการติดตั้งแพคเกจทั้งหมดที่ไม่ได้พึ่งพาการพึ่งพามากกว่าสิ่งที่ฉันคิดว่าตอนนี้คุณหมายถึงซึ่งเป็น 'ติดตั้งแพคเกจที่เรียกว่า [แพคเกจ]' ซึ่งเป็นวิธีที่ฉันคิดว่ามันทำงาน ก่อนที่จะอ่านข้อความนี้ ถ้าฉันเป็นคุณฉันจะแก้ไขเพื่อบอกว่า [package-name] ซึ่งแสดงให้เห็นอย่างชัดเจนว่าสิ่งที่คุณหมายถึงคือ 'insert-name-here'
— Tom W
184
มันเยี่ยมมาก! ฉันไม่เคยรู้มาก่อน แต่คำตอบนี้สอนฉันว่าความแตกต่างของการพึ่งพาและการพัฒนาความแตกต่างนั้นใช้ได้เฉพาะเมื่อคุณกำลังจะเผยแพร่แพคเกจ npm หากคุณเพิ่งทำงานกับแอพพลิเคชั่นหรือเว็บไซต์มันไม่สำคัญมากนัก ขอบคุณ!
— jedd.ahyoung
3
โพสต์นี้ควรได้รับการอัพเดตเพื่อให้สะท้อนถึงpeerDependenciesพฤติกรรมที่เปลี่ยนแปลงใน npm @ 3 ที่จะเกิดขึ้น จากblog.npmjs.org/post/110924823920/npm-weekly-5 : "เราจะไม่ดาวน์โหลดการพึ่งพาเพียร์โดยอัตโนมัติอีกต่อไปแทนเราจะเตือนคุณหากการพึ่งพาเพียร์ยังไม่ได้ติดตั้งสิ่งนี้ต้องการคุณ เพื่อแก้ไขความขัดแย้งระหว่างเพื่อนด้วยตนเองด้วยตนเอง แต่ในระยะยาวสิ่งนี้จะทำให้โอกาสที่คุณจะลงเอยด้วยการขึ้นต่อกันของแพคเกจของคุณจะน้อยลง "
— nextgentech
8
นอกจากนี้ devDependencies ไม่ได้ถูกติดตั้งแบบต่อเนื่องโดยแพ็คเกจที่ขึ้นอยู่ ตัวอย่าง: แพคเกจ A ขึ้นอยู่กับแพคเกจ B แพ็คเกจ B ขึ้นอยู่กับแพ็คเกจ C และ B ยังขึ้นอยู่กับแพ็คเกจ D หากคุณเรียกใช้npm installจากแพ็คเกจ A คุณจะได้รับ B และ C แต่ไม่ใช่ D
— Ben Hutchison
9
มันเป็นสิ่งสำคัญที่จะพูดว่าdevDependenciesยังไม่ได้ติดตั้งเมื่อมีการตั้งค่าNODE_ENV production
— Augusto Franzoia
491

หากคุณไม่ต้องการติดตั้ง devDependencies คุณสามารถใช้ npm install --production

— แกราน Charith
แหล่งที่มา
1
npm install - บันทึกไว้สำหรับการพึ่งพาซอฟต์แวร์หรือไม่
— Vamsi Pavan Mahesh
19
การติดตั้ง NPM จะติดตั้งการอ้างอิงทั้งหมด - บันทึกค่าสถานะใช้เมื่อคุณต้องการเพิ่มโมดูลเฉพาะลงใน package.json ด้วย เช่น: - ติดตั้ง uglify npm - บันทึกจะติดตั้ง uglify ในโฟลเดอร์โครงการของคุณและเพิ่ม uglify ให้กับโครงการ, ไฟล์ package.json
— Gayan Charith
6
และเนื่องจากเรากำลังพูดถึงการพึ่งพาผู้อื่นคุณสามารถใช้ - บันทึก -ev เพื่อบันทึกโมดูลใหม่เป็นผู้พัฒนา ตัวอย่าง: npm install uglify --save-dev
— Mykaelos
9
ตั้งแต่ npm 5 --saveตัวเลือกไม่จำเป็นอีกต่อไป หากคุณทำ "npm install my-package" มันจะเพิ่ม my-package เป็นการอ้างอิงในpackage.jsonไฟล์ของคุณ
— Martin Carel
เพียงแค่ติดตั้ง npm
— สุลต่าน
116

เป็นตัวอย่างมอคค่าโดยปกติจะเป็นผู้อ้างอิงเนื่องจากการทดสอบไม่จำเป็นในการผลิตในขณะที่การแสดงจะเป็นการพึ่งพา

— แดนโคห์น
แหล่งที่มา
4
ฉันจะโน้มตัวไปสู่การทดสอบเป็นการพึ่งพาเนื่องจากคุณอาจต้องการทำการทดสอบตัวเองก่อนที่จะเปิดเซิร์ฟเวอร์การผลิต
47
ฉันขอแนะนำให้ใช้บริการการรวมอย่างต่อเนื่องเช่นฮัดสันหรือ CircleCI ที่รันการทดสอบของคุณแล้วนำไปใช้กับการผลิตหากผ่าน
— Dan Kohn
1
มันอาจยังเกี่ยวข้องกับการทดสอบเซิร์ฟเวอร์จริงเนื่องจากเซิร์ฟเวอร์ CI อาจแตกต่างจากเซิร์ฟเวอร์ prod และความแตกต่างนี้อาจช่วยป้องกันแอปเริ่มต้น ...
— Nicole
2
@ นิโคลทำไมคุณถึงทำให้เซิร์ฟเวอร์การแสดงละครของคุณไม่เหมือนกันในการกำหนดค่าให้กับผลิตภัณฑ์ของคุณ?
— ลูคัส
1
จากนั้นอีกครั้งการเพิ่มการขึ้นต่อกันของการทดสอบในขณะที่การพึ่งพาปกติจะแนะนำไลบรารีจำนวนมากทั้งหมดซึ่งแต่ละไลบรารีอาจล้มเหลวในบางวิธี ฉันจะเอนตัวไปทางเซิร์ฟเวอร์การผลิตที่มีน้ำหนักเบาโดยมีรหัสน้อยที่สุดเท่าที่จะทำได้ จำไว้ว่ารหัสที่ดีที่สุดคือไม่มีรหัส!
— Stijn de Witt
69

การอ้างอิงการ
พึ่งพาที่โครงการของคุณต้องการเรียกใช้เช่นไลบรารีที่มีฟังก์ชันที่คุณโทรจากรหัสของคุณ
มีการติดตั้งแบบเปลี่ยนผ่าน (หากขึ้นอยู่กับ B ขึ้นอยู่กับ C การติดตั้ง npm ใน A จะติดตั้ง B และ C)
ตัวอย่าง: lodash: โครงการของคุณเรียกบางฟังก์ชั่น lodash

devDependencies การ
พึ่งพาที่คุณต้องการในระหว่างการพัฒนาหรือการเปิดตัวเท่านั้นเช่นคอมไพเลอร์ที่ใช้รหัสของคุณและรวบรวมเป็นจาวาสคริปต์กรอบการทดสอบหรือเครื่องกำเนิดเอกสาร
พวกเขาไม่ได้ติดตั้งแบบต่อเนื่อง (ถ้าขึ้นอยู่กับ B dev-ขึ้นอยู่กับ C, การติดตั้ง NPM บน A จะติดตั้ง B เท่านั้น)
ตัวอย่าง: เสียงฮึดฮัด: โครงการของคุณใช้เสียงฮึดฮัดเพื่อสร้างตัวเอง

peerDependencies
Dependencies ที่โครงการของคุณเชื่อมโยงหรือแก้ไขในโครงการแม่มักจะเป็นปลั๊กอินสำหรับห้องสมุดหรือเครื่องมืออื่น ๆ มีวัตถุประสงค์เพียงเพื่อตรวจสอบให้แน่ใจว่าโครงการหลัก (โครงการที่จะขึ้นอยู่กับโครงการของคุณ) มีการพึ่งพาโครงการที่คุณขอ ดังนั้นหากคุณสร้างปลั๊กอิน C ที่เพิ่มฟังก์ชันการทำงานให้กับไลบรารี B ดังนั้นบางคนที่สร้างโครงการ A จะต้องมีการพึ่งพา B หากพวกเขามีการพึ่งพา C
พวกเขาไม่ได้ติดตั้ง (ยกเว้น npm <3) เท่านั้น ตรวจสอบแล้วสำหรับ
ตัวอย่าง: เสี้ยงฮึดฮัด: โครงการของคุณเพิ่มฟังก์ชันการทำงานเพื่อเสี้ยงฮึดฮัดแสดงความไม่พอใจและสามารถนำมาใช้เฉพาะในโครงการที่ใช้เสียงฮึดฮัด

เอกสารนี้อธิบายถึงการพึ่งพาของเพื่อนได้ดีมาก: https://nodejs.org/en/blog/npm/peer-dependencies/

นอกจากนี้เอกสาร npm ยังได้รับการปรับปรุงเมื่อเวลาผ่านไปและขณะนี้มีคำอธิบายที่ดีขึ้นเกี่ยวกับการพึ่งพาประเภทต่างๆ: https://github.com/npm/cli/blob/latest/doc/files/package.json.md#devdependencies

— qwertzguy
แหล่งที่มา
63

หากต้องการบันทึกแพ็กเกจไปยังpackage.jsonเป็นการอ้างอิง dev:

npm install "$package" --save-dev

เมื่อคุณเรียกnpm installมันจะติดตั้งทั้งในและdevDependencies dependenciesเพื่อหลีกเลี่ยงการติดตั้งdevDependenciesรัน:

npm install --production
— Mohammed Safeer
แหล่งที่มา
3
คุณยังสามารถใช้: npm i -S
— Maysara Alhindi
36

มีบางโมดูลและแพ็คเกจที่จำเป็นสำหรับการพัฒนาเท่านั้นซึ่งไม่จำเป็นในการผลิต เหมือนที่มันบอกไว้ในเอกสารประกอบ :

หากมีใครบางคนกำลังวางแผนในการดาวน์โหลดและใช้โมดูลของคุณในโปรแกรมของพวกเขาพวกเขาอาจไม่ต้องการหรือจำเป็นต้องดาวน์โหลดและสร้างการทดสอบภายนอกหรือกรอบงานเอกสารที่คุณใช้ ในกรณีนี้เป็นการดีที่สุดที่จะแสดงรายการเพิ่มเติมเหล่านี้ในแฮชการอ้างอิง

— Amberlamps
แหล่งที่มา
ถ้าคุณใช้งานไฟล์บันเดิล.jsที่ใช้งานจริงเท่านั้น คุณต้องการการพึ่งพาเหล่านั้นหรือไม่?
— RegarBoy
หากคุณใช้งาน bundle.js บนเซิร์ฟเวอร์คุณกำลังทำ webpack ฝั่งเซิร์ฟเวอร์หรือบางสิ่งบางอย่าง ... โปรดตรวจสอบว่าเป็นกรณีนี้หรือไม่เพราะโดยปกติแล้วจะไม่ทำงาน รู้เพราะฉันทำอย่างนั้น) ฉันสงสัยว่า Bundle.js ของคุณนั้นให้บริการกับเบราว์เซอร์และมีรหัสฝั่งไคลเอ็นต์เท่านั้น
— Stijn de Witt
16

คำอธิบายง่ายๆที่ทำให้ฉันชัดเจนยิ่งขึ้นคือ:

เมื่อคุณปรับใช้แอพของคุณจำเป็นต้องติดตั้งโมดูลในการพึ่งพามิฉะนั้นแอพของคุณจะไม่ทำงาน โมดูลใน devDependencies ไม่จำเป็นต้องติดตั้งบนเซิร์ฟเวอร์ที่ใช้งานจริงเนื่องจากคุณไม่ได้พัฒนาบนเครื่องนั้น ลิงค์

— Jyoti Duhan
แหล่งที่มา
2
ดังนั้นหากเรากำลังทำเว็บไซต์และ libs ทั้งหมดในรุ่นจะถูก inlined vendor.js, deps ทั้งหมดของเราควร dev dep ถ้ารหัสคอมไพล์มีการมุ่งมั่นใน repo? และมันก็ควรจะถูกคอมมิชชันเพราะมันแปลกที่คุณต้องคอมไพล์โมดูลไม่ใช่แค่ติดตั้ง (และการทดสอบก็อยู่ที่นี่เพราะการเปลี่ยนแปลงของ submodules สามารถนำไปสู่การถดถอย) ...
— Qwertiy
คำตอบที่ยอดเยี่ยม แต่มีคำถาม? เป็นไปได้ที่ Webpack จะสร้างกลุ่มที่เสียหายหรือไม่? ฉันเดาว่าแพ็คเกจ devDependencies จะไม่ทำงานในเวอร์ชันผลิตภัณฑ์webpack -pฉันหมายถึง โปรดตอบคำถามของฉัน
— AmerllicA
หากมีปัญหาใด ๆ ในขณะที่บิลด์โปรดักชั่นกระบวนการปรับใช้ของคุณควรได้รับการออกแบบในลักษณะที่แสดงข้อผิดพลาด ณ เวลาบิลด์และไม่ส่งรหัสที่เสียหายไปยังการผลิต (เช่นคุณสามารถลองเจนกินส์) ไม่จำเป็นต้องติดตั้งใด ๆ เพิ่มเติมบนเซิร์ฟเวอร์ที่ใช้งานจริง
— Jyoti Duhan
และสิ่งที่เกี่ยวกับการพึ่งพาเพื่อน
— dev27
13

ฉันต้องการที่จะเพิ่มคำตอบในมุมมองของฉันเกี่ยวกับคำอธิบายการพึ่งพาเหล่านี้

  • dependencies ใช้สำหรับการใช้งานโดยตรงใน codebase ของคุณสิ่งที่มักจะจบลงด้วยรหัสการผลิตหรือชิ้นส่วนของรหัส
  • devDependencies ใช้สำหรับกระบวนการสร้างเครื่องมือที่ช่วยให้คุณจัดการวิธีที่รหัสท้ายจะสิ้นสุดลงโมดูลทดสอบของบุคคลที่สาม (เช่นเนื้อหาเว็บแพ็ค)
— Sîrbu Nicolae-Cezar
แหล่งที่มา
สินทรัพย์ css คืออะไร?
— Brian Zelip
8

ในระยะสั้น

  1. การอ้างอิง - npm install <package> --save-prodติดตั้งแพ็กเกจที่แอปพลิเคชันของคุณต้องการในสภาพแวดล้อมการผลิต

  2. DevDependencies - npm install <package> --save-devติดตั้งแพคเกจที่จำเป็นสำหรับการพัฒนาและการทดสอบในท้องถิ่นเท่านั้น

  3. เพียงพิมพ์npm installติดตั้งแพ็คเกจทั้งหมดที่กล่าวถึงใน package.json

ดังนั้นหากคุณกำลังทำงานกับเครื่องคอมพิวเตอร์ของคุณเพียงแค่พิมพ์npm installและดำเนินการต่อ :)

— cherankrish
แหล่งที่มา
6

peerDependenciesไม่ค่อยมีเหตุผลสำหรับฉันจนกว่าฉันจะอ่านตัวอย่างนี้จากโพสต์บล็อกในหัวข้อCiro ดังกล่าวข้างต้น :

สิ่งที่ [ ปลั๊กอิน ] ต้องการคือวิธีการแสดง "การพึ่งพา" เหล่านี้ระหว่างปลั๊กอินและโฮสต์แพ็กเกจ วิธีการพูดบางอย่าง“ ฉันจะทำงานเฉพาะเมื่อเสียบเข้ากับแพ็คเกจโฮสต์ของฉันเวอร์ชัน 1.2.x เท่านั้นดังนั้นหากคุณติดตั้งฉันต้องแน่ใจว่ามันอยู่ข้างโฮสต์ที่เข้ากันได้” เราเรียกว่าความสัมพันธ์นี้เป็นการพึ่งพาจากเพื่อน

ปลั๊กอินคาดหวังโฮสต์รุ่นที่เฉพาะเจาะจง ...

peerDependenciesสำหรับปลั๊กอินไลบรารีที่ต้องใช้ไลบรารี "โฮสต์" เพื่อทำงานของฟังก์ชัน แต่อาจถูกเขียนขึ้นก่อนหน้านี้ที่โฮสต์รุ่นล่าสุดจะวางจำหน่าย

นั่นคือถ้าผมเขียนPluginX v1สำหรับHostLibraryX v3และเดินออกไปไม่มีการรับประกันPluginX v1จะทำงานเมื่อHostLibraryX v4(หรือแม้กระทั่งHostLibraryX v3.0.1 ) จะถูกปล่อยออก

... แต่ปลั๊กอินไม่ได้ขึ้นอยู่กับกับโฮสต์ ...

จากมุมมองของปลั๊กอินจะเพิ่มเฉพาะฟังก์ชั่นในไลบรารีโฮสต์ ฉันไม่ต้องการ "โฮสต์" เพื่อเพิ่มการพึ่งพาปลั๊กอินและปลั๊กอินมักไม่ได้ขึ้นอยู่กับโฮสต์ของพวกเขา หากคุณไม่มีโฮสต์ปลั๊กอินจะไม่ทำอันตรายอะไรเลย

นี่หมายความว่าdependenciesไม่ใช่แนวคิดที่ถูกต้องสำหรับปลั๊กอิน

ยิ่งแย่ไปกว่านั้นหากโฮสต์ของฉันได้รับการปฏิบัติเหมือนเป็นผู้พึ่งพาเราจะจบลงในสถานการณ์นี้ซึ่งโพสต์บล็อกเดียวกันพูดถึง (แก้ไขเล็กน้อยเพื่อใช้โฮสต์ & ปลั๊กอินที่สร้างขึ้นจากคำตอบนี้):

แต่ตอนนี้ [ถ้าเราถือว่า HostLibraryX เวอร์ชันร่วมสมัยเป็นการอ้างอิงสำหรับ PluginX] แสดงnpm installผลในกราฟการพึ่งพาที่ไม่คาดคิดของ

├── HostLibraryX@4.0.0
└─┬ PluginX@1.0.0
  └── HostLibraryX@3.0.0

ฉันจะปล่อยให้ความล้มเหลวเล็กน้อยที่มาจากปลั๊กอินโดยใช้ [HostLibraryX] API ที่แตกต่างจากแอปพลิเคชันหลักในจินตนาการของคุณ

... และโฮสต์ไม่ได้ขึ้นกับปลั๊กอิน ...

... นั่นคือจุดรวมทั้งหมดของปลั๊กอิน ตอนนี้ถ้าโฮสต์ดีพอที่จะรวมข้อมูลการพึ่งพาสำหรับปลั๊กอินทั้งหมดของมันนั่นจะช่วยแก้ปัญหาได้ แต่นั่นก็จะนำเสนอปัญหาทางวัฒนธรรมใหม่ ๆเช่นการจัดการปลั๊กอิน!

จุดทั้งหมดของปลั๊กอินคือพวกเขาสามารถจับคู่โดยไม่ระบุชื่อ ในโลกที่สมบูรณ์แบบการมีโฮสต์จัดการ 'em ทั้งหมดจะเป็นระเบียบเรียบร้อย แต่เราจะไม่ต้องใช้ห้องสมุดแมวฝูง

หากเราไม่ได้ขึ้นอยู่กับลำดับชั้นบางทีเราอาจเป็นเพื่อนร่วมงานซึ่งกันและกัน ...

แต่เรามีแนวคิดของการเป็นเพื่อนร่วมงาน โฮสต์หรือปลั๊กอินไม่อยู่ในที่ฝากข้อมูลการอ้างอิงของอีกรายการ ทั้งคู่อาศัยอยู่ในระดับเดียวกันของกราฟการพึ่งพา

... แต่นี่ไม่ใช่ความสัมพันธ์อัตโนมัติ <<< Moneyball !!!

ถ้าฉันPluginX v1และคาดหวังเพื่อนของ (นั่นคือมีเพื่อนพึ่งพา ) HostLibraryX v3ฉันจะพูดอย่างนั้น หากคุณได้อัปเกรดอัตโนมัติล่าสุดHostLibraryX v4(หมายเหตุว่ารุ่นของ4 ) และมีการPlugin v1ติดตั้งคุณจำเป็นต้องรู้ใช่มั้ย?

npm ไม่สามารถจัดการสถานการณ์นี้ให้ฉันได้ -

"เฮ้ฉันเห็นว่าคุณกำลังใช้อยู่PluginX v1! ฉันกำลังลดระดับรุ่นHostLibraryXจาก v4 เป็น v3 โดยอัตโนมัติหรือไม่"

... หรือ...

"เฮ้ฉันเห็นว่าคุณกำลังใช้งานPluginX v1อยู่ซึ่งคาดว่าHostLibraryX v3คุณจะทิ้งฝุ่นไว้ในระหว่างการอัปเดตครั้งล่าสุดเพื่อความปลอดภัยฉันจะถอนการติดตั้งโดยอัตโนมัติPlugin v1!! 1!

ไม่เป็นไรครับ!

ดังนั้น npm ไม่ได้ มันเตือนคุณถึงสถานการณ์และช่วยให้คุณคิดออกว่าเป็นเพียร์เหมาะสำหรับHostLibraryX v4Plugin v1

Coda

ที่ดีpeerDependencyในการจัดการปลั๊กอินจะทำให้การทำงานของแนวคิดนี้ขึ้นอย่างสังหรณ์ใจในการปฏิบัติ จากโพสต์บล็อกอีกครั้ง ...

คำแนะนำหนึ่งข้อ: ข้อกำหนดการพึ่งพาจากเพื่อนซึ่งแตกต่างจากการอ้างอิงปกติควรผ่อนปรน คุณไม่ควรล็อคการพึ่งพาเพื่อนของคุณลงในเวอร์ชันแพทช์เฉพาะ มันจะน่ารำคาญจริง ๆ หากปลั๊กอินของชัยหนึ่งเพียร์ขึ้นอยู่กับชัย 1.4.1 ในขณะที่อีกปลั๊กอินขึ้นอยู่กับชัย 1.5.0 เพียงเพราะผู้เขียนขี้เกียจและไม่ได้ใช้เวลาในการหาเวอร์ชั่นขั้นต่ำที่แท้จริงของพวกเขาชัย เข้ากันได้กับ

— รัฟฟิน
แหล่งที่มา
4

การพึ่งพา VS การพึ่งพาการพัฒนา

Dev dependencies เป็นโมดูลที่จำเป็นเฉพาะในระหว่างการพัฒนาในขณะที่จำเป็นต้องพึ่งพาที่รันไทม์ หากคุณกำลังปรับใช้แอปพลิเคชันของคุณจะต้องติดตั้งการพึ่งพามิฉะนั้นแอปของคุณจะไม่ทำงาน ไลบรารี่ที่คุณโทรจากรหัสของคุณซึ่งทำให้โปรแกรมสามารถเรียกใช้ได้นั้นจะถือว่าเป็นการอ้างอิง

เช่น - ทำปฏิกิริยา, ทำปฏิกิริยา - dom

ไม่จำเป็นต้องติดตั้งโมดูลการพึ่งพาของ Dev ในเซิร์ฟเวอร์ที่ใช้งานจริงเนื่องจากคุณจะไม่พัฒนาในเครื่อง. com ที่มีรหัสลับจาวาสคริปต์การทดสอบเฟรมเวิร์ก

เช่น - ESLint, Babel, webpack

@FYI,

mod-a
  dev-dependents:
    - mod-b
  dependents:
    - mod-c

mod-d
  dev-dependents:
    - mod-e
  dependents:
    - mod-a

----

npm install mod-d

installed modules:
  - mod-d
  - mod-a
  - mod-c

----

checkout the mod-d code repository

npm install

installed modules:
  - mod-a
  - mod-c
  - mod-e

หากคุณกำลังเผยแพร่ไปยัง npm เป็นสิ่งสำคัญที่คุณต้องใช้การตั้งค่าสถานะที่ถูกต้องสำหรับโมดูลที่ถูกต้อง หากเป็นสิ่งที่โมดูล npm ของคุณต้องการใช้งานให้ใช้แฟล็ก "--save" เพื่อบันทึกโมดูลเป็นการพึ่งพา หากเป็นสิ่งที่โมดูลของคุณไม่จำเป็นต้องใช้งาน แต่จำเป็นสำหรับการทดสอบให้ใช้แฟล็ก "--save-dev"

# For dependent modules
npm install dependent-module --save

# For dev-dependent modules
npm install development-module --save-dev
— Selva Ganapathi
แหล่งที่มา
1

เมื่อพยายามที่จะกระจายแพคเกจ NPM dependenciesที่คุณควรหลีกเลี่ยงการใช้ แต่คุณต้องพิจารณาเพิ่มมันเข้าไปในหรือเอาออกจากpeerDependenciesdependencies

— Melchia
แหล่งที่มา
1

ฉันพบคำอธิบายง่ายๆ

คำตอบสั้น ๆ :

การอ้างอิง "... คือสิ่งที่โครงการของคุณต้องการเพื่อให้สามารถทำงานในการผลิตจริง ๆ "

devDependencies "... เป็นสิ่งที่คุณต้องการในระหว่างการพัฒนา"

peerDependencies "ถ้าคุณต้องการสร้างและเผยแพร่ไลบรารี่ของคุณเองเพื่อให้สามารถใช้เป็นอ้างอิงได้"

รายละเอียดเพิ่มเติมในโพสต์นี้: https://code-trotter.com/web/dependencies-vs-devdependencies-vs-peerdependencies

— ใช้ความต้องการความช่วยเหลือ
แหล่งที่มา
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.