NPM กับ Bower เทียบกับ Browserify เทียบกับ Gulp vs. Grunt vs. Webpack


1886

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

  • npm& bowerเป็นผู้จัดการแพคเกจ พวกเขาเพียงแค่ดาวน์โหลดการอ้างอิงและไม่ทราบวิธีการสร้างโครงการด้วยตัวเอง สิ่งที่พวกเขารู้คือการโทรwebpack/ gulp/ gruntหลังจากดึงการอ้างอิงทั้งหมด
  • bowerเป็นเหมือนnpmแต่สร้างต้นไม้พึ่งพาอาศัยแบบแบน (ไม่เหมือนต้นไม้npmที่เรียกซ้ำ) หมายถึงการnpmดึงการอ้างอิงสำหรับการพึ่งพาแต่ละครั้ง (อาจดึงเหมือนกันสองสามครั้ง) ในขณะที่bowerคาดว่าคุณจะรวมการพึ่งพาย่อยด้วยตนเอง บางครั้งbowerและnpmใช้ร่วมกันสำหรับ front-end และ back-end ตามลำดับ (เนื่องจากเมกะไบต์แต่ละตัวอาจมีปัญหาใน front-end)
  • gruntและgulpเป็นนักวิ่งภารกิจที่จะทำให้ทุกอย่างเป็นไปโดยอัตโนมัติ (เช่นการคอมไพล์ CSS / Sass, ปรับภาพให้ดีที่สุด, สร้างมัดและย่อขนาด / transpile)
  • gruntเทียบกับgulp(เป็นเหมือนmavenเทียบgradleหรือการกำหนดค่าเมื่อเทียบกับรหัส) ฮึดฮัดจะขึ้นอยู่กับการกำหนดค่างานแยกต่างหากแต่ละงานเปิด / จัดการ / ปิดไฟล์ อึกต้องใช้จำนวนน้อยรหัสและเป็นไปตามกระแสโหนดซึ่งช่วยให้มันสามารถสร้างไปป์ที่โยงโซ่ (w / o เปิดไฟล์เดียวกันอีกครั้ง) และทำให้มันเร็วขึ้น
  • webpack( webpack-dev-server) - สำหรับฉันมันเป็นงานที่มีการโหลดใหม่ของการเปลี่ยนแปลงที่ช่วยให้คุณลืมเกี่ยวกับนักดู JS / CSS ทั้งหมด
  • npm/ bower+ ปลั๊กอินอาจแทนที่ runners task ความสามารถของพวกเขามักจะตัดกันดังนั้นจึงมีความหมายที่แตกต่างกันหากคุณต้องการใช้gulp/ gruntมากกว่าnpm+ ปลั๊กอิน แต่นักวิ่งงานจะดีกว่าสำหรับงานที่ซับซ้อนอย่างแน่นอน (เช่น "ในแต่ละบิลด์สร้างบันเดิล transpile จาก ES6 ถึง ES5 รันที่เบราว์เซอร์อีมูเลเตอร์ทั้งหมดสร้างภาพหน้าจอ
  • browserifyอนุญาตให้โมดูลโหนดแพ็กเกจสำหรับเบราว์เซอร์ browserifyVS node's requireเป็นจริงAMD VS CommonJS

คำถาม:

  1. webpack& คือwebpack-dev-serverอะไร เอกสารอย่างเป็นทางการกล่าวว่ามันเป็นโมดูลรวม แต่สำหรับฉันมันเป็นเพียงงานนักวิ่ง ความแตกต่างคืออะไร?
  2. คุณจะใช้browserifyที่ไหน เราไม่สามารถทำเช่นเดียวกันกับการนำเข้า node / ES6 ได้หรือไม่
  3. เมื่อใดที่คุณจะใช้gulp/ gruntมากกว่าnpm+ ปลั๊กอิน
  4. โปรดระบุตัวอย่างเมื่อคุณจำเป็นต้องใช้ชุดค่าผสม

52
เวลาที่จะเพิ่มในการยกเลิก ? 😝
gman

167
นี่เป็นคำถามที่สมเหตุสมผลมาก เว็บ devs หลอกเหมือนผมสะดุดทุกแพคเกจที่จะดำเนินการในรูปแบบรายสัปดาห์ ..
ไซมอน Dirmeier


41
@Fisherman ฉันทั้งหมดใหม่นี้และดูเหมือนว่าสมบูรณ์ถั่ว ...
เดวิด Stosik

13
@Fisherman ความคิดเห็น "แนะนำ" ที่ฉันเพิ่งอ่านแย่ยิ่งขึ้นไปอีก! D: ฉันแค่ต้องการสร้างหน้าสแตติก fricking ที่ใช้คู่ของ CSS / JS libs และจะได้รับประโยชน์จากการมีเครื่องมือที่สามารถคอมไพล์ด้วยกันได้ ... โยนเครื่องมือสร้างเทมเพล็ตลงในส่วนที่เหลือของ Ctrl-C / Ctrl-V นิ้วมือและนั่นจะสมบูรณ์แบบ ... และยังเป็นเวลาหลายชั่วโมงมันยังคงพยายามหาวิธีที่จะไป ...
David Stosik

คำตอบ:


1028

Webpack และ Browserify

Webpack และ Browserify ทำงานในลักษณะเดียวกันซึ่งกำลังประมวลผลรหัสของคุณเพื่อใช้ในสภาพแวดล้อมเป้าหมาย (โดยส่วนใหญ่จะเป็นเบราว์เซอร์ แต่คุณสามารถกำหนดเป้าหมายสภาพแวดล้อมอื่น ๆ เช่นโหนด) ผลลัพธ์ของการประมวลผลดังกล่าวเป็นสคริปต์ชุดประกอบหนึ่งชุดขึ้นไปซึ่งเหมาะสมกับสภาพแวดล้อมเป้าหมาย

ตัวอย่างเช่นสมมติว่าคุณเขียนรหัส ES6 แบ่งออกเป็นโมดูลและต้องการให้สามารถเรียกใช้ได้ในเบราว์เซอร์ หากโมดูลเหล่านั้นเป็นโมดูลโหนดเบราว์เซอร์จะไม่เข้าใจเนื่องจากมีอยู่ในสภาพแวดล้อมของโหนดเท่านั้น โมดูล ES6 จะไม่ทำงานในเบราว์เซอร์รุ่นเก่าเช่น IE11 ยิ่งกว่านั้นคุณอาจใช้คุณลักษณะภาษาทดลอง (ข้อเสนอต่อไปของ ES) ที่เบราว์เซอร์ยังไม่ได้ใช้งานดังนั้นการเรียกใช้สคริปต์ดังกล่าวอาจทำให้เกิดข้อผิดพลาด เครื่องมือเช่น Webpack และ Browserify แก้ปัญหาเหล่านี้โดยการแปลรหัสดังกล่าวเป็นรูปแบบที่เบราว์เซอร์สามารถใช้งานได้ ยิ่งไปกว่านั้นพวกเขายังสามารถใช้การเพิ่มประสิทธิภาพที่หลากหลายบนบันเดิลเหล่านั้นได้

อย่างไรก็ตาม Webpack และ Browserify แตกต่างกันในหลาย ๆ วิธี Webpack มีเครื่องมือมากมายโดยค่าเริ่มต้น (เช่นรหัสแยก) ในขณะที่ Browserify สามารถทำเช่นนี้เพียงหลังจากการดาวน์โหลดปลั๊กอิน แต่ใช้ทั้งนำไปสู่ผลลัพธ์ที่คล้ายกันมาก มันมาลงที่การตั้งค่าส่วนตัว (Webpack เป็นเทรนด์) Btw, Webpack ไม่ใช่ task task มันเป็นเพียงตัวประมวลผลของไฟล์ของคุณ (มันประมวลผลโดยเรียกว่า loader และ plugins) และมันสามารถรันได้ (โดยวิธีอื่น ๆ ) โดย task runner


เซิร์ฟเวอร์ Webpack Dev

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


นักวิ่งงานเทียบกับสคริปต์ NPM

ฉันใช้ Gulp เพื่อความกระชับและการเขียนงานง่าย ๆ แต่ภายหลังฉันพบว่าฉันไม่ต้องการ Gulp หรือ Grunt เลย ทุกสิ่งที่ฉันต้องการเคยทำได้โดยใช้สคริปต์ NPM เพื่อเรียกใช้เครื่องมือของบุคคลที่สามผ่าน API ของพวกเขา การเลือกระหว่างสคริปต์ Gulp, Grunt หรือ NPM ขึ้นอยู่กับรสนิยมและประสบการณ์ของทีมของคุณ

ในขณะที่งานใน Gulp หรือ Grunt นั้นอ่านง่ายแม้สำหรับผู้ที่ไม่คุ้นเคยกับ JS แต่มันก็เป็นเครื่องมืออีกอย่างที่ต้องใช้และเรียนรู้และฉันเองชอบที่จะ จำกัด การพึ่งพาและทำสิ่งต่าง ๆ ให้ง่าย ในทางกลับกันการแทนที่งานเหล่านี้ด้วยการรวมกันของสคริปต์ NPM และ (propably JS) สคริปต์ที่เรียกใช้เครื่องมือของบุคคลที่สามเหล่านั้น (เช่นการกำหนดค่าสคริปต์ Node และการเรียกใช้rimrafเพื่อการทำความสะอาด) อาจมีความท้าทายมากขึ้น แต่ในกรณีส่วนใหญ่ทั้งสามมีความเท่าเทียมกันในแง่ของผลลัพธ์ของพวกเขา


ตัวอย่าง

สำหรับตัวอย่างฉันขอแนะนำให้คุณดูที่โปรเจ็กต์ React นี้ซึ่งแสดงให้คุณเห็นการรวมกันของสคริปต์ NPM และ JS ที่ครอบคลุมกระบวนการสร้างและปรับใช้ทั้งหมด คุณสามารถค้นหาสคริปต์ NPM ผู้ที่อยู่ในในโฟลเดอร์รากในชื่อคุณสมบัติpackage.json มีคุณส่วนใหญ่จะพบคำสั่งเช่นscripts babel-node tools/run startBabel-node เป็นเครื่องมือ CLI (ไม่ได้มีไว้สำหรับการใช้งานจริง) ซึ่งในตอนแรกจะรวบรวมไฟล์ ES6 tools/run(ไฟล์ run.js ที่อยู่ในเครื่องมือ ) - โดยทั่วไปแล้วเป็นโปรแกรมอรรถประโยชน์สำหรับนักวิ่ง นักวิ่งนี้รับฟังก์ชั่นเป็นอาร์กิวเมนต์และดำเนินการซึ่งในกรณีนี้คือstart- ยูทิลิตี้อื่น (start.js) รับผิดชอบการรวมไฟล์ต้นฉบับ (ทั้งไคลเอนต์และเซิร์ฟเวอร์) และการเริ่มต้นแอพพลิเคชันและเซิร์ฟเวอร์การพัฒนา (เซิร์ฟเวอร์ dev อาจเป็น Webpack Dev Server หรือ Browsersync)

พูดอย่างแม่นยำยิ่งขึ้นstart.jsสร้างทั้งไคลเอนต์และเซิร์ฟเวอร์รวมกันเริ่มเซิร์ฟเวอร์ด่วนและหลังจากการเปิดตัวที่ประสบความสำเร็จในการเริ่มต้นการซิงค์เบราว์เซอร์ซึ่งในขณะที่เขียนเป็นเช่นนี้ (โปรดดูปฏิกิริยาเริ่มต้นสำหรับรหัสล่าสุด)

const bs = Browsersync.create();  
bs.init({
      ...(DEBUG ? {} : { notify: false, ui: false }),

      proxy: {
        target: host,
        middleware: [wpMiddleware, ...hotMiddlewares],
      },

      // no need to watch '*.js' here, webpack will take care of it for us,
      // including full page reloads if HMR won't work
      files: ['build/content/**/*.*'],
}, resolve)

ส่วนที่สำคัญคือproxy.targetที่ที่พวกเขาตั้งที่อยู่เซิร์ฟเวอร์ที่พวกเขาต้องการพร็อกซี่ซึ่งอาจhttp: // localhost: 3000และ Browsersync เริ่มต้นเซิร์ฟเวอร์ฟังบนhttp: // localhost: 3001ซึ่งสินทรัพย์ที่สร้างขึ้นจะให้บริการกับการเปลี่ยนแปลงอัตโนมัติ การตรวจจับและการเปลี่ยนโมดูลร้อน ดังที่คุณเห็นมีคุณสมบัติการกำหนดค่าอื่นที่filesมีแต่ละไฟล์หรือรูปแบบการตรวจสอบ Browser-sync สำหรับการเปลี่ยนแปลงและรีโหลดเบราว์เซอร์ถ้ามีบางอย่างเกิดขึ้น แต่ตามความเห็นบอกว่า Webpack ดูแลการดูแหล่ง js ด้วย HMR ด้วยตนเอง ที่นั่น

ตอนนี้ฉันไม่มีตัวอย่างที่เทียบเท่าของการกำหนดค่า Grunt หรือ Gulp แต่ด้วย Gulp (และค่อนข้างคล้ายกับ Grunt) คุณจะเขียนงานแต่ละงานใน gulpfile.js เช่น

gulp.task('bundle', function() {
  // bundling source files with some gulp plugins like gulp-webpack maybe
});

gulp.task('start', function() {
  // starting server and stuff
});

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


3
คำตอบที่ดี! คุณช่วยอธิบาย pls ว่า webpack / browserify จัดการโมดูลโหนดที่เบราว์เซอร์ได้ไหม?
VB_

4
Webpack ประกอบการพึ่งพา (ค่าโมดูลที่ส่งออก) เป็นวัตถุ (installedModules) แต่ละโมดูลจึงเป็นคุณสมบัติของวัตถุนั้นและชื่อของคุณสมบัติดังกล่าวแสดงถึงรหัส (เช่น 1, 2, 3 ... ฯลฯ ) ทุกครั้งที่คุณต้องการโมดูลดังกล่าวในแหล่งที่มาของคุณ webpack แปลงค่าเป็นการเรียกใช้ฟังก์ชันด้วยรหัสโมดูลในอาร์กิวเมนต์ (เช่น __webpack_require __ (1)) ซึ่งส่งคืนการอ้างอิงที่ถูกต้องตามการค้นหาในโมดูลที่ติดตั้งโดยโมดูล id ฉันไม่แน่ใจว่า Browserify จัดการอย่างไร
Dan Macák

@Dan Skočdopoleคุณช่วยอธิบายเพิ่มเติมได้ไหม?
Asim KT

1
ฉันไม่เห็นด้วยกับการนำเสนอการใช้งานพื้นฐานของ gulp หรือ grunt ทั้งสองนี้ง่ายต่อการเปรียบเทียบโดยใช้ google, webpack-dev-server ต้องเข้าใจ webpack ก่อนและมันอยู่นอกขอบเขตของคำถาม / คำตอบนี้ แต่ฉันได้นำเสนอ Browsersync config บางตัว คุณพูดถูกเกี่ยวกับชุดเริ่มต้นและฉันก็อธิบายเพิ่มเติม
Dan Macák

5
+1 สำหรับการลดการพึ่งพาเพื่อทำให้สิ่งต่าง ๆ ง่ายขึ้นแทนที่จะทำตามความคิดเห็นที่นิยม (เพิ่มเติม) ที่จะต้องใช้แพ็คเกจใหม่ทุกอัน!
madannes

675

อัปเดตตุลาคม 2561

หากคุณยังไม่แน่ใจเกี่ยวกับ Front-end dev สามารถเข้าไปดูแหล่งข้อมูลที่ยอดเยี่ยมได้ที่นี่

https://github.com/kamranahmedse/developer-roadmap

อัปเดตมิถุนายน 2561

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

https://medium.com/the-node-js-collection/modern-javascript-explained-for-dinosaurs-f695e9747b70

อัปเดตกรกฎาคม 2560

เมื่อเร็ว ๆ นี้ฉันพบคู่มือที่ครอบคลุมจริงๆจากทีม Grab เกี่ยวกับวิธีการพัฒนาส่วนหน้าในปี 2560 คุณสามารถตรวจสอบได้จากด้านล่าง

https://github.com/grab/front-end-guide


ฉันเคยค้นหามันมาระยะหนึ่งแล้วเนื่องจากมีเครื่องมือมากมายที่นั่นและแต่ละอันมีประโยชน์ต่อเราในด้านที่แตกต่างกัน Browserify, Webpack, jspm, Grunt and Gulpชุมชนมีการแบ่งออกทั่วเครื่องมือเช่น คุณอาจได้ยินเกี่ยวกับYeoman or Slushนอกจากนี้คุณอาจได้ยินเกี่ยวกับนั่นไม่ใช่ปัญหาจริงๆมันเป็นเพียงความสับสนสำหรับทุกคนที่พยายามเข้าใจเส้นทางที่ชัดเจนไปข้างหน้า

อย่างไรก็ตามฉันต้องการมีส่วนร่วม

1. ผู้จัดการแพคเกจ

ผู้จัดการแพคเกจทำให้การติดตั้งและอัปเดตการอ้างอิงโครงการง่ายขึ้นนั่นคือไลบรารีเช่น: jQuery, Bootstrapและอื่น ๆ ทุกสิ่งที่ใช้บนไซต์ของคุณ

เรียกดูเว็บไซต์ห้องสมุดทั้งหมดดาวน์โหลดและแกะที่เก็บถาวรคัดลอกไฟล์ลงในโครงการ - ทั้งหมดนี้จะถูกแทนที่ด้วยคำสั่งไม่กี่ใน terminal

  • NPMย่อมาจาก: Node JS package managerช่วยให้คุณจัดการไลบรารีทั้งหมดที่ซอฟต์แวร์ของคุณเชื่อถือได้ คุณจะกำหนดความต้องการของคุณในไฟล์ชื่อpackage.jsonและเรียกใช้npm installในบรรทัดคำสั่ง ... จากนั้นแบงกแพคเกจของคุณจะถูกดาวน์โหลดและพร้อมใช้งาน สามารถใช้ได้ทั้งกับfront-end and back-endห้องสมุด

  • Bower: สำหรับการจัดการแพ็คเกจ front-end แนวคิดนี้เหมือนกันกับ NPM ไลบรารีทั้งหมดของคุณจะถูกเก็บไว้ในไฟล์ชื่อbower.jsonแล้วเรียกใช้bower installในบรรทัดคำสั่ง

ความแตกต่างที่ใหญ่ที่สุดระหว่างBowerและNPMคือ NPM ทำแผนผังการพึ่งพาซ้อนกันในขณะที่ Bower ต้องการต้นไม้พึ่งพาแบบแบนดังนี้

ข้อความจากBower และ npm แตกต่างกันอย่างไร

NPM

project root
[node_modules] // default directory for dependencies
 -> dependency A
 -> dependency B
    [node_modules]
    -> dependency A

 -> dependency C
    [node_modules]
    -> dependency B
      [node_modules]
       -> dependency A 
    -> dependency D

ซุ้มไม้ในสวน

project root
[bower_components] // default directory for dependencies
 -> dependency A
 -> dependency B // needs A
 -> dependency C // needs B and D
 -> dependency D

มีการอัปเดตบางอย่างnpm 3 Duplication and Deduplicationโปรดเปิดเอกสารเพื่อดูรายละเอียดเพิ่มเติม

  • Yarn: ผู้จัดการแพคเกจใหม่สำหรับJavaScript การตีพิมพ์โดยFacebookเมื่อเร็ว ๆ NPMนี้มีข้อได้เปรียบมากขึ้นเมื่อเทียบกับ และด้วย Yarn คุณยังสามารถใช้ทั้งสองอย่างNPMและBowerรีจีสตรีเพื่อดึงแพ็คเกจ หากคุณได้ติดตั้งแพคเกจก่อนสร้างสำเนาแคชที่อำนวยความสะดวกyarnoffline package installs

  • jspm: เป็นผู้จัดการแพ็กเกจสำหรับSystemJSโหลดโมดูลสากลที่สร้างขึ้นจากES6โหลดเดอร์โมดูลแบบไดนามิก ไม่ใช่ผู้จัดการแพ็กเกจใหม่ที่มีชุดกฎของตัวเอง แต่ทำงานได้ดีกว่าแหล่งที่มาของแพ็คเกจ ออกจากกล่องจะทำงานร่วมกับและGitHub npmเนื่องจากBowerแพ็คเกจส่วนใหญ่นั้นใช้พื้นฐานGitHubเราจึงสามารถติดตั้งแพ็คเกจเหล่านั้นได้jspmเช่นกัน มีรีจิสตรีที่แสดงรายการแพ็คเกจส่วนใหญ่ที่ใช้กันทั่วไปเพื่อการติดตั้งที่ง่ายขึ้น

ดูความแตกต่างระหว่างBowerและjspm: Package Manager: Bower vs jspm


2. โมดูล Loader / Bundling

โครงการส่วนใหญ่ในทุกขนาดจะมีการแบ่งรหัสระหว่างไฟล์จำนวนหนึ่ง คุณสามารถรวมแต่ละไฟล์ด้วย<script>แท็กแต่ละรายการอย่างไรก็ตาม<script>สร้างการเชื่อมต่อ http ใหม่และสำหรับไฟล์ขนาดเล็ก - ซึ่งเป็นเป้าหมายของ modularity - เวลาในการตั้งค่าการเชื่อมต่ออาจใช้เวลานานกว่าการถ่ายโอนข้อมูลอย่างมีนัยสำคัญ ในขณะที่สคริปต์กำลังดาวน์โหลดจะไม่มีการเปลี่ยนแปลงเนื้อหาในหน้า

  • ปัญหาของเวลาในการดาวน์โหลดสามารถแก้ไขได้โดยการต่อกลุ่มโมดูลอย่างง่ายเข้าด้วยกันเป็นไฟล์เดียวและลดขนาดไฟล์ลง

เช่น

<head>
    <title>Wagon</title>
    <script src=“build/wagon-bundle.js”></script>
</head>
  • ประสิทธิภาพนั้นมาจากความยืดหยุ่น หากโมดูลของคุณมีการพึ่งพาระหว่างกันการขาดความยืดหยุ่นนี้อาจเป็นสิ่งที่ต้องทำก่อน

เช่น

<head>
    <title>Skateboard</title>
    <script src=“connectors/axle.js”></script>
    <script src=“frames/board.js”></script>
    <!-- skateboard-wheel and ball-bearing both depend on abstract-rolling-thing -->
    <script src=“rolling-things/abstract-rolling-thing.js”></script>
    <script src=“rolling-things/wheels/skateboard-wheel.js”></script>
    <!-- but if skateboard-wheel also depends on ball-bearing -->
    <!-- then having this script tag here could cause a problem -->
    <script src=“rolling-things/ball-bearing.js”></script>
    <!-- connect wheels to axle and axle to frame -->
    <script src=“vehicles/skateboard/our-sk8bd-init.js”></script>
</head>

คอมพิวเตอร์สามารถทำได้ดีกว่าที่คุณสามารถทำได้และนั่นคือเหตุผลที่คุณควรใช้เครื่องมือเพื่อรวมทุกอย่างไว้ในไฟล์เดียวโดยอัตโนมัติ

แล้วเราได้ยินเกี่ยวกับRequireJS, Browserify, WebpackและSystemJS

  • RequireJS: เป็นตัวJavaScriptโหลดไฟล์และโมดูล มันเป็นที่เหมาะสำหรับการใช้งานในเบราว์เซอร์ แต่ก็สามารถนำมาใช้ในสภาพแวดล้อม JavaScript อื่น ๆ Nodeเช่น

เช่นmyModule.js

// package/lib is a dependency we require
define(["package/lib"], function (lib) {

    // behavior for our module
    function foo() {
        lib.log( "hello world!" );
    }

    // export (expose) foo to other modules as foobar
    return {
        foobar: foo
    }
});

ในmain.jsเราสามารถนำเข้าmyModule.jsเป็นการพึ่งพาและใช้งานได้

require(["package/myModule"], function(myModule) {
    myModule.foobar();
});

และจากนั้นในของเราเราสามารถอ้างที่จะใช้กับHTMLRequireJS

<script src=“app/require.js data-main=“main.js ></script>

อ่านเพิ่มเติมเกี่ยวกับCommonJSและAMDทำความเข้าใจได้ง่าย ความสัมพันธ์ระหว่าง CommonJS, AMD และ RequireJS?

  • Browserify: กำหนดให้ใช้งานCommonJSโมดูลที่จัดรูปแบบในเบราว์เซอร์ ดังนั้นBrowserifyเครื่องมือโหลดมอดูลไม่มากเท่าโมดูลบันเดอร์: Browserifyเป็นเครื่องมือ build-time ทั้งหมดสร้างมัดของรหัสซึ่งสามารถโหลดฝั่งไคลเอ็นต์ได้

เริ่มต้นด้วยเครื่องสร้างที่ติดตั้งโหนด & npm และรับแพ็คเกจ:

npm install -g save-dev browserify

เขียนโมดูลของคุณในCommonJSรูปแบบ

//entry-point.js
var foo = require('../foo.js');
console.log(foo(4));

และเมื่อมีความสุขออกคำสั่งเพื่อมัด:

browserify entry-point.js -o bundle-name.js

Browserify ค้นหาการอ้างอิงจุดเข้าใช้งานทั้งหมดซ้ำและรวมเข้าด้วยกันเป็นไฟล์เดียว:

<script src=”bundle-name.js”></script>
  • Webpack: มันรวมสินทรัพย์สแตติกทั้งหมดของคุณรวมถึงJavaScriptรูปภาพ, CSS และอื่น ๆ ไว้ในไฟล์เดียว นอกจากนี้ยังช่วยให้คุณสามารถประมวลผลไฟล์ผ่านโหลดเดอร์ประเภทต่างๆ คุณสามารถเขียนJavaScriptด้วยCommonJSหรือAMDโมดูลไวยากรณ์ของคุณ มันโจมตีปัญหาการสร้างในลักษณะพื้นฐานแบบบูรณาการและความเห็น ในBrowserifyคุณใช้Gulp/Gruntและรายการการแปลงและปลั๊กอินที่มีความยาวเพื่อให้งานเสร็จสมบูรณ์ Webpackให้พลังงานเพียงพอที่จะออกจากกล่องที่คุณไม่ต้องการGruntหรือGulpโดยทั่วไป

การใช้งานขั้นพื้นฐานนั้นง่ายกว่าที่คิด ติดตั้ง Webpack เช่น Browserify:

npm install -g save-dev webpack

และส่งคำสั่งให้เป็นจุดเข้าใช้งานและไฟล์เอาต์พุต:

webpack ./entry-point.js bundle-name.js
  • SystemJS: เป็นโหลดเดอร์โมดูลที่สามารถอิมพอร์ตโมดูล ณ รันไทม์ในรูปแบบที่นิยมใด ๆ ที่ใช้ในปัจจุบัน ( CommonJS, UMD, AMD, ES6) มันถูกสร้างขึ้นที่ด้านบนของES6โมดูลตัวโหลดโพลีฟิลและฉลาดพอที่จะตรวจจับรูปแบบที่ใช้และจัดการกับมันอย่างเหมาะสม SystemJSยังสามารถ transpile รหัส ES6 (ด้วยBabelหรือTraceur) หรือภาษาอื่น ๆ เช่นTypeScriptและการCoffeeScriptใช้ปลั๊กอิน

ต้องการทราบว่าอะไรคือnode moduleสาเหตุใดและทำไมจึงไม่ปรับให้เข้ากับเบราว์เซอร์

บทความที่เป็นประโยชน์เพิ่มเติม:


ทำไมjspmและSystemJS?

หนึ่งในเป้าหมายหลักของการES6แยกส่วนคือการทำให้ง่ายต่อการติดตั้งและใช้ไลบรารี Javascript จากที่ใดก็ได้บนอินเทอร์เน็ต ( Github, npmและอื่น ๆ ) ต้องการเพียงสองสิ่งเท่านั้น:

  • คำสั่งเดียวในการติดตั้งไลบรารี
  • โค้ดหนึ่งบรรทัดเพื่อนำเข้าไลบรารีและใช้งาน

ด้วยjspmคุณสามารถทำได้

  1. ติดตั้งไลบรารีด้วยคำสั่ง: jspm install jquery
  2. นำเข้าไลบรารีด้วยรหัสบรรทัดเดียวไม่จำเป็นต้องอ้างอิงภายนอกภายในไฟล์ HTML ของคุณ

display.js

var $ = require('jquery'); 

$('body').append("I've imported jQuery!");
  1. จากนั้นคุณกำหนดค่าสิ่งเหล่านี้ภายในSystem.config({ ... })ก่อนที่จะนำเข้าโมดูลของคุณ โดยปกติเมื่อเรียกใช้jspm initจะมีชื่อไฟล์config.jsสำหรับจุดประสงค์นี้

  2. เพื่อให้สคริปต์เหล่านี้ทำงานเราจำเป็นต้องโหลดsystem.jsและconfig.jsในหน้า HTML หลังจากนั้นเราจะโหลดdisplay.jsไฟล์โดยใช้SystemJSโมดูลโหลดเดอร์

index.html

<script src="jspm_packages/system.js"></script>
<script src="config.js"></script>
<script>
  System.import("scripts/display.js");
</script>

ตั้งข้อสังเกต: คุณยังสามารถใช้npmกับWebpackเป็น Angular 2 ได้ใช้มัน ตั้งแต่jspmได้รับการพัฒนาเพื่อรวมเข้ากับSystemJSและทำงานได้เหนือnpmแหล่งที่มีอยู่ดังนั้นคำตอบของคุณขึ้นอยู่กับคุณ


3. นักวิ่ง

นักวิ่งงานและเครื่องมือสร้างเป็นเครื่องมือบรรทัดคำสั่งเป็นหลัก ทำไมเราต้องใช้พวกเขาในหนึ่งคำ: อัตโนมัติ งานน้อยลงที่คุณต้องทำเมื่อดำเนินงานซ้ำ ๆ เช่นminification การรวบรวมการทดสอบหน่วย lintingซึ่งก่อนหน้านี้เรามีค่าใช้จ่ายจำนวนมากที่จะทำกับบรรทัดคำสั่งหรือแม้กระทั่งด้วยตนเอง

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

ทุกงานในGruntคือชุดของการกำหนดค่าปลั๊กอินที่แตกต่างกันซึ่งจะถูกดำเนินการอย่างต่อเนื่องอย่างอิสระและต่อเนื่อง

grunt.initConfig({
  clean: {
    src: ['build/app.js', 'build/vendor.js']
  },

  copy: {
    files: [{
      src: 'build/app.js',
      dest: 'build/dist/app.js'
    }]
  }

  concat: {
    'build/app.js': ['build/vendors.js', 'build/app.js']
  }

  // ... other task configurations ...

});

grunt.registerTask('build', ['clean', 'bower', 'browserify', 'concat', 'copy']);
  • Gulp: ทำงานอัตโนมัติเหมือนGruntแต่แทนที่จะตั้งค่าคุณสามารถเขียนJavaScriptด้วยสตรีมเหมือนเป็นแอปพลิเคชันโหนด ชอบวันนี้

นี่คือการGulpประกาศงานตัวอย่าง

//import the necessary gulp plugins
var gulp = require('gulp');
var sass = require('gulp-sass');
var minifyCss = require('gulp-minify-css');
var rename = require('gulp-rename');

//declare the task
gulp.task('sass', function(done) {
  gulp.src('./scss/ionic.app.scss')
    .pipe(sass())
    .pipe(gulp.dest('./www/css/'))
    .pipe(minifyCss({
      keepSpecialComments: 0
    }))
    .pipe(rename({ extname: '.min.css' }))
    .pipe(gulp.dest('./www/css/'))
    .on('end', done);
});

ดูเพิ่มเติมได้ที่: https://medium.com/@preslavrachev/gulp-vs-grunt-why-one-why-the-other-f5d3b398edc4#.fte0nahri


4. เครื่องมือนั่งร้าน

  • Slush and Yeoman: คุณสามารถสร้างโครงการเริ่มต้นได้ ตัวอย่างเช่นคุณวางแผนที่จะสร้างต้นแบบด้วย HTML และ SCSS จากนั้นแทนที่จะสร้างโฟลเดอร์ด้วยตนเองเช่น scss, css, img, แบบอักษร คุณสามารถติดตั้งyeomanและรันสคริปต์อย่างง่าย จากนั้นทุกอย่างที่นี่เพื่อคุณ

หาข้อมูลเพิ่มเติมได้ที่นี่

npm install -g yo
npm install --global generator-h5bp
yo h5bp

ดูเพิ่มเติมได้ที่: https://www.quora.com/What-are-the-differences-between-NPM-Bower-Grunt-Gulp-Webpack-Browserify-Slush-Yeoman-and- Express


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


64

ตกลงพวกเขาทั้งหมดมีความคล้ายคลึงกันพวกเขาทำสิ่งเดียวกันสำหรับคุณในวิธีที่แตกต่างและคล้ายกันฉันแบ่งพวกเขาออกเป็น3 กลุ่มหลักดังนี้:


1) โมดูลตัวรวม

