Grunt'un farklı kurulumlar için index.html oluşturmasını sağlayın


208

Web uygulamam için bir inşa aracı olarak Grunt kullanmaya çalışıyorum.

En az iki kurulum yapmak istiyorum:

I. Geliştirme kurulumu - bitiştirmeden ayrı dosyalardan komut dosyaları yükleyin,

böylece index.html şöyle görünecektir:

<!DOCTYPE html>
<html>
    <head>
        <script src="js/module1.js" />
        <script src="js/module2.js" />
        <script src="js/module3.js" />
        ...
    </head>
    <body></body>
</html>

II. Üretim kurulumu - komut dosyalarımı küçültülmüş ve birleştirilmiş olarak tek bir dosyaya yükleyin,

index.html ile buna göre:

<!DOCTYPE html>
<html>
    <head>
        <script src="js/MyApp-all.min.js" />
    </head>
    <body></body>
</html>

Soru, nasıl ben çalıştırdığınızda bu index.html en bağlı yapılandırmasına yapmak hırıltı yapabilir grunt devya grunt prod?

Ya da belki yanlış yönde kazıyorum ve her zaman oluşturmak daha kolay olurdu MyApp-all.min.jsama içine tüm komut dosyaları (birleştirilmiş) ya da bu komut dosyalarını eşzamansız olarak ayrı dosyalardan yükleyen bir yükleyici komut dosyası koymak?

Bunu nasıl yapıyorsunuz beyler?


3
Sizinkini yapan bir 'usemin' görevi içeren Yeoman aracını deneyin. Buna ek olarak, Yeamon jeneratörleri yeni bir araç kullanırken öğrenmesi zor birçok "iyi uygulama" da içerir.
EricSonaron

Yanıtlar:


161

Son zamanlarda bu Grunt v0.4.0uyumlu görevleri keşfettim :

  • hırıltı-preprocess

    Önişlem npm modülünün etrafında görev değiştirme.

  • hırıltı-env

    Gelecekteki görevler için ortam yapılandırmasını otomatikleştirmek için görevi zorla.

Aşağıda snippet'lerim var Gruntfile.js.

ENV kurulumu:

env : {

    options : {

        /* Shared Options Hash */
        //globalOption : 'foo'

    },

    dev: {

        NODE_ENV : 'DEVELOPMENT'

    },

    prod : {

        NODE_ENV : 'PRODUCTION'

    }

},

preprocess:

preprocess : {

    dev : {

        src : './src/tmpl/index.html',
        dest : './dev/index.html'

    },

    prod : {

        src : './src/tmpl/index.html',
        dest : '../<%= pkg.version %>/<%= now %>/<%= ver %>/index.html',
        options : {

            context : {
                name : '<%= pkg.name %>',
                version : '<%= pkg.version %>',
                now : '<%= now %>',
                ver : '<%= ver %>'
            }

        }

    }

}

Görevler:

grunt.registerTask('default', ['jshint']);

grunt.registerTask('dev', ['jshint', 'env:dev', 'clean:dev', 'preprocess:dev']);

grunt.registerTask('prod', ['jshint', 'env:prod', 'clean:prod', 'uglify:prod', 'cssmin:prod', 'copy:prod', 'preprocess:prod']);

Ve /src/tmpl/index.htmlşablon dosyasında (örneğin):

<!-- @if NODE_ENV == 'DEVELOPMENT' -->

    <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.js"></script>
    <script src="../src/js/foo1.js"></script>
    <script src="../src/js/foo2.js"></script>
    <script src="../src/js/jquery.blah.js"></script>
    <script src="../src/js/jquery.billy.js"></script>
    <script src="../src/js/jquery.jenkins.js"></script>

<!-- @endif -->

<!-- @if NODE_ENV == 'PRODUCTION' -->

    <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>

    <script src="http://cdn.foo.com/<!-- @echo name -->/<!-- @echo version -->/<!-- @echo now -->/<!-- @echo ver -->/js/<!-- @echo name -->.min.js"></script>

<!-- @endif -->

