Gulp + Webpack หรือ JUST Webpack


161

ฉันเห็นคนใช้อึกกับ webpack แต่แล้วฉันอ่าน webpack สามารถแทนที่อึก? ฉันสับสนอย่างสมบูรณ์ที่นี่ ... ใครสามารถอธิบายได้บ้าง

UPDATE

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

หากคุณไม่ต้องการอึกใช่ก็มีเสี้ยงฮึดฮัด แต่คุณสามารถระบุคำสั่งใน package.json ของคุณและเรียกพวกเขาจากบรรทัดคำสั่งโดยไม่ต้องมี task runner เพียงเพื่อเริ่มต้นและเริ่มทำงาน ตัวอย่างเช่น:

"scripts": {
      "babel": "babel src -d build",
      "browserify": "browserify build/client/app.js -o dist/client/scripts/app.bundle.js",
      "build": "npm run clean && npm run babel && npm run prepare && npm run browserify",
      "clean": "rm -rf build && rm -rf dist",
      "copy:server": "cp build/server.js dist/server.js",
      "copy:index": "cp src/client/index.html dist/client/index.html",
      "copy": "npm run copy:server && npm run copy:index",
      "prepare": "mkdir -p dist/client/scripts/ && npm run copy",
      "start": "node dist/server"
    },

3
สิ่งนี้ช่วยให้ฉันเข้าใจ Webpack ได้ดีกว่าเอกสารของ Webpack หรือบทความใด ๆ : github.com/petehunt/webpack-howto
George Ananda Eman

blog.andrewray.me/webpack-when-to-use-and-whyไม่ต้องใช้อึกกับ webpack
Andy Ray

ตัวอย่างที่เรียบง่ายและเรียบง่ายของฉันคือฉันต้องการให้ webpack-dev-server จัดการ js ของฉันด้วย HMR แต่ฉันประสบปัญหาที่ฉันไม่สามารถใช้ตัวสร้างไซต์แบบคงที่และเซิร์ฟเวอร์ dev webpack ด้วยการกำหนดค่าที่ซับซ้อนฉันสามารถทำสิ่งนี้ได้ แต่เป็นอึกไปข้างหน้าฉันสามารถทำได้เช่นกัน ดังนั้นความแตกต่างที่สำคัญคือเวลาและช่วงการเรียนรู้
dewwwald


การอัปเดตของคุณควรเป็นคำตอบ +1
Z. Khullah

คำตอบ:


82

คำตอบนี้อาจช่วยได้ Task Runners (Gulp, Grunt, etc) และ Bundlers (Webpack, Browserify) ทำไมต้องใช้ร่วมกัน?

... และนี่คือตัวอย่างของการใช้ webpack จากภายในงานอึก นี่เป็นขั้นตอนต่อไปและถือว่าการกำหนดค่า webpack ของคุณเขียนด้วย es6

var gulp = require('gulp');
var webpack = require('webpack');
var gutil = require('gutil');
var babel = require('babel/register');
var config = require(path.join('../..', 'webpack.config.es6.js'));

gulp.task('webpack-es6-test', function(done){
   webpack(config).run(onBuild(done));
});

function onBuild(done) {
    return function(err, stats) {
        if (err) {
            gutil.log('Error', err);
            if (done) {
                done();
            }
        } else {
            Object.keys(stats.compilation.assets).forEach(function(key) {
                gutil.log('Webpack: output ', gutil.colors.green(key));
            });
            gutil.log('Webpack: ', gutil.colors.blue('finished ', stats.compilation.name));
            if (done) {
                done();
            }
        }
    }
}

ฉันคิดว่าคุณจะพบว่าเมื่อแอปของคุณซับซ้อนมากขึ้นคุณอาจต้องการใช้อึกกับงาน webpack ตามตัวอย่างด้านบน สิ่งนี้ช่วยให้คุณสามารถทำสิ่งที่น่าสนใจเพิ่มเติมอีกสองสามอย่างในงานสร้างของคุณที่ webpack loader และปลั๊กอินไม่ได้ทำจริง ๆ เช่น การสร้างไดเรกทอรีเอาท์พุทการเริ่มต้นเซิร์ฟเวอร์ ฯลฯ เพื่อให้ง่ายต่อการเข้าใจ Webpack สามารถทำสิ่งเหล่านั้นได้ แต่คุณอาจพบว่ามัน จำกัด สำหรับความต้องการในระยะยาวของคุณ ข้อดีอย่างหนึ่งที่ใหญ่ที่สุดที่คุณได้รับจาก gulp -> webpack คือคุณสามารถปรับแต่งการตั้งค่า webpack ของคุณสำหรับสภาพแวดล้อมที่แตกต่างกันและให้อึกทำงานที่ถูกต้องในเวลาที่เหมาะสม มันขึ้นอยู่กับคุณจริงๆ แต่ไม่มีอะไรผิดปกติกับการใช้ webpack จากอึกจริงๆแล้วมีบางตัวอย่างที่น่าสนใจเกี่ยวกับวิธีการทำ.