webpack และ browserify เป็นที่นิยมใช้งานได้เหมือน task runners แต่มีความยืดหยุ่นมากกว่านั้นมันจะรวมทุกอย่างเข้าด้วยกันตามการตั้งค่าของคุณดังนั้นคุณสามารถชี้ไปที่ผลลัพธ์เป็น bundle.js เช่นในไฟล์เดียวรวมถึง CSS และ Javascript สำหรับ รายละเอียดเพิ่มเติมของแต่ละรายการดูที่รายละเอียดด้านล่าง:

webpack

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

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

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

เพิ่มเติมที่นี่

browserify

Browserify เป็นเครื่องมือพัฒนาที่ช่วยให้เราสามารถเขียนโมดูลสไตล์ node.js ที่รวบรวมเพื่อใช้ในเบราว์เซอร์ เช่นเดียวกับโหนดเราเขียนโมดูลของเราในไฟล์แยกการส่งออกวิธีการและคุณสมบัติภายนอกโดยใช้โมดูลการส่งออกและตัวแปรส่งออก เรายังสามารถต้องการโมดูลอื่น ๆ โดยใช้ฟังก์ชั่น require และถ้าเราไม่ใช้พา ธ สัมพัทธ์มันจะแก้ไขโมดูลในไดเรกทอรี node_modules

