Node.jsでスクリプトが実行されているかどうかを確認するにはどうすればよいですか？

Node.jsスクリプトに必要なスクリプトがあります。JavaScriptエンジンを独立させておきたいのですが。

たとえば、exports.x = y;Node.jsで実行されている場合にのみ実行したいと思います。このテストを実行するにはどうすればよいですか？

この質問を投稿したとき、Node.jsモジュールの機能がCommonJSに基づいていることを知りませんでした。

私が挙げた具体的な例では、より正確な質問は次のようになります。

CommonJSモジュールとして必要であるかどうかをスクリプトで確認するにはどうすればよいですか？

CommonJSのサポートを探すことで、これはUnderscore.jsライブラリが行う方法です。

編集：更新された質問へ：

(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._ = _;
    }
})();

ここでの例は、モジュールパターンを保持しています。

すべてのWebサイトが同じ変数を簡単に宣言できるため、Node.jsで実行を検出する信頼できる方法はありません。windowただし、Node.jsにはデフォルトでオブジェクトがないため、他の方法で回避して、内部で実行されているかどうかを確認できます。ブラウザ。

これは、ブラウザとNode.jsの両方で機能するライブラリに使用するものです。

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

} else {
    window.foo = {};
}

windowNode.jsで定義されている場合でも爆発する可能性がありますが、明示的に除外するかオブジェクトのプロパティを設定する必要があるため、誰かがこれを行う正当な理由はありません。varglobal

編集

スクリプトがCommonJSモジュールとして必要であるかどうかを検出するために、これも簡単ではありません。commonJSが指定しているのは、A：モジュールが関数の呼び出しを介して含まれること、requireおよびB：モジュールがexportsオブジェクトのプロパティを介して物事をエクスポートすることだけです。これがどのように実装されるかは、基になるシステムに任されています。Node.jsは、モジュールのコンテンツを無名関数でラップします。

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

参照：https : //github.com/ry/node/blob/master/src/node.js#L325

しかし、いくつかのクレイジーなものを介してそれを検出しようとせずarguments.callee.toString()、代わりにブラウザをチェックする上記のサンプルコードを使用してください。Node.jsはよりクリーンな環境であるため、windowそこで宣言されることはほとんどありません。

私は現在、誤解を招く機能検出のため、Electronのノード環境を認識していないノードの誤った検出に遭遇しました。次のソリューションは、プロセス環境を明示的に識別します。

Node.jsのみを識別する

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

process.release「現在の[Node-] releaseに関連するメタデータ」が含まれているため、Node-processで実行しているかどうかがわかります。

io.jsの生成後、の値process.release.nameも同様になる可能性がありますio.js（process-docを参照）。ノード対応環境を適切に検出するには、次のように確認する必要があります。

ノード（> = 3.0.0）またはio.jsを識別します

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

このステートメントは、ノード5.5.0、エレクトロン0.36.9（ノード5.1.1を含む）、およびChrome 48.0.2564.116でテストされました。

ノード（> = 0.10.0）またはio.jsを識別します

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

@daluegeのコメントは、より一般的な証明について考えるきっかけになりました。これはNode.js> = 0.10から機能するはずです。以前のバージョンの一意の識別子が見つかりませんでした。

Ps：OPは別の質問への回答を探していましたが、質問がここに導いてくれたので、ここでその回答を投稿しています。

コードが実行されている環境を把握しようとする際の問題は、オブジェクトを変更および宣言できるため、どのオブジェクトが環境にネイティブで、どのオブジェクトがプログラムによって変更されたかを把握することがほぼ不可能になることです。

ただし、現在の環境を確認するために使用できるいくつかのトリックがあります。

下線ライブラリで使用されている一般に受け入れられているソリューションから始めましょう：

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

require関数が呼び出されると、thisオブジェクトが空のオブジェクトにリセットされ、再定義さmoduleれるので、外部の改ざんを心配する必要がないので、この手法は実際にはサーバー側にとって完全に適切です。コードがで読み込まれている限り、require安全です。