โปรเจ็กต์ webpack ของฉันค่อนข้างใหญ่ดังนั้นฉันต้องเพิ่มหน่วยความจำของโหนดด้วยคำสั่ง command line stackoverflow.com/questions/34727743/…มีวิธีทำผ่าน webpack โดยตรงหรือไม่?
Abhinav Singi

ตรวจสอบสองสิ่งนี้ คุณอาจต้องตั้งค่าหน่วยความจำ v8 ก่อนใช้งานโหนดหรือ webpack stackoverflow.com/questions/7193959/…และwebpack.github.io/docs/build-performance.html
4m1r

ฉันไม่แน่ใจว่าทำไมฉันจึงยอมรับคำตอบนี้ ฉันคิดว่าอาจเป็นเพราะลิงก์แรกที่คุณแชร์ แต่ใช้ webpack จากอึก? มันยิ่งเป็นระเบียบถ้าคุณถามฉันตอนนี้ :) ฉันจะไม่ลองใช้อะไรแบบนั้นอีก
PositiveGuy

80

สคริปต์ NPMสามารถทำเช่นเดียวกันกับอึก แต่ในรหัสน้อยกว่าประมาณ 50x ในความเป็นจริงไม่มีรหัสเลยอาร์กิวเมนต์บรรทัดคำสั่งเท่านั้น

ตัวอย่างเช่นกรณีการใช้งานที่คุณอธิบายซึ่งคุณต้องการให้มีรหัสที่แตกต่างกันสำหรับสภาพแวดล้อมที่แตกต่างกัน

ด้วย Webpack + NPM Scripts มันเป็นเรื่องง่าย:

"prebuild:dev": "npm run clean:wwwroot",
"build:dev": "cross-env NODE_ENV=development webpack --config config/webpack.development.js --hot --profile --progress --colors --display-cached",
"postbuild:dev": "npm run copy:index.html && npm run rename:index.html",

"prebuild:production": "npm run clean:wwwroot",
"build:production": "cross-env NODE_ENV=production webpack --config config/webpack.production.js --profile --progress --colors --display-cached --bail",
"postbuild:production": "npm run copy:index.html && npm run rename:index.html",

"clean:wwwroot": "rimraf -- wwwroot/*",
"copy:index.html": "ncp wwwroot/index.html Views/Shared",
"rename:index.html": "cd ../PowerShell && elevate.exe -c renamer --find \"index.html\" --replace \"_Layout.cshtml\" \"../MyProject/Views/Shared/*\"",

ตอนนี้คุณเพียงแค่รักษาสองสคริปต์การกำหนดค่า webpack หนึ่งสำหรับโหมดการพัฒนา, และหนึ่งสำหรับโหมดการผลิตwebpack.development.js webpack.production.jsฉันยังใช้การwebpack.common.jsกำหนดค่า webpack ที่แชร์ในทุกสภาพแวดล้อมและใช้ webpackMerge เพื่อรวมเข้าด้วยกัน

เนื่องจากความเย็นของสคริปต์ NPM จะช่วยให้ผูกมัดง่ายคล้ายกับวิธีอึก Streams / ท่อ

ในตัวอย่างข้างต้นเพื่อสร้างสำหรับ Developement npm run build:devคุณเพียงแค่ไปที่บรรทัดคำสั่งของคุณและดำเนินการ

  1. NPM แรกจะวิ่งprebuild:dev,
  2. จากนั้นbuild:dev,
  3. postbuild:devและในที่สุดก็

preและpostคำนำหน้าบอก NPM ซึ่งเพื่อที่จะดำเนินการใน

