Bir komut dosyasının Node.js altında çalışıp çalışmadığını nasıl kontrol edebilirim?

JavaScript motorunu bağımsız tutmak istediğim bir Node.js komut dosyasından istediğim bir komut dosyası var.

Örneğin, exports.x = y;yalnızca Node.js altında çalışıyorsa yapmak istiyorum. Bu testi nasıl yapabilirim?

Bu soruyu gönderirken, Node.js modülleri özelliğinin CommonJS'ye dayalı olduğunu bilmiyordum .

Verdiğim belirli örnek için daha doğru bir soru olurdu:

Bir komut dosyası, bir CommonJS modülü olarak gerekli olup olmadığını nasıl anlayabilir?

CommonJS desteği arayarak , Underscore.js kütüphanesi böyle yapar:

Düzenle: güncellenmiş sorunuza:

(function () {

    // Establish the root object, `window` in the browser, or `global` on the server.
    var root = this; 

    // Create a reference to this
    var _ = new Object();

    var isNode = false;

    // Export the Underscore object for **CommonJS**, with backwards-compatibility
    // for the old `require()` API. If we're not in CommonJS, add `_` to the
    // global object.
    if (typeof module !== 'undefined' && module.exports) {
            module.exports = _;
            root._ = _;
            isNode = true;
    } else {
            root._ = _;
    }
})();

Buradaki örnek Modül desenini korur.

Her web sitesi aynı değişkenleri kolayca bildirebildiğinden, Node.js'de çalışmayı tespit etmenin güvenilir bir yolu yoktur, ancak windowNode.js'de varsayılan olarak hiçbir nesne olmadığından , ters yönde gidebilir ve bir Tarayıcı.

Bu bir Tarayıcı ve Node.js altında çalışması gereken kütüphaneler için kullandığım şey:

if (typeof window === 'undefined') {
    exports.foo = {};

} else {
    window.foo = {};
}

windowNode.js'de tanımlanması durumunda yine de patlayabilir, ancak birisinin bunu yapması için iyi bir nedeni yoktur , çünkü nesneyi açıkça bırakmanız varveya özelliği ayarlamanız gerekir global.

DÜZENLE

Komut dosyanızın CommonJS modülü olarak gerekli olup olmadığını tespit etmek için bu yine kolay değildir. CommonJS'nin belirttiği tek şey, A: Modüllerin işleve çağrı yoluyla dahil edileceği requireve B: Modüller nesneleri nesneler üzerindeki özellikler yoluyla dışa aktaracaktır exports. Şimdi bunun nasıl uygulandığı temel sisteme bırakılmıştır. Node.js, modülün içeriğini anonim bir işlevle sarar:

function (exports, require, module, __filename, __dirname) { 

Bkz. Https://github.com/ry/node/blob/master/src/node.js#L325

Ancak bunu çılgınca arguments.callee.toString()şeyler yoluyla tespit etmeye çalışmayın , bunun yerine yukarıdaki Tarayıcı'yı kontrol eden örnek kodumu kullanın. Node.js çok daha temiz bir ortam olduğundan, windoworada ilan edilmesi pek olası değildir .

Şu anda yanıltıcı bir özellik algılaması nedeniyle Elektron'daki Düğüm ortamının farkında olmayan bir Düğüm yanlış tespiti için tökezledim . Aşağıdaki çözümler, işlem ortamını açıkça tanımlar.

Yalnızca Node.js'yi tanımlayın

(typeof process !== 'undefined') && (process.release.name === 'node')

Bu process.release, "geçerli [Düğüm-] sürümü ile ilgili meta veriler" içerdiğinden bir Düğüm işleminde çalışıp çalışmadığınızı keşfedecektir .

İo.js'nin ortaya çıkmasından sonra değeri de process.release.nameolabilir io.js(bkz. Süreç-doc ). Düğüme hazır bir ortamı doğru bir şekilde algılamak için sanırım aşağıdaki gibi kontrol etmelisiniz:

Düğümü Tanımla (> = 3.0.0) veya io.js

(typeof process !== 'undefined') &&
(process.release.name.search(/node|io.js/) !== -1)

Bu ifade Düğüm 5.5.0, Elektron 0.36.9 (Düğüm 5.1.1 ile) ve Chrome 48.0.2564.116 ile test edilmiştir.

Düğümü Tanımla (> = 0.10.0) veya io.js

(typeof process !== 'undefined') &&
(typeof process.versions.node !== 'undefined')

@ daluege'ın yorumu bana daha genel bir kanıt düşünmem için ilham verdi. Bu, Node.js> = 0.10'dan çalışmalıdır . Önceki sürümler için benzersiz bir tanımlayıcı bulamadım.

Ps: OP farklı bir soruya cevap aramasına rağmen, soru beni buraya getirdiğinden beri bu cevabı burada gönderiyorum.

Kodunuzun hangi ortamda çalıştığını anlamaya çalışmayla ilgili sorun, herhangi bir nesnenin değiştirilebileceği ve bildirilebileceğidir, bu da hangi nesnelerin çevreye özgü olduğunu ve program tarafından değiştirildiğini anlamayı imkansız hale getirir.

Ancak, hangi ortamda bulunduğunuzdan emin olmak için kullanabileceğimiz birkaç püf noktası var.

Alt çizgi kütüphanesinde kullanılan genel kabul görmüş çözümle başlayalım:

typeof module !== 'undefined' && module.exports

Bu teknik aslında sunucu tarafı için mükemmel, requireişlev çağrıldığında, thisnesneyi boş bir nesneye sıfırlar ve modulesizin için yeniden tanımlar , yani herhangi bir dış müdahale konusunda endişelenmenize gerek yoktur. Kodunuz yüklendiği requiresürece güvendesiniz.

Ancak, herkes modulearadığınız nesne gibi görünmesini sağlamak için kolayca tanımlayabildiğinden, bu tarayıcıda ayrılır . Bir yandan bu istediğiniz davranış olabilir, ancak kütüphane kullanıcısının genel kapsamda hangi değişkenleri kullanabileceğini de belirler. Belki birisi module, exportsiçinde başka bir kullanım için adı olan bir değişken kullanmak istemektedir . Bu olası değildir, ancak başka bir ortamın bu değişken adını kullanması nedeniyle başka hangi değişkenleri kullanabileceğimizi kime görebiliyoruz?

Ancak, hile, komut dosyanızın genel kapsamda yüklendiğini varsayarsak (bir komut dosyası etiketi aracılığıyla yüklenirse olur), bir değişken bir dış kapanışta ayrılamaz, çünkü tarayıcı buna izin vermez . Şimdi düğümde, thisnesne boş bir nesne olduğunu unutmayın, ancak moduledeğişken hala kullanılabilir. Bunun nedeni dış bir kapanışta beyan edilmiş olmasıdır. Böylece ekstra bir kontrol ekleyerek alt çizginin kontrolünü düzeltebiliriz:

this.module !== module

Bununla, bir kişi moduletarayıcıda genel kapsamda beyan ederse , thisnesnenin içine yerleştirilir , bu da testin başarısız olmasına neden olur, çünkü this.modulemodülle aynı nesne olacaktır. Düğümde, this.moduleyoktur ve modulebir dış kapak içinde bulunur, bu nedenle eşdeğer olmadığı için test başarılı olacaktır.

Böylece, son test:

typeof module !== 'undefined' && this.module !== module

Not: Bu artık moduledeğişkenin global kapsamda serbestçe kullanılmasına izin verse de, yeni bir kapatma oluşturarak ve modulebunun içinde bildirerek , daha sonra komut dosyasını bu kapatma içine yükleyerek bunu tarayıcıda atlamak hala mümkündür . Bu noktada kullanıcı, düğüm ortamını tamamen çoğaltır ve umarım ne yaptıklarını bilir ve bir düğüm stili gereksinimi yapmaya çalışır. Kod bir komut dosyası etiketinde çağrılırsa, yeni dış kapaklardan yine de güvende olacaktır.

Açıkça sabote edilmedikçe aşağıdakiler tarayıcıda çalışır:

if(typeof process === 'object' && process + '' === '[object process]'){
    // is node
}
else{
    // not node
}

Bam.

İşte bunu yapmanın çok güzel bir yolu:

const isBrowser = this.window === this;

Çünkü tarayıcılarda global 'this' değişkeni 'window' adında bir öz referansa sahiptir. Bu öz referans Düğümde mevcut değildir.

• Tarayıcıda 'bu', 'pencere' adı verilen global nesneye bir referanstır.
• 'Düğüm' düğümünde module.exports nesnesine bir başvuru var.
  • 'this', 'global' adı verilen Düğüm genel nesnesine bir başvuru değildir .
  • 'this', modül değişken bildirim alanına bir referans değildir .

Yukarıda önerilen tarayıcı kontrolünü kırmak için aşağıdakine benzer bir şey yapmanız gerekir

this.window = this;

kontrol etmeden önce.

Yine başka bir ortam tespiti :

(Anlamı: buradaki cevapların çoğu iyi.)

function isNode() {
    return typeof global === 'object'
        && String(global) === '[object global]'
        && typeof process === 'object'
        && String(process) === '[object process]'
        && global === global.GLOBAL // circular ref
        // process.release.name cannot be altered, unlike process.title
        && /node|io\.js/.test(process.release.name)
        && typeof setImmediate === 'function'
        && setImmediate.length === 4
        && typeof __dirname === 'string'
        && Should I go on ?..
}

Biraz paranoyak değil mi? Daha denetleyerek bu daha ayrıntılı yapabilirsiniz globaller .

Ama YAPMAYIN !.

Yukarıdaki tüm bunlar sahte / simüle edilebilir.

Örneğin, globalnesneyi taklit etmek için :

global = {
    toString: function () {
        return '[object global]';
    },
    GLOBAL: global,
    setImmediate: function (a, b, c, d) {}
 };
 setImmediate = function (a, b, c, d) {};
 ...

Bu, Düğümün orijinal global nesnesine bağlanmayacak, ancak windownesneye bir tarayıcıda eklenecektir . Yani bir tarayıcı içinde Düğüm env içinde olduğunuz anlamına gelir.

Hayat kısa!

Ortamımızın sahte olup olmadığını önemsiyor muyuz? Bazı aptal geliştiriciler globalküresel kapsamda adlandırılan bir global değişken bildirdiklerinde olur . Ya da bazı kötü geliştiriciler bir şekilde env'imize kod enjekte eder.

Bunu yakaladığımızda kodumuzun yürütülmesini engelleyebiliriz, ancak uygulamamızın diğer birçok bağımlılığı buna yakalanabilir. Sonuçta kod kırılacak. Kodunuz yeterince iyi ise, başkaları tarafından yapılabilecek her aptalca hataya dikkat etmemelisiniz.

Ne olmuş yani?

2 ortamı hedefliyorsanız: Tarayıcı ve Düğüm;
"use strict"; ve ya sadece kontrol edin windowya da global; ve dokümanlarda kodunuzun yalnızca bu ortamları desteklediğini açıkça belirtin. Bu kadar!

var isBrowser = typeof window !== 'undefined'
    && ({}).toString.call(window) === '[object Window]';

var isNode = typeof global !== "undefined" 
    && ({}).toString.call(global) === '[object global]';

Kullanım durumunuz için mümkünse; çevre tespiti yerine; bir try / catch bloğu içinde senkron özellik algılama yapabilir. (bunların yürütülmesi birkaç milisaniye sürer).

Örneğin

function isPromiseSupported() {
    var supported = false;
    try {
        var p = new Promise(function (res, rej) {});
        supported = true;
    } catch (e) {}
    return supported;
}

Önerilen çözümlerin çoğu aslında sahte olabilir. Sağlam bir yol, Classglobal nesnenin dahili özelliğini Object.prototype.toString. Dahili sınıf JavaScript'te taklit edilemez:

var isNode = 
    typeof global !== "undefined" && 
    {}.toString.call(global) == '[object global]';

Hangi süreci nesnesini kullanarak ve denetlenmesi hakkında execPath için node?

process.execPath

Bu, işlemi başlatan yürütülebilir dosyanın mutlak yol adıdır.

Misal:

/ Usr / yerel / bin / düğüm

Bir komut dosyası, ortak bir modül olarak gerekli olup olmadığını nasıl anlayabilir?

İlgili: modül olarak mı yoksa doğrudan düğümde mi çalıştırıldığını kontrol etmek için kontrol edebilirsiniz require.main !== module. http://nodejs.org/docs/latest/api/modules.html#accessing_the_main_module

İşte yukarıda ne var benim varyasyon:

(function(publish) {
    "use strict";

    function House(no) {
        this.no = no;
    };

    House.prototype.toString = function() {
        return "House #"+this.no;
    };

    publish(House);

})((typeof module == 'undefined' || (typeof window != 'undefined' && this == window))
    ? function(a) {this["House"] = a;}
    : function(a) {module.exports = a;});

Bunu kullanmak için, son satırdaki "Ev" i modülün adının tarayıcıda olmasını istediğiniz şekilde değiştirin ve modülün değerinin olmasını istediğiniz her şeyi yayınlayın (genellikle bir kurucu veya nesne değişmezi) ).