เพิ่มเติมที่นี่


2) นักวิ่งงาน

gulp และ grunt คือ task runners โดยทั่วไปสิ่งที่พวกเขาทำสร้างงานและเรียกใช้เมื่อใดก็ตามที่คุณต้องการตัวอย่างเช่นคุณติดตั้งปลั๊กอินเพื่อลดขนาด CSS ของคุณจากนั้นเรียกใช้แต่ละครั้งเพื่อลดขนาดรายละเอียดเพิ่มเติมเกี่ยวกับแต่ละ

อึก

gulp.js เป็นชุดเครื่องมือ JavaScript แบบโอเพ่นซอร์สโดย Fractal Innovations และชุมชนโอเพนซอร์สที่ GitHub ใช้เป็นระบบสร้างสตรีมมิ่งในการพัฒนาเว็บส่วนหน้า มันเป็นนักวิ่งงานที่สร้างขึ้นบน Node.js และ Node Package Manager (npm) ซึ่งใช้สำหรับระบบอัตโนมัติของงานที่ต้องใช้เวลาและซ้ำ ๆ ที่เกี่ยวข้องกับการพัฒนาเว็บเช่น minification, concatenation, การเชื่อมต่อแคช, การทดสอบหน่วย วิธีการกำหนดรหัสเพื่อกำหนดงานและอาศัยปลั๊กอินขนาดเล็กที่มีจุดประสงค์เดียวในการดำเนินงาน ระบบนิเวศอึกมี 1,000+ ปลั๊กอินดังกล่าวให้เลือก