ถ้าคุณสังเกตเห็นมีสคริปต์ Webpack + NPM คุณสามารถเรียกใช้โปรแกรมพื้นเมืองเช่นแทนที่จะอึกกระดาษห่อสำหรับโปรแกรมพื้นเมืองเช่นrimraf gulp-rimrafนอกจากนี้คุณยังสามารถเรียกใช้ไฟล์. exe Windows แบบเดิมที่ฉันทำที่นี่ด้วยelevate.exeหรือไฟล์เนทีฟ * บน Linux หรือ Mac

ลองทำสิ่งเดียวกันกับอึก คุณจะต้องรอให้ใครบางคนเข้ามาและเขียนโปรแกรมห่อหุ้มอึกสำหรับโปรแกรมเนทีฟที่คุณต้องการใช้ นอกจากนี้คุณอาจต้องเขียนโค้ดที่ซับซ้อนเช่นนี้: (ถ่ายโดยตรงจากrepo angular2-seed )

รหัสพัฒนาอึก

import * as gulp from 'gulp';
import * as gulpLoadPlugins from 'gulp-load-plugins';
import * as merge from 'merge-stream';
import * as util from 'gulp-util';
import { join/*, sep, relative*/ } from 'path';

import { APP_DEST, APP_SRC, /*PROJECT_ROOT, */TOOLS_DIR, TYPED_COMPILE_INTERVAL } from '../../config';
import { makeTsProject, templateLocals } from '../../utils';

const plugins = <any>gulpLoadPlugins();

let typedBuildCounter = TYPED_COMPILE_INTERVAL; // Always start with the typed build.

/**
 * Executes the build process, transpiling the TypeScript files (except the spec and e2e-spec files) for the development
 * environment.
 */
export = () => {
  let tsProject: any;
  let typings = gulp.src([
    'typings/index.d.ts',
    TOOLS_DIR + '/manual_typings/**/*.d.ts'
  ]);
  let src = [
    join(APP_SRC, '**/*.ts'),
    '!' + join(APP_SRC, '**/*.spec.ts'),
    '!' + join(APP_SRC, '**/*.e2e-spec.ts')
  ];

  let projectFiles = gulp.src(src);
  let result: any;
  let isFullCompile = true;

  // Only do a typed build every X builds, otherwise do a typeless build to speed things up
  if (typedBuildCounter < TYPED_COMPILE_INTERVAL) {
    isFullCompile = false;
    tsProject = makeTsProject({isolatedModules: true});
    projectFiles = projectFiles.pipe(plugins.cached());
    util.log('Performing typeless TypeScript compile.');
  } else {
    tsProject = makeTsProject();
    projectFiles = merge(typings, projectFiles);
  }

  result = projectFiles
    .pipe(plugins.plumber())
    .pipe(plugins.sourcemaps.init())
    .pipe(plugins.typescript(tsProject))
    .on('error', () => {
      typedBuildCounter = TYPED_COMPILE_INTERVAL;
    });

  if (isFullCompile) {
    typedBuildCounter = 0;
  } else {
    typedBuildCounter++;
  }

  return result.js
    .pipe(plugins.sourcemaps.write())
// Use for debugging with Webstorm/IntelliJ
// https://github.com/mgechev/angular2-seed/issues/1220
//    .pipe(plugins.sourcemaps.write('.', {
//      includeContent: false,
//      sourceRoot: (file: any) =>
//        relative(file.path, PROJECT_ROOT + '/' + APP_SRC).replace(sep, '/') + '/' + APP_SRC
//    }))
    .pipe(plugins.template(templateLocals()))
    .pipe(gulp.dest(APP_DEST));
};

รหัสการผลิตอึก

import * as gulp from 'gulp';
import * as gulpLoadPlugins from 'gulp-load-plugins';
import { join } from 'path';

import { TMP_DIR, TOOLS_DIR } from '../../config';
import { makeTsProject, templateLocals } from '../../utils';

const plugins = <any>gulpLoadPlugins();

const INLINE_OPTIONS = {
  base: TMP_DIR,
  useRelativePaths: true,
  removeLineBreaks: true
};

/**
 * Executes the build process, transpiling the TypeScript files for the production environment.
 */