Eminim kurulumum çoğu insandan farklıdır ve yukarıdakilerin kullanışlılığı sizin durumunuza bağlı olacaktır. Benim için, harika bir kod olsa da, Yeoman homurdanma usem kişisel olarak ihtiyacımdan daha sağlam.

NOT: Ben sadece ben bir özellik eksik olabilir böylece, bugün yukarıda listelenen görevleri keşfetti ve / veya benim süreç yolda değişebilir. Şimdilik, grunt-preprocess ve grunt-env'nin sunduğu basitliği ve özellikleri seviyorum . :)


Ocak 2014 güncellemesi:

Aşağı oyla motive edildi ...

Bu cevabı gönderdiğimde Grunt 0.4.xiçin ihtiyaçlarım için çalışan bir çözüm sunan pek çok seçenek yoktu . Şimdi, aylar sonra, burada yayınladığımdan daha iyi olabilecek daha fazla seçenek olduğunu tahmin ediyorum. Yapımlarım için hala kişisel olarak bu tekniği kullanmaktan ve kullanmaktan zevk alırken, gelecekteki okuyucuların verilen diğer cevapları okumaya ve tüm seçenekleri araştırmaya zaman ayırmalarını istiyorum. Daha iyi bir çözüm bulursanız, lütfen cevabınızı buraya gönderin.

Şubat 2014 güncellemesi:

Kimseye herhangi bir yardımcı olup olmayacağından emin değilim, ancak GitHub'da yukarıda özetlediğim teknikleri kullanarak tam (ve daha karmaşık bir kurulum) gösteren bu demo deposunu oluşturdum .


Teşekkürler, kontrol edeceğim!
Dmitry Pashkevich

3
Çözümün bana kafamı duvara daldırıp saatler geçirdi. Teşekkürler.
sthomps

1
@sthomps Yardımcı oldu sevindim! Bu görevleri keşfettiğimden beri iş akışını çok seviyorum. Bilginize, süreçte ufak bir değişiklik yaptım ... Html şablonuma birkaç bağlam değişkeni iletmek yerine, path : '/<%= pkg.name %>/dist/<%= pkg.version %>/<%= now %>/<%= ver %>'tüm değişkenleri bir araya getiren bir varya geçmeyi seçtim (bu benim oluşturma yolum). Şablonumun ben gerekecek: <script src="http://cdn.foo.com<!-- @echo path -->/js/bulldog.min.js"></script>. Her neyse, size biraz zaman kazandırabildiğim için mutluyum! : D
mhulse

4
Sadece grunt-template kullanarak , datadev / prod için farklı bir nesneyi ileterek aynı şeyi yapabilirsiniz .
Mathias Bynens

2
Adamım bu çözümü seviyorum .. Temiz, okunabilir ve aşırı mühendislik ürünü değil.
Gaurang Patel

34

Kendi çözümümü buldum. Henüz parlatılmamış ama sanırım bu yönde ilerleyeceğim.

Derinliklerinden, ben kullanıyorum grunt.template.process () gözlerimi üretmek için index.htmlgeçerli yapılandırmayı analiz eder ve minified kodla tek bir dosyaya ya benim özgün kaynak dosyalarının veya bağlantıların bir listesini üreten bir şablondan. Aşağıdaki örnek js dosyaları içindir, ancak aynı yaklaşım css ve diğer olası metin dosyalarına genişletilebilir.

grunt.js:

/*global module:false*/
module.exports = function(grunt) {
    var   // js files
        jsFiles = [
              'src/module1.js',
              'src/module2.js',
              'src/module3.js',
              'src/awesome.js'
            ];

    // Import custom tasks (see index task below)
    grunt.loadTasks( "build/tasks" );

    // Project configuration.
    grunt.initConfig({
      pkg: '<json:package.json>',
      meta: {
        banner: '/*! <%= pkg.name %> - v<%= pkg.version %> - ' +
          '<%= grunt.template.today("yyyy-mm-dd") %> */'
      },

      jsFiles: jsFiles,

      // file name for concatenated js
      concatJsFile: '<%= pkg.name %>-all.js',

      // file name for concatenated & minified js
      concatJsMinFile: '<%= pkg.name %>-all.min.js',

      concat: {
        dist: {
            src: ['<banner:meta.banner>'].concat(jsFiles),
            dest: 'dist/<%= concatJsFile %>'
        }
      },
      min: {
        dist: {
        src: ['<banner:meta.banner>', '<config:concat.dist.dest>'],
        dest: 'dist/<%= concatJsMinFile %>'
        }
      },
      lint: {
        files: ['grunt.js'].concat(jsFiles)
      },
      // options for index.html builder task
      index: {
        src: 'index.tmpl',  // source template file
        dest: 'index.html'  // destination file (usually index.html)
      }
    });


    // Development setup
    grunt.registerTask('dev', 'Development build', function() {
        // set some global flags that all tasks can access
        grunt.config('isDebug', true);
        grunt.config('isConcat', false);
        grunt.config('isMin', false);

        // run tasks
        grunt.task.run('lint index');
    });

    // Production setup
    grunt.registerTask('prod', 'Production build', function() {
        // set some global flags that all tasks can access
        grunt.config('isDebug', false);
        grunt.config('isConcat', true);
        grunt.config('isMin', true);

        // run tasks
        grunt.task.run('lint concat min index');
    });

    // Default task
    grunt.registerTask('default', 'dev');
};

index.js (the index task):

module.exports = function( grunt ) {
    grunt.registerTask( "index", "Generate index.html depending on configuration", function() {
        var conf = grunt.config('index'),
            tmpl = grunt.file.read(conf.src);

        grunt.file.write(conf.dest, grunt.template.process(tmpl));

        grunt.log.writeln('Generated \'' + conf.dest + '\' from \'' + conf.src + '\'');
    });
}

Son olarak, index.tmplkuşak mantığı fırında:

<doctype html>
<head>
<%
    var jsFiles = grunt.config('jsFiles'),
        isConcat = grunt.config('isConcat');

    if(isConcat) {
        print('<script type="text/javascript" src="' + grunt.config('concat.dist.dest') + '"></script>\n');
    } else {
        for(var i = 0, len = jsFiles.length; i < len; i++) {
            print('<script type="text/javascript" src="' + jsFiles[i] + '"></script>\n');
        }
    }
%>
</head>
<html>
</html>

UPD. Öğrendim Yeoman hırıltı dayanmaktadır vardır yerleşik bir usemin görevi olduğunu Yeoman derlenme sistemine sahip bütünleştirir. Diğer ortam ayarlarının yanı sıra index.html'nin geliştirme sürümündeki bilgilerden index.html üretim sürümünü oluşturur. Biraz sofistike ama bakmak ilginç.


5
grunt-template ,grunt.template.process()bunu daha da kolaylaştıracakçok hafif bir sargıdır(burada kullandığınız şeydir). Aynı şeyidev / prod içinfarklı birnesnedengeçirerek grunt-template'i kullanarak da yapabilirsinizdata.
Mathias Bynens

15

Buradaki çözümleri beğenmedim ( daha önce verdiğim çözümler dahil ) ve neden:

  • En yüksek oyu alan sorunun yanıtı , bir JS dosyası eklediğinizde / yeniden adlandırdığınızda / sildiğinizde komut dosyası etiketleri listesini el ile eşitlemeniz gerektiğidir.
  • Kabul edilen yanıtla ilgili sorun , JS dosyaları listenizde kalıp eşleşmesinin bulunamamasıdır. Bu, Gruntfile'da elle güncellemeniz gerektiği anlamına gelir.

Bu sorunların her ikisini de nasıl çözeceğimizi anladım. Grunt görevimi her dosya eklendiğinde veya silindiğinde, komut dosyası etiketlerinin otomatik olarak bunu yansıtacak şekilde oluşturulacağı şekilde ayarladım. Bu şekilde, JS dosyalarınızı eklediğinizde / kaldırdığınızda / yeniden adlandırdığınızda html dosyanızı veya grunt dosyanızı değiştirmeniz gerekmez .