เพิ่มเติมที่นี่

เสี้ยงฮึดฮัดแสดงความไม่พอใจ

Grunt เป็นตัวเรียกใช้งาน JavaScript ซึ่งเป็นเครื่องมือที่ใช้ในการทำงานที่ใช้บ่อยโดยอัตโนมัติเช่น minification, compilation, การทดสอบหน่วย, linting เป็นต้นโดยใช้อินเตอร์เฟสบรรทัดคำสั่งเพื่อเรียกใช้งานที่กำหนดเองในไฟล์ (รู้จักกันในชื่อ Gruntfile) . Grunt ถูกสร้างโดย Ben Alman และเขียนเป็น Node.js มันกระจายผ่านทาง NPM ปัจจุบันมีปลั๊กอินมากกว่าห้าพันรายการในระบบนิเวศ Grunt

เพิ่มเติมที่นี่


3) ผู้จัดการแพ็คเกจ

ผู้จัดการแพคเกจสิ่งที่พวกเขาทำคือการจัดการปลั๊กอินที่คุณต้องการในแอปพลิเคชันของคุณและติดตั้งให้คุณผ่าน github ฯลฯ โดยใช้ package.json มีประโยชน์อย่างมากในการอัปเดตโมดูลของคุณติดตั้งและแชร์แอพของคุณ