export = () => {
  let tsProject = makeTsProject();
  let src = [
    'typings/index.d.ts',
    TOOLS_DIR + '/manual_typings/**/*.d.ts',
    join(TMP_DIR, '**/*.ts')
  ];
  let result = gulp.src(src)
    .pipe(plugins.plumber())
    .pipe(plugins.inlineNg2Template(INLINE_OPTIONS))
    .pipe(plugins.typescript(tsProject))
    .once('error', function () {
      this.once('finish', () => process.exit(1));
    });


  return result.js
    .pipe(plugins.template(templateLocals()))
    .pipe(gulp.dest(TMP_DIR));
};

รหัส gulp ที่แท้จริงนั้นซับซ้อนกว่านี้มากเนื่องจากเป็นเพียง 2 ในไฟล์ gulp หลายโหลใน repo

แล้วอันไหนง่ายกว่ากันสำหรับคุณ

ในความคิดของฉันสคริปต์ NPM มีประสิทธิภาพเหนือกว่าทั้งอึกทึกและเสี้ยงฮึดฮัดแสดงความไม่พอใจทั้งในประสิทธิภาพและความสะดวกในการใช้งานและนักพัฒนาส่วนหน้าทั้งหมดควรพิจารณาใช้ในเวิร์กโฟลว์ของพวกเขาเพราะมันเป็นโปรแกรมประหยัดเวลาที่สำคัญ

UPDATE

มีสถานการณ์หนึ่งที่ฉันพบว่าฉันต้องการใช้ Gulp ร่วมกับสคริปต์ NPM และ Webpack

เมื่อฉันต้องทำการดีบักแบบรีโมทบนอุปกรณ์ iPad หรือ Android เช่นฉันต้องเริ่มต้นเซิร์ฟเวอร์เพิ่มเติม ในอดีตที่ผ่านมาฉันรันเซิร์ฟเวอร์ทั้งหมดเป็นกระบวนการที่แยกจากภายใน IntelliJ IDEA (หรือ Webstorm) ซึ่งเป็นเรื่องง่ายด้วยการเรียกใช้ "Compound" Run Configuration แต่ถ้าฉันต้องหยุดและรีสตาร์ทมันก็น่าเบื่อที่จะต้องปิดแท็บเซิร์ฟเวอร์ 5 แท็บต่าง ๆ รวมทั้งเอาต์พุตก็กระจายไปทั่วหน้าต่างอื่น

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

ดังนั้นฉันจึงสร้างงานอึกง่าย ๆ ที่เพิ่งรันสคริปต์ NPM หรือคำสั่งโดยตรงดังนั้นผลลัพธ์ทั้งหมดที่ปรากฏในหน้าต่างเดียวและฉันสามารถจบเซิร์ฟเวอร์ทั้ง 5 ได้พร้อมกันโดยการปิดหน้าต่างงานอึก

Gulp.js

/**
 * Gulp / Node utilities
 */
var gulp = require('gulp-help')(require('gulp'));
var utils = require('gulp-util');
var log = utils.log;
var con = utils.colors;

/**
 * Basic workflow plugins
 */
var shell = require('gulp-shell'); // run command line from shell
var browserSync = require('browser-sync');

/**
 * Performance testing plugins
 */
var ngrok = require('ngrok');

// Variables
var serverToProxy1 = "localhost:5000";
var finalPort1 = 8000;


// When the user enters "gulp" on the command line, the default task will automatically be called. This default task below, will run all other tasks automatically.

// Default task
gulp.task('default', function (cb) {
   console.log('Starting dev servers!...');
   gulp.start(
      'devserver:jit',
      'nodemon',
      'browsersync',
      'ios_webkit_debug_proxy'
      'ngrok-url',
      // 'vorlon',
      // 'remotedebug_ios_webkit_adapter'
   );
});

gulp.task('nodemon', shell.task('cd ../backend-nodejs && npm run nodemon'));
gulp.task('devserver:jit', shell.task('npm run devserver:jit'));
gulp.task('ios_webkit_debug_proxy', shell.task('npm run ios-webkit-debug-proxy'));
gulp.task('browsersync', shell.task(`browser-sync start --proxy ${serverToProxy1} --port ${finalPort1} --no-open`));
gulp.task('ngrok-url', function (cb) {
   return ngrok.connect(finalPort1, function (err, url) {
      site = url;
      log(con.cyan('ngrok'), '- serving your site from', con.yellow(site));
      cb();
   });
});
// gulp.task('vorlon', shell.task('vorlon'));
// gulp.task('remotedebug_ios_webkit_adapter', shell.task('remotedebug_ios_webkit_adapter'));