Tarayıcılarda genel nesne penceredir ve kendisine bir referansı vardır (== pencere olan bir window.window vardır). Bana öyle geliyor ki, bir tarayıcıda veya bir tarayıcıda olduğuna inanmanızı isteyen bir ortamda değilseniz bu gerçekleşme olasılığı düşüktür. Diğer tüm durumlarda, bildirilen genel bir 'modül' değişkeni varsa, aksi takdirde genel nesneyi kullandığını kullanır.

Ben kullanıyorum processşöyle node.js kontrol etmek için

if (typeof(process) !== 'undefined' && process.version === 'v0.9.9') {
  console.log('You are running Node.js');
} else {
  // check for browser
}

veya

if (typeof(process) !== 'undefined' && process.title === 'node') {
  console.log('You are running Node.js');
} else {
  // check for browser
}

Burada belgelenmiştir

Bu yazıdan itibaren, bu cevap daha çok JavaScript'in yeni özelliklerinden yararlandığını gören bir "yakında" seçeneğidir.

const runtime = globalThis.process?.release?.name || 'not node'
console.log(runtime)

runtimeDeğeri, olacak nodeya da not node.

Belirtildiği gibi, bu birkaç yeni JavaScript özelliğine dayanmaktadır. globalThisECMAScript 2020 spesifikasyonunda kesinleşmiş bir özelliktir. İsteğe bağlı zincirleme / nullish birleştirme ( ?parçası globalThis.process?.release?.name), Chrome 80 ile birlikte gelen V8 motorunda desteklenir. V8 7.9.xxx. Düğüm 14'ün (21.04.2020 tarihinde piyasaya sürülmesi nedeniyle) V8 8.x + kullanması gerektiğine inanıyorum.