NPM

npm เป็นตัวจัดการแพ็กเกจสำหรับภาษาการเขียนโปรแกรม JavaScript มันเป็นตัวจัดการแพคเกจเริ่มต้นสำหรับสภาพแวดล้อมรันไทม์ JavaScript Node.js ประกอบด้วยไคลเอ็นต์บรรทัดคำสั่งหรือที่เรียกว่า npm และฐานข้อมูลออนไลน์ของแพ็คเกจสาธารณะเรียกว่ารีจิสทรี npm มีการเข้าถึงรีจิสทรีผ่านทางไคลเอนต์และสามารถเรียกดูแพ็คเกจที่มีอยู่และค้นหาผ่านเว็บไซต์ npm

เพิ่มเติมที่นี่

ซุ้มไม้ในสวน

Bower สามารถจัดการส่วนประกอบที่มี HTML, CSS, JavaScript, ฟอนต์หรือแม้แต่ไฟล์รูปภาพ Bower ไม่เชื่อมต่อหรือย่อขนาดโค้ดหรือทำสิ่งอื่น - เพียงแค่ติดตั้งแพ็คเกจที่คุณต้องการและการพึ่งพาของมัน ในการเริ่มต้น Bower ทำงานด้วยการดึงและติดตั้งแพคเกจจากทั่วทุกมุมดูแลการล่าสัตว์ค้นหาดาวน์โหลดและบันทึกสิ่งที่คุณกำลังมองหา Bower ติดตามแพ็คเกจเหล่านี้ในไฟล์ Manifest bower.json