ただし、これはブラウザ上ではバラバラになっており、誰でも簡単に定義moduleして、探しているオブジェクトのように見せかけることができます。一方でこれはあなたが望む振る舞いかもしれませんが、それはまた、ライブラリユーザーがグローバルスコープで使用できる変数を決定します。多分誰かが別の用途のためにmoduleそのexports中にある名前を持つ変数を使いたいと思うでしょう。ありそうもないことですが、別の環境がその変数名を使用しているという理由だけで、他の誰かが使用できる変数を判断するのは誰ですか？

ただし、トリックは、スクリプトがグローバルスコープで読み込まれていると想定している場合（スクリプトタグを介して読み込まれている場合）、変数が外部クロージャーで予約できないことです。これは、ブラウザーで許可されていないためです。 。ノードで覚えておいてください、thisオブジェクトは空のオブジェクトmoduleですが、変数はまだ利用可能です。それは外側のクロージャーで宣言されているからです。アンダースコアのチェックを修正するには、追加のチェックを追加します。

this.module !== module

これにより、誰かmoduleがブラウザのグローバルスコープで宣言すると、thisオブジェクトに配置されます。これはthis.module、がモジュールと同じオブジェクトになるため、テストが失敗する原因になります。ノードにthis.moduleは存在せずmodule、外側のクロージャー内に存在するため、同等ではないため、テストは成功します。

したがって、最終的なテストは次のとおりです。

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

注：これにより、module変数をグローバルスコープで自由に使用できるようになりますが、新しいクロージャーを作成しmoduleてその中で宣言し、そのクロージャー内でスクリプトをロードすることにより、ブラウザーでこれをバイパスすることも可能です。その時点で、ユーザーはノード環境を完全に複製しており、うまくいけば、自分が何をしているかを理解しており、ノードスタイルで必要なことを実行しようとしています。コードがスクリプトタグで呼び出された場合でも、新しい外部クロージャーからは安全です。

以下は、故意に、明示的に妨害されない限り、ブラウザで機能します。

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

バム。

同様にそれを行うにはかなりクールな方法があります：

const isBrowser = this.window === this;

これは、ブラウザではグローバルな「this」変数に「ウィンドウ」と呼ばれる自己参照があるため機能します。この自己参照はノードに存在しません。

• ブラウザでは、「this」は「window」と呼ばれるグローバルオブジェクトへの参照です。
• ノードの 'this'はmodule.exportsオブジェクトへの参照です。
  • 「これ」は「グローバル」と呼ばれるノードグローバルオブジェクトへの参照ではありません。
  • 「これ」は、モジュール変数宣言スペースへの参照ではありません。

上記の推奨ブラウザチェックを解除するには、次のようなことを行う必要があります。

this.window = this;

チェックを実行する前。

さらに別の環境検出：

（意味：ここでの答えのほとんどは問題ありません。）

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 ?..
}

少し偏執的ですね？より多くのグローバルをチェックすることで、これをより詳細にすることができます。

しかし、しないでください。

上記のこれらすべてはとにかく偽造/シミュレーションすることができます。

たとえば、globalオブジェクトを偽造するには：

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

これはノードの元のグローバルオブジェクトにアタッチされませんがwindow、ブラウザでオブジェクトにアタッチされます。したがって、ブラウザ内のノード環境にいることを意味します。

人生は短いです！

私たちの環境が偽物であるかどうかを気にしますか？愚かな開発者globalがグローバルスコープで呼び出されるグローバル変数を宣言すると発生します。または、悪意のある開発者がなんとかして環境にコードを挿入します。

これをキャッチするとコードが実行されない場合がありますが、アプリの他の多くの依存関係がこれに巻き込まれる可能性があります。したがって、最終的にはコードが壊れます。コードが十分であれば、他の人が行った可能性のあるすべての愚かな間違いを気にしないでください。

だから何？

2つの環境をターゲットにする場合：ブラウザーとノード。
"use strict"; windowまたは単にを確認するかglobal、そして、あなたのコードがこれらの環境のみをサポートすることをドキュメントで明確に示してください。それでおしまい！

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

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

あなたのユースケースで可能であれば; 環境検出の代わりに; try / catchブロック内で同期機能検出を行います。（これらの実行には数ミリ秒かかります）。

例えば

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