Bu yaklaşım, sağlıklı bir doz mevcut kısıtlamalarla birlikte gelir. Ancak; tarayıcıların / Düğümün serbest bırakılma hızı, sonunda güvenilir bir tek katmanlı olacaktır.

Node.js'nin processoluşturduğu başka bir komut dosyanız olmadığı sürece , nesnenin processkodu Node üzerinde çalışıp çalışmadığını belirlemek için kullanabilirsiniz.

var isOnNodeJs = false;
if(typeof process != "undefined") {
  isOnNodeJs = true;
}

if(isOnNodeJs){
  console.log("you are running under node.js");
}
else {
  console.log("you are NOT running under node.js");
}

Bu, browserfy, RequireJS veya CommonJS dahil istemci tarafı ile de çalışacak olan sunucu tarafı ve istemci tarafı javascript arasında uyumluluk sağlamanın oldukça güvenli ve basit bir yoludur:

(function(){

  // `this` now refers to `global` if we're in NodeJS
  // or `window` if we're in the browser.

}).call(function(){
  return (typeof module !== "undefined" &&
    module.exports &&
    typeof window === 'undefined') ?
    global : window;
}())

Düzenleme : Güncellenmiş sorunuzla ilgili olarak: "Bir komut dosyası bir ortak modül olarak gerekli olup olmadığını nasıl anlayabilir?" Yapabileceğini sanmıyorum. exportsBir nesne ( if (typeof exports === "object")) olup olmadığını kontrol edebilirsiniz , çünkü spec modüllere verilmesini gerektirir, ama size söylenen tek şey ... exportsbir nesnedir. :-)

Orijinal cevap:

Eminim kontrol edebileceğiniz NodeJS'ye özgü bir sembol ( EventEmitterbelki de hayır, requireetkinlik modülünü almak için kullanmanız gerekir; aşağıya bakın ), ancak David'in dediği gibi, ideal olarak özelliği algılamaktan daha iyidir (daha doğrusu) çevreden daha fazla).

Güncelleme : Belki şöyle bir şey:

if (typeof require === "function"
    && typeof Buffer === "function"
    && typeof Buffer.byteLength === "function"
    && typeof Buffer.prototype !== "undefined"
    && typeof Buffer.prototype.write === "function") {

Ama bu sadece requireNodeJS'lerin olduğu bir ortamda ve çok, çok benzer bir şeyde olduğunuzu gösterir Buffer. :-)

const isNode =
  typeof process !== 'undefined' &&
  process.versions != null &&
  process.versions.node != null;

Hata ayıklama paketinin kaynağından:

const isBrowser = typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs

https://github.com/visionmedia/debug/blob/master/src/index.js#L6

Node.js kaynağını alın ve aşağıdaki gibi bir değişken tanımlamak için değiştirin runningOnNodeJS . Kodunuzda bu değişkeni kontrol edin.

Kendi özel node.js sürümünüz yoksa, projede bir özellik isteği açın. Çalıştırdığınız node.js sürümünü veren bir değişken tanımladıklarını sorun. Sonra bu değişkeni kontrol edin.

Çok eski yazı, ama ben sadece bir try - catch gerekli ifadeleri sararak çözüldü

try {
     var fs = require('fs')
} catch(e) {
     alert('you are not in node !!!')
}