เพิ่มเติมที่นี่

และตัวจัดการแพ็กเกจล่าสุดที่ไม่ควรพลาดมันเป็นรุ่นใหม่และเร็วในสภาพแวดล้อมการทำงานจริงเมื่อเทียบกับ npm ซึ่งฉันใช้เป็นส่วนใหญ่มาก่อนสำหรับการติดตั้งโมดูลใหม่มันจะตรวจสอบสองครั้งที่โฟลเดอร์ node_modules ดูเหมือนว่าการติดตั้งโมดูลจะใช้เวลาน้อยลง:

เส้นด้าย

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

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

รหัสที่ใช้ร่วมกันผ่านสิ่งที่เรียกว่าแพคเกจ (บางครั้งเรียกว่าโมดูล) แพคเกจประกอบด้วยรหัสทั้งหมดที่ใช้ร่วมกันเช่นเดียวกับไฟล์ package.json ซึ่งอธิบายแพคเกจ

เพิ่มเติมที่นี่



มีรายการของปลั๊กอินอึกหรือไม่? มี 1,000+ จริงหรือ npm ส่งคืน 20 หรือมากกว่าเท่านั้น
flurbius

1
สรุปที่ดี ควรเป็นจุดเริ่มต้นสำหรับการอภิปรายเกี่ยวกับการพัฒนาเว็บที่ทันสมัย
Adam Bubela