Nasıl çalıştığını özetlemek için, komut dosyası etiketleri için bir değişken ile bir html şablonu var. Bu değişkeni doldurmak için https://github.com/alanshaw/grunt-include-replace kullanıyorum . Dev modunda, bu değişken tüm JS dosyalarımın globbing modelinden geliyor. İzleme görevi bir JS dosyası eklendiğinde veya kaldırıldığında bu değeri yeniden hesaplar.

Şimdi, dev veya prod modunda farklı sonuçlar elde etmek için, bu değişkeni farklı bir değerle doldurmanız yeterlidir. İşte bazı kod:

var jsSrcFileArray = [
    'src/main/scripts/app/js/Constants.js',
    'src/main/scripts/app/js/Random.js',
    'src/main/scripts/app/js/Vector.js',
    'src/main/scripts/app/js/scripts.js',
    'src/main/scripts/app/js/StatsData.js',
    'src/main/scripts/app/js/Dialog.js',
    'src/main/scripts/app/**/*.js',
    '!src/main/scripts/app/js/AuditingReport.js'
];

var jsScriptTags = function (srcPattern, destPath) {
    if (srcPattern === undefined) {
        throw new Error("srcPattern undefined");
    }
    if (destPath === undefined) {
        throw new Error("destPath undefined");
    }
    return grunt.util._.reduce(
        grunt.file.expandMapping(srcPattern, destPath, {
            filter: 'isFile',
            flatten: true,
            expand: true,
            cwd: '.'
        }),
        function (sum, file) {
            return sum + '\n<script src="' + file.dest + '" type="text/javascript"></script>';
        },
        ''
    );
};

...