提案されたソリューションのほとんどは、実際に偽造することができます。堅牢な方法は、Classを使用してグローバルオブジェクトの内部プロパティをチェックすることObject.prototype.toStringです。JavaScriptで内部クラスを偽造することはできません。

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

プロセスオブジェクトの使用とexecPathのチェックについてはnodeどうですか？

process.execPath

これは、プロセスを開始した実行可能ファイルの絶対パス名です。

例：

/ usr / local / bin / node

スクリプトは、commonjsモジュールとして必要かどうかをどのようにして知ることができますか？

関連：モジュールとして必要であるか、ノードで直接実行する必要があるかを確認するには、を確認しrequire.main !== moduleます。 http://nodejs.org/docs/latest/api/modules.html#accessing_the_main_module

これが上記のものの私のバリエーションです：

(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;});

これを使用するには、最後の2行目の「House」をモジュールの名前をブラウザに表示するように変更し、モジュールの値を通常のように公開します（通常はコンストラクタまたはオブジェクトリテラル） ）。

ブラウザでは、グローバルオブジェクトはwindowであり、それ自体への参照を持っています（== windowであるwindow.windowがあります）。これは、ブラウザーを使用している場合、またはブラウザーを使用していると信じ込ませたい環境でない限り、発生する可能性は低いようです。他のすべての場合では、宣言されたグローバル「モジュール」変数がある場合、それを使用します。それ以外の場合は、グローバルオブジェクトを使用します。

私はprocessそのようにnode.jsをチェックするために使用しています

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

または

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

ここに文書化

この記事の執筆時点では、この回答はJavaScriptの非常に新しい機能を活用しているため、「近日公開」の選択肢となっています。

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

runtime値がどちらかになりますnodeかnot node。

前述のように、これはいくつかの新しいJavaScript機能に依存しています。globalThisECMAScript 2020仕様の最終的な機能です。オプションのチェーン/ヌルの合体（の?一部globalThis.process?.release?.name）は、Chrome 80に同梱されているV8エンジンでサポートされています。2020年4月8日以降、このコードはブラウザーでは機能しますが、ノード13ブランチが使用するため、ノードでは機能しません。 V8 7.9.xxx。ノード14（2020年4月21日リリース予定）ではV8 8.x +を使用することになっています。

このアプローチには、現在の制限の健全な線量が付属しています。しかしながら; ブラウザ/ノードがリリースされるペースは、最終的に信頼できるワンライナーになるでしょう。

Node.jsにはprocessオブジェクトがあります。そのため、作成processする他のスクリプトがない限り、それを使用して、コードがノードで実行されるかどうかを判断できます。

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");
}

これは、サーバーサイドとクライアントサイドのjavascript間の互換性を保証するかなり安全で簡単な方法であり、browserify、RequireJS、またはCommonJSに含まれるクライアントサイドでも機能します。

(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;
}())

編集：更新された質問について：「スクリプトは、commonjsモジュールとして必要であったかどうかをどのようにして知ることができますか？」できないと思います。仕様ではモジュールに提供する必要があるためexports、がオブジェクト（if (typeof exports === "object")）かどうかを確認できますが、... がオブジェクトであることだけがわかります。:-)exports

元の答え：

（私は確かにいくつかのNodeJS固有のシンボルがありますよんEventEmitter多分、 何、あなたが使用する必要がありますrequire。下記を参照のイベントモジュールを取得するには、むしろ（あなたがチェックすることができること）が、ダビデは言ったように、理想的にあなたは特徴を検出方がいいでしょう環境よりも）そうすることが理にかなっている場合。

更新：おそらく次のようなものです：

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

ただし、これは、requireNodeJSと非常によく似た環境にいることを示していますBuffer。:-)

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

デバッグパッケージのソースから：

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のソースを取得して、のような変数を定義するように変更しますrunningOnNodeJS。コードでその変数を確認します。

node.jsの独自のプライベートバージョンを作成できない場合は、プロジェクトで機能リクエストを開きます。実行しているnode.jsのバージョンを提供する変数を定義するよう依頼してください。次に、その変数を確認します。

非常に古い投稿ですが、requireステートメントをtryでラップして解決しました-catch

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