1
@flurbius ใช่ที่นี่: gulpjs.com/plugins ปัจจุบันดูเหมือนจะมีปลั๊กอิน 3,465 อึก
เอ็มทีเอ knn

52

คุณสามารถค้นหาการเปรียบเทียบทางเทคนิคบางอย่างในnpmcompare

เปรียบเทียบ browserify กับ grunt กับ gulp vs. webpack

อย่างที่คุณเห็น webpack ได้รับการดูแลเป็นอย่างดีโดยมีเวอร์ชั่นใหม่ออกมาทุก ๆ 4 วันโดยเฉลี่ย แต่อึกดูเหมือนว่าจะมีชุมชนที่ใหญ่ที่สุดของพวกเขาทั้งหมด (มีดาวมากกว่า 20K ใน Github) Grunt ดูเหมือนจะถูกทอดทิ้งเล็กน้อย (เทียบกับคนอื่น ๆ )

ดังนั้นหากจำเป็นต้องเลือกอย่างใดอย่างหนึ่งมากกว่าที่ฉันจะไปด้วยอึก


5
webpack ตอนนี้ 26k เริ่มต้นที่ Github และ gulp ด้วย 25.7k ไม่สามารถใช้ปัจจัยความนิยมในการตัดสินใจอีกต่อไป ...
Rayee Roded


14

webpack & webpack-dev-server คืออะไร เอกสารอย่างเป็นทางการกล่าวว่ามันเป็นโมดูลรวม แต่สำหรับฉันมันเป็นเพียงงานนักวิ่ง ความแตกต่างคืออะไร?