grunt.initConfig({

    includereplace: {
        dev: {
            options: {
                globals: {
                    scriptsTags: '<%= jsScriptTags(jsSrcFileArray, "../../main/scripts/app/js")%>'
                }
            },
            src: [
                'src/**/html-template.html'
            ],
            dest: 'src/main/generated/',
            flatten: true,
            cwd: '.',
            expand: true
        },
        prod: {
            options: {
                globals: {
                    scriptsTags: '<script src="app.min.js" type="text/javascript"></script>'
                }
            },
            src: [
                'src/**/html-template.html'
            ],
            dest: 'src/main/generatedprod/',
            flatten: true,
            cwd: '.',
            expand: true
        }

...

    jsScriptTags: jsScriptTags

jsSrcFileArraytipik homurdanma dosya-globbing modelinizdir. jsScriptTagsalır jsSrcFileArrayve scripther iki taraftaki etiketlerle birleştirir . destPathher dosyada istediğim ön ek.

HTML şu şekilde görünür:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8"/>
    <title>Example</title>

</head>

<body>    
@@scriptsTags
</body>
</html>

Şimdi, yapılandırmada görebileceğiniz gibi, bu değişkenin değerini sabit kodlu bir scriptetiket olarak üretiyorum prod. Dev modunda, bu değişken şöyle bir değere genişler:

<script src="../../main/scripts/app/js/Constants.js" type="text/javascript"></script>
<script src="../../main/scripts/app/js/Random.js" type="text/javascript"></script>
<script src="../../main/scripts/app/js/Vector.js" type="text/javascript"></script>
<script src="../../main/scripts/app/js/StatsData.js" type="text/javascript"></script>
<script src="../../main/scripts/app/js/Dialog.js" type="text/javascript"></script>

Herhangi bir sorunuz varsa bize bildirin.

Not: Bu, her istemci tarafı JS uygulamasında yapmak istediğim bir şey için çılgın bir kod miktarı. Umarım birisi bunu yeniden kullanılabilir bir eklentiye dönüştürebilir. Belki bir gün yapacağım.


1
Umut verici geliyor. Parçacıkları paylaşma şansın var mı?
Adam Marshall

I've set up my grunt task so that every time a file is added or deleted, the script tags automatically get generated to reflect thatBunu nasıl yaptın?
CodyBugstein

2
Başka bir soru: HTML <script>etiketlerinin bloklarını silmenin bir yolunu biliyor musunuz ?
CodyBugstein

@Imray kafamın üstünden değil. Herhangi bir şablonlama (yani, grunt-include-replace) olmadan mı demek istediniz? Kafama gelen ilk düşünce xslt olurdu. Muhtemelen iyi bir çözüm değil.
Daniel Kaplan

1
Ben şahsen kaldırıldı gerçi Bu cevap, üzerinde nokta destPathdan jsScriptTagsve takas grunt.file.expandMappingile grunt.file.expandistediğim dosyaların doğru yerlerde zaten olduğu gibi. Bu işleri basitleştirdi. Teşekkürler @DanielKaplan, bana büyük miktarda zaman
kazandın

13

Kendime bir süredir aynı soruyu soruyorum ve bence bu homurdanma eklentisi istediğiniz şeyi yapacak şekilde yapılandırılmış olabilir: https://npmjs.org/package/grunt-targethtml . Grunt hedefine bağlı olan koşullu html etiketlerini uygular.


2
Bu eklentiyi gördüm ama benim indeks.html tüm dosyaları (ve aslında herhangi bir mantık) belirtme fikrini sevmiyorum çünkü zaten benim homurdanma yapılandırmasında kaynak js / css dosyalarının bir listesi var ve don ' Kendimi tekrarlamak istemiyorum. Alt satır - hangi dosyaları dahil edeceğinize karar vermeniz gereken index.html'de değil
Dmitry Pashkevich

Grunt-targethtml için +1. İndex.html dosyasında hangi varlıkların yükleneceğine "karar vermek" için if ifadeleri eklemek biraz çirkin olsa da. Yine de mantıklı. Burası normalde projenize kaynakları dahil etmek isteyeceğiniz yerdir. Ayrıca, bunu takip etmek beni grunt-katkıda kontrol etmek için götürdü. İçinde harika şeyler var.
carbontax

8

Daha basit, basit bir çözüm arıyordum, bu yüzden bu sorunun cevabını birleştirdim:

Gruntfile.js'de başka bir blok varsa nasıl yerleştirilir

ve aşağıdaki basit adımlarla geldi:

  1. Dizin dosyalarınızın iki sürümünü listelediğiniz gibi saklayın ve index-development.html ve index-prodoction.html olarak adlandırın.
  2. İndex.html dosyanız için Gruntfile.js dosyasının concat / copy bloğunda aşağıdaki mantığı kullanın:

    concat: {
        index: {
            src : [ (function() {
                if (grunt.option('Release')) {
                  return 'views/index-production.html';
                } else {
                  return 'views/index-development.html';
                }
              }()) ],
           dest: '<%= distdir %>/index.html',
           ...
        },
        ...
    },
  3. index-production.html dosyasını seçmek için 'grunt --Release' komutunu çalıştırın ve geliştirme sürümüne sahip olmak için bayrağı bırakın.

Eklenecek veya yapılandırılacak yeni eklentiler ve yeni homurdanma görevleri yok.


3
Buradaki tek dezavantaj, bakımı gereken iki index.html dosyası olmasıdır.
Adam Marshall

5

Scriptlinker adlı bu homurdanan görev, bet modlarını dev modunda eklemek için kolay bir yol gibi görünüyor. Muhtemelen önce bir concat görevi çalıştırabilir ve ardından prod modunda bitmiş dosyanıza yönlendirebilirsiniz.


+1. Belgeler kafa karıştırıcı ve bazı şeyler (appRoot, göreceli) her zaman amaçlandığı gibi çalışmıyor, ancak yine de yardımcı bir araç.
hashchange

1
@hashchange Bu aracı kullanmıyorum. Bunun yerine github.com/alanshaw/grunt-include-replace kullanarak sona erdi . Benim html dosyasında komut dosyası etiketlerini temsil eden bir değişken var. Sonra bu değişkeni istediğim html dizesi ile dolduruyorum. Dev modunda, bu değişken komut dosyalarının listesidir. Ürün kipinde bu değişken birleştirilmiş, küçültülmüş sürümdür.
Daniel Kaplan

İşaretçi grunt-include-replace için teşekkürler. (Aslında bir dizindeki tüm spec dosyalarını Mocha index.html dosyasına eklemek için bir araca ihtiyacım vardı. Scriptlinker bunun için iyi.)
hashchange

@hashchange belge emme konusunda haklısınız. Komut dosyası döşemelerini html dosyanıza nereye koyacağınızı nasıl anlarsınız ?
Daniel Kaplan

1
Bir HTML yorumu tanımlarsınız. Bu dosyaya bir göz atın . Eklemeler <!--SINON COMPONENT SCRIPTS-->ve konumunda gerçekleşir <!--SPEC SCRIPTS-->. Ve işte bunu yapan Grunt görevi (dokümanlardaki şeylerin aksine gerçek çalışan bir görev). Umarım yardımcı olur;)
hashchange

5

grunt-dom-munger HTML'yi CSS seçicilerle okur ve yönetir . Ör. html'nizdeki etiketleri okuyun. Düğümleri kaldırın, düğüm ekleyin ve daha fazlasını yapın.

İndex.html'nizle bağlantılı tüm JS dosyalarınızı okumak için grunt-dom-munger'ı kullanabilir, bunları uglifed edebilir ve ardından yalnızca küçültülmüş JS'yi bağlamak için index.html dosyanızı değiştirmek için grunt-dom-munger'ı kullanabilirsiniz.


5

Grunt-dev-prod-switch adlı bir homurdanma eklentisi buldum. Tek yaptığı, homurdanmaya geçirdiğiniz bir --env seçeneğine göre aradığı belirli blokları yorumlamaktır (her ne kadar dev, prod ve test ile sınırlandırsa da).

Burada açıklandığı gibi ayarladıktan sonra , örneğin çalıştırabilirsiniz:

grunt serve --env=devve tek yaptığı,

    <!-- env:test/prod -->
    your code here
    <!-- env:test/prod:end -->

ve tarafından sarılmış blokları açacak

    <!-- env:dev -->
    your code here
    <!-- env:dev:end -->

Ayrıca javascript üzerinde çalışır, arka uç API için bağlanmak için doğru IP adresini ayarlamak için kullanın. Bloklar sadece

    /* env:dev */
    your code here
    /* env:dev:end */

Sizin durumunuzda, bu kadar basit olurdu:

<!DOCTYPE html>
<html>
    <head>
        <!-- env:dev -->
        <script src="js/module1.js" />
        <script src="js/module2.js" />
        <script src="js/module3.js" />
        ...
        <!-- env:dev:end -->
        <!-- env:prod -->
        <script src="js/MyApp-all.min.js" />
        ...
        <!-- env:prod:end -->
    </head>
    <body></body>
</html>

4

grunt-bake burada harika çalışacak fantastik bir homurdanmalı komut dosyasıdır. JQM otomatik derleme komut dosyasında kullanıyorum.

https://github.com/imaginethepoet/autojqmphonegap

Benim grunt.coffee dosyasına bir göz atın:

bake:
    resources: 
      files: "index.html":"resources/custom/components/base.html"

Bu, base.html'deki tüm dosyalara bakar ve index.html oluşturmak için onları emer, çok sayfalı uygulamalar (telefon aralığı) için harika çalışır. Bu, tüm geliştiriciler tek bir uzun tek uygulama üzerinde çalışmadığından (çok sayıda çakışma denetimini önler) daha kolay geliştirmeye olanak tanır. Bunun yerine sayfaları parçalayabilir ve daha küçük kod parçaları üzerinde çalışabilir ve bir watch komutunu kullanarak tam sayfaya derleyebilirsiniz.

Bake, base.html'deki şablonu okur ve saatte bileşen html sayfalarını enjekte eder.

<!DOCTYPE html>

jQuery Mobil Demoları

app.initialize ();

<body>
    <!--(bake /resources/custom/components/page1.html)-->
    <!--(bake /resources/custom/components/page2.html)-->
    <!--(bake /resources/custom/components/page3.html)-->
</body>

Bunu bir adım daha ileri taşıyabilir ve sayfalarınızı "menüler" "pop-up'lar" vb. İçin enjeksiyon ekleyebilirsiniz, böylece sayfaları daha küçük yönetilebilir bileşenlere ayırabilirsiniz.


Belki cevabınızı grunt-bake kullanan bir kod demosu ile geliştirebilirsiniz?
Dmitry Pashkevich

4

Bu görevlerin üstesinden gelmek için wiredep https://github.com/taptapship/wiredep ve usemin https://github.com/yeoman/grunt-usemin bir arada kullanın . Wiredep, bağımlılıklarınızı bir kerede bir komut dosyası ekleyecek ve usemin bunları üretim için tek bir dosyada birleştirecektir. Bu daha sonra bazı html yorumlarıyla gerçekleştirilebilir. Örneğin, bower paketlerim otomatik olarak dahil edilir ve çalıştırdığımda html'ye eklenir bower install && grunt bowerInstall:

<!-- build:js /scripts/vendor.js -->
<!-- bower:js -->
<!-- endbower -->
<!-- endbuild -->

2

Bu cevap yeni başlayanlar için değil!

Jade şablonunu kullanın ... değişkenleri Jade şablonuna geçirmek bataklık standart kullanım durumudur

Ben homurdanıyorum (homurdanma-katkı-yeşim) ama homurdanmak zorunda değilsiniz. Sadece standart npm yeşim modülünü kullanın.

Grunt kullanıyorsanız, grunt dosyanız aşağıdaki gibi bir şey ister ...

jade: {
    options: {
      // TODO - Define options here
    },
    dev: {
      options: {
        data: {
          pageTitle: '<%= grunt.file.name %>',
          homePage: '/app',
          liveReloadServer: liveReloadServer,
          cssGruntClassesForHtmlHead: 'grunt-' + '<%= grunt.task.current.target %>'
        },
        pretty: true
      },
      files: [
        {
          expand: true,
          cwd: "src/app",
          src: ["index.jade", "404.jade"],
          dest: "lib/app",
          ext: ".html"
        },
        {
          expand: true,
          flatten: true,
          cwd: "src/app",
          src: ["directives/partials/*.jade"],
          dest: "lib/app/directives/partials",
          ext: ".html"
        }
      ]
    }
  },

Şimdi yeşim şablonundan homurdanarak geçirilen verilere kolayca erişebiliriz.

Modernizr tarafından kullanılan yaklaşıma çok benzer şekilde, geçirilen değişkenin değerine göre HTML etiketi üzerinde bir CSS sınıfı ayarladım ve CSS sınıfının mevcut olup olmamasına bağlı olarak oradan JavaScript mantığı kullanabilirim.

Açısal kullanıldığında bu harika bir özelliktir, çünkü sınıfın var olup olmadığına bağlı olarak sayfadaki öğeleri dahil edebileceksiniz.

Örneğin, sınıf varsa bir komut dosyası içerebilir ...

(Örneğin, canlı yeniden yükleme komut dosyasını geliştiriciye dahil edebilirim, ancak prodüksiyona eklemeyebilirim)

<script ng-if="controller.isClassPresent()" src="//localhost:35729/livereload.js"></script> 

2

Processhtml'i düşünün . Yapılar için birden fazla "hedef" tanımına izin verir. Yorumlar, koşullu olarak HTML'den malzeme eklemek veya HTML'den hariç tutmak için kullanılır:

<!-- build:js:production js/app.js -->
...
<!-- /build -->

olur

<script src="js/app.js"></script>

Böyle şık şeyler yapmayı bile iddia ediyor (bkz . README ):

<!-- build:[class]:dist production -->
<html class="debug_mode">
<!-- /build -->

<!-- class is changed to 'production' only when the 'dist' build is executed -->
<html class="production">
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.