ยังคงเป็นโค้ดเพียงเล็กน้อยเพื่อให้ทำงาน 5 อย่างในความคิดของฉัน แต่มันใช้งานได้ตามวัตถุประสงค์ หนึ่ง caveate คือว่าดูเหมือนจะไม่เรียกใช้คำสั่งบางอย่างถูกต้องเช่นgulp-shell ios-webkit-debug-proxyดังนั้นฉันต้องสร้างสคริปต์ NPM ที่เพิ่งรันคำสั่งเดียวกันจากนั้นก็ใช้งานได้

ดังนั้นฉันจึงใช้ NPM Scripts เป็นหลักสำหรับงานทั้งหมดของฉัน แต่บางครั้งเมื่อฉันต้องการเรียกใช้เซิร์ฟเวอร์จำนวนมากในคราวเดียวฉันจะเริ่มภารกิจ Gulp ของฉันเพื่อช่วยเหลือ เลือกเครื่องมือที่เหมาะสมสำหรับงานที่เหมาะสม

อัพเดท 2

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

// NOTE: If you need to run a command with spaces in it, you need to use 
// double quotes, and they must be escaped (at least on windows).
// It doesn't seem to work with single quotes.

"run:all": "concurrently \"npm run devserver\" nodemon browsersync ios_webkit_debug_proxy ngrok-url"

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

ฉันขอแนะนำให้คุณอ่านบทความเหล่านี้ซึ่งเปรียบเทียบพวกเขาในเชิงลึก


14
นั่นทำให้งานของคุณค่อนข้างง่าย ขอให้โชคดีสคริปต์ที่ซับซ้อนสร้างด้วยเชลล์ :-)
Filip Sobczak

5
นี่เป็นเพียงตัวอย่าง งานสร้างของฉันซับซ้อนมากและมีสคริปต์จำนวนมากที่ทำงานบนเชลล์ทำงานได้อย่างไร้ที่ติและดูแลรักษาได้ง่าย และสิ่งที่สคริปต์ NPM ไม่ได้ทำเพื่อฉัน webpack ทำเช่น uglify, บีบอัด gzip, แปลง, ฯลฯ ขอบคุณ อะไรคือความซับซ้อนที่คุณต้องการกลืน
TetraDev

2
(มากกว่าหนึ่งปีต่อมาฮ่า ๆ ): ขอบคุณมากคำตอบยอดเยี่ยม !!
PositiveGuy

1
@ user108471 แน่ใจว่า webpack สามารถทำได้มันสามารถสร้าง assets.json ซึ่งแสดงรายการโมดูลทั้งหมดที่คอมไพล์ด้วยรหัสที่เกี่ยวข้อง สามารถสร้างไฟล์ข้อมูล JSON แบบบิวด์เพิ่มเติมได้ด้วยปลั๊กอินที่ถูกต้อง คุณหมายถึงชนิดใดโดยเฉพาะที่อ้างถึงอึกนั้นสามารถทำได้?
TetraDev

1
@GiannosCharalambous ขอบคุณสำหรับคำแนะนำนั้น ตอนนี้ฉันใช้จริงมาnpm-run-allสองสามเดือนแล้ว แต่ฉันไม่เคยคิดที่จะใช้-pธงคู่ขนาน! ฉันจะลองดูในสัปดาห์นี้
เตตร้าเดฟ

8

ฉันใช้ทั้งสองตัวเลือกในโครงการต่าง ๆ ของฉัน

นี่คือหนึ่งในต้นแบบที่ผมใส่กันใช้gulpกับwebpack- https://github.com/iroy2000/react-reflux-boilerplate-with-webpack

ฉันมีบางโครงการอื่น ๆ ที่ใช้เฉพาะกับ webpacknpm tasks

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

ตัวอย่างเช่นถ้างานที่คุณเป็นเรื่องง่ายสมมติว่าdev, build, test... ฯลฯ (ซึ่งเป็นมาตรฐานมาก) คุณมีทั้งหมดดีกับง่ายเพียงแค่มี webpacknpm tasks

แต่ถ้าคุณมีเวิร์กโฟลว์ที่ซับซ้อนมากและคุณต้องการควบคุมการกำหนดค่าของคุณมากขึ้น (เพราะมันคือการเข้ารหัส) คุณสามารถไปที่เส้นทางอึก

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