webpack-dev-serverเป็นเว็บเซิร์ฟเวอร์ที่โหลดสดซึ่งนักพัฒนาWebpackใช้เพื่อรับข้อเสนอแนะในทันทีสิ่งที่พวกเขาทำ ควรใช้ระหว่างการพัฒนาเท่านั้น

โครงการนี้ได้รับแรงบันดาลใจอย่างมากจากเครื่องมือทดสอบหน่วยnof5

Webpackเป็นชื่อที่แสดงจะสร้างSINGLE แพ็คอายุสำหรับเว็บ แพ็คเกจจะถูกย่อให้เล็กสุดและรวมเป็นไฟล์เดียว (เรายังคงใช้งานได้ในยุค HTTP 1.1) Webpackไม่มหัศจรรย์ของการรวมทรัพยากร (JavaScript, CSS, รูปภาพ) <script src="assets/bundle.js"></script>และการฉีดพวกเขาเช่นนี้:

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

คุณจะใช้เบราว์เซอร์ที่ไหน เราไม่สามารถทำเช่นเดียวกันกับการนำเข้า node / ES6 ได้หรือไม่

คุณสามารถใช้Browserifyในงานเดียวกันที่แน่นอนที่คุณจะใช้Webpack - Webpackนั้นกะทัดรัดกว่า

โปรดทราบว่าฟีเจอร์โหลดเดอร์โมดูล ES6ในWebpack2กำลังใช้งานSystem.importซึ่งไม่ใช่เบราว์เซอร์ตัวเดียวที่รองรับในรูปแบบดั้งเดิม

เมื่อใดที่คุณจะใช้ gulp / grunt เหนือ npm + plugin

คุณสามารถลืม อึก, ฮึดฮัด, Brokoli, อาหารเช้าและกลางวันและซุ้ม ใช้สคริปต์บรรทัดคำสั่ง npm โดยตรงแทนและคุณสามารถกำจัดแพ็กเกจพิเศษเช่นนี้ที่นี่สำหรับอึก :

var gulp        = require('gulp'),
  minifyCSS     = require('gulp-minify-css'),
  sass          = require('gulp-sass'),
  browserify    = require('gulp-browserify'),
  uglify        = require('gulp-uglify'),
  rename        = require('gulp-rename'),
  jshint        = require('gulp-jshint'),
  jshintStyle   = require('jshint-stylish'),
  replace       = require('gulp-replace'),
  notify        = require('gulp-notify'),

คุณสามารถใช้เครื่องมือสร้างไฟล์กำหนดค่าGulpและGruntเมื่อสร้างไฟล์กำหนดค่าสำหรับโครงการของคุณ วิธีนี้คุณไม่จำเป็นต้องติดตั้งYeomanหรือเครื่องมือที่คล้ายกัน


14

Yarn เป็นผู้จัดการแพ็คเกจล่าสุดที่อาจสมควรได้รับการกล่าวถึง
ดังนั้นนี่คือ: https://yarnpkg.com/

เท่าที่ฉันรู้ว่ามันสามารถดึงข้อมูลการอ้างอิงทั้งสอง npm และ bower และมีคุณลักษณะที่ชื่นชมอื่น ๆ


12

Webpackเป็นตัวรวมกลุ่ม ชอบที่Browserfyจะปรากฏใน codebase สำหรับคำขอโมดูล ( requireหรือimport) และแก้ไขพวกเขาซ้ำ ๆ ยิ่งไปกว่านั้นคุณสามารถกำหนดค่าWebpackเพื่อแก้ไขไม่เพียง แต่โมดูลที่เหมือน JavaScript แต่ CSS, รูปภาพ, HTML ทุกอย่างแท้จริง สิ่งที่ทำให้ฉันตื่นเต้นเป็นWebpackพิเศษคุณสามารถรวมทั้งโมดูลที่คอมไพล์และโหลดแบบไดนามิกในแอพเดียวกัน ดังนั้นจึงมีการเพิ่มประสิทธิภาพที่แท้จริงโดยเฉพาะอย่างยิ่งผ่าน HTTP / 1.x คุณอธิบายด้วยตัวอย่างที่นี่ได้อย่างไรhttp://dsheiko.com/weblog/state-of-javascript-modules-2017/ เป็นอีกทางเลือกหนึ่งสำหรับ Bundler ที่คุณสามารถคิดถึงRollup.js( https://rollupjs.org/ ) ซึ่งปรับโค้ดให้เหมาะสมในระหว่างการคอมไพล์ แต่การแยกส่วนที่ไม่ได้ใช้ที่พบทั้งหมด

สำหรับAMDแทนที่จะRequireJSสามารถใช้กับเนทิES2016 module systemฟ แต่โหลดด้วยSystem.js( https://github.com/systemjs/systemjs )

นอกจากนี้ผมจะชี้ว่าnpmมักจะถูกใช้เป็นเครื่องมืออัตโนมัติเหมือนหรือgrunt gulpตรวจสอบhttps://docs.npmjs.com/misc/scripts โดยส่วนตัวแล้วฉันจะใช้สคริปต์ npm เพื่อหลีกเลี่ยงเครื่องมืออัตโนมัติอื่น ๆ แต่ในอดีตที่ผ่านมาฉันเข้ามาgruntมาก ด้วยเครื่องมืออื่น ๆ คุณต้องพึ่งพาปลั๊กอินนับไม่ถ้วนสำหรับแพ็คเกจซึ่งมักจะเขียนไม่ดีและไม่ได้รับการบำรุงรักษาอย่างแข็งขัน npmรู้จักแพ็คเกจของมันดังนั้นคุณจึงโทรไปยังแพ็คเกจใด ๆ ที่ติดตั้งในเครื่องตามชื่อ:

{
  "scripts": {
    "start": "npm http-server"
  },
  "devDependencies": {
    "http-server": "^0.10.0"
  }
}

จริงๆแล้วคุณเป็นกฎไม่จำเป็นต้องใช้ปลั๊กอินใด ๆ หากแพคเกจรองรับ CLI

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