และหลายครั้งในทุกวันนี้ฉันเห็นผู้คนเข้ามาแทนที่gulp and browsifyด้วยตัวwebpackเองจริงๆ


5
ใช่ แต่ Webpack มีชื่อเสียงไม่ดีที่จะเข้าใจยากเกินไป ฉันมักจะพยายามใช้ gulp ก่อนกับ browserify ไม่พร้อมที่จะใช้ Webpack เพียงบางส่วนและฉันยังไม่ได้ทำอะไรมากกับ Browserify หรือโหนดที่ส่วนหน้าดังนั้นฉันต้องการเรียนรู้วิธีที่ทุกคนทำกับ gulp และ เบราว์เซอร์แรกก่อนดังนั้นฉันจึงมีประวัติในแง่ของประสบการณ์
PositiveGuy

1
Webpack มีความซับซ้อนหากคุณไม่ได้ใช้งานเช่นเดียวกับอึก, เสียงฮึดฮัด, เบราว์เซอร์, ตัวพิมพ์ดีดและอื่น ๆ Webpack ใช้งานได้ง่ายมากเมื่อคุณเข้าใจวิธีการตั้งค่าไฟล์กำหนดค่าและทำงานกับตัวโหลด ในความเป็นจริงไฟล์กำหนดค่าอาจมีขนาดสั้นถึง 20-30 บรรทัดของรหัสสำหรับการสร้าง webpack ที่ใช้งานได้และมีความทนทานตามที่คุณต้องการ ไม่ต้องพูดถึง Webpack Hot Module Replacement นั้นยอดเยี่ยมมาก ดู: andrewhfarmer.com/understanding-hmrและandrewhfarmer.com/webpack-hmr-tutorialและmedium.com/@dabit3/beginner-s-guide-to-webpack-b1f1a3638460
TetraDev

2

แนวคิดของ Gulp และ Webpack นั้นแตกต่างกันมาก คุณบอก Gulp วิธีการใส่รหัสส่วนหน้าเข้าด้วยกันทีละขั้นตอน แต่คุณบอก Webpack ว่าคุณต้องการอะไรผ่านไฟล์ปรับแต่ง

นี่เป็นบทความสั้น ๆ (อ่าน 5 นาที) ฉันเขียนอธิบายความเข้าใจของฉันเกี่ยวกับความแตกต่าง: https://medium.com/@Maokai/compile-the-front-end-from-gulp-to-webpack-c45671ad87fe

บริษัท ของเราย้ายจาก Gulp มาเป็น Webpack ในปีที่ผ่านมา แม้ว่าเราจะต้องใช้เวลาสักพัก แต่เราก็หาวิธีย้ายสิ่งที่เราทำในอึกไปยัง Webpack สำหรับเราทุกสิ่งที่เราทำในอึกนั้นเราสามารถทำได้ผ่าน Webpack แต่ไม่ใช่วิธีอื่น ๆ

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


2

สุจริตฉันคิดว่าดีที่สุดคือการใช้ทั้งสอง

  • Webpackสำหรับจาวาสคริปต์ที่เกี่ยวข้องทั้งหมด
  • อึกสำหรับcssทั้งหมดที่เกี่ยวข้อง

ฉันยังต้องหาโซลูชันที่เหมาะสมสำหรับการบรรจุ css กับ webpack และจนถึงตอนนี้ฉันมีความสุขที่ได้ใช้ gulp สำหรับ css และ webpack สำหรับ javascript

ฉันยังใช้npmสคริปต์เป็น @Tradradev ตามที่อธิบายไว้ โดยเฉพาะตั้งแต่ฉันใช้Visual Studioและในขณะที่NPM Task runnerสวยน่าเชื่อถือ Webpack Task Runnerสวยรถ


ฉันได้พบการใช้งาน NPM Task Runner + อึกกุญแจ วางคำสั่ง webpack ในไฟล์ packange.json และ CSS (SASS) ที่เกี่ยวข้องกับไฟล์ gulp นอกจากนี้ยังตั้งค่า package.json เพื่อให้มีขั้นตอนการสร้างที่เรียกใช้งานอึกเป็นส่วนหนึ่งของการเปิดตัวการผลิต
Nico
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.