在this链接后，我创建了一个带有'require（getmac）'脚本的文件index.js并运行了命令browserify index.js > bundle.js
文件bundle.js已经创建了，我在脚本路径<script src="/bundle.js"></script>中添加了相同的文件。我还在项目中添加了文件bundle.js，但每次加载时我都会收到错误Uncaught TypeError: Cannot read property 'indexOf' of undefined。页。
错误位于bundle.js中的isWindows = process.platform.indexOf('win') === 0;行。详细说明我发现 process.platform 的脚本未定义。请按照脚本查找bundle.js的内容
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
},{}],2:[function(require,module,exports){
// shim for using process in browser
var process = module.exports = {};
// cached from whatever global is present so that test runners that stub it
// don't break things. But we need to wrap it in a try catch in case it is
// wrapped in strict mode code which doesn't define any globals. It's inside a
// function because try/catches deoptimize in certain engines.
var cachedSetTimeout;
var cachedClearTimeout;
function defaultSetTimout() {
throw new Error('setTimeout has not been defined');
}
function defaultClearTimeout () {
throw new Error('clearTimeout has not been defined');
}
(function () {
try {
if (typeof setTimeout === 'function') {
cachedSetTimeout = setTimeout;
} else {
cachedSetTimeout = defaultSetTimout;
}
} catch (e) {
cachedSetTimeout = defaultSetTimout;
}
try {
if (typeof clearTimeout === 'function') {
cachedClearTimeout = clearTimeout;
} else {
cachedClearTimeout = defaultClearTimeout;
}
} catch (e) {
cachedClearTimeout = defaultClearTimeout;
}
} ())
function runTimeout(fun) {
if (cachedSetTimeout === setTimeout) {
//normal enviroments in sane situations
return setTimeout(fun, 0);
}
// if setTimeout wasn't available but was latter defined
if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
cachedSetTimeout = setTimeout;
return setTimeout(fun, 0);
}
try {
// when when somebody has screwed with setTimeout but no I.E. maddness
return cachedSetTimeout(fun, 0);
} catch(e){
try {
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
return cachedSetTimeout.call(null, fun, 0);
} catch(e){
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
return cachedSetTimeout.call(this, fun, 0);
}
}
}
function runClearTimeout(marker) {
if (cachedClearTimeout === clearTimeout) {
//normal enviroments in sane situations
return clearTimeout(marker);
}
// if clearTimeout wasn't available but was latter defined
if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
cachedClearTimeout = clearTimeout;
return clearTimeout(marker);
}
try {
// when when somebody has screwed with setTimeout but no I.E. maddness
return cachedClearTimeout(marker);
} catch (e){
try {
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
return cachedClearTimeout.call(null, marker);
} catch (e){
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
// Some versions of I.E. have different rules for clearTimeout vs setTimeout
return cachedClearTimeout.call(this, marker);
}
}
}
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;
function cleanUpNextTick() {
if (!draining || !currentQueue) {
return;
}
draining = false;
if (currentQueue.length) {
queue = currentQueue.concat(queue);
} else {
queueIndex = -1;
}
if (queue.length) {
drainQueue();
}
}
function drainQueue() {
if (draining) {
return;
}
var timeout = runTimeout(cleanUpNextTick);
draining = true;
var len = queue.length;
while(len) {
currentQueue = queue;
queue = [];
while (++queueIndex < len) {
if (currentQueue) {
currentQueue[queueIndex].run();
}
}
queueIndex = -1;
len = queue.length;
}
currentQueue = null;
draining = false;
runClearTimeout(timeout);
}
process.nextTick = function (fun) {
var args = new Array(arguments.length - 1);
if (arguments.length > 1) {
for (var i = 1; i < arguments.length; i++) {
args[i - 1] = arguments[i];
}
}
queue.push(new Item(fun, args));
if (queue.length === 1 && !draining) {
runTimeout(drainQueue);
}
};
// v8 likes predictible objects
function Item(fun, array) {
this.fun = fun;
this.array = array;
}
Item.prototype.run = function () {
this.fun.apply(null, this.array);
};
process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];
process.version = ''; // empty string to avoid regexp issues
process.versions = {};
function noop() {}
process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;
process.prependListener = noop;
process.prependOnceListener = noop;
process.listeners = function (name) { return [] }
process.binding = function (name) {
throw new Error('process.binding is not supported');
};
process.cwd = function () { return '/' };
process.chdir = function (dir) {
throw new Error('process.chdir is not supported');
};
process.umask = function() { return 0; };
},{}],3:[function(require,module,exports){
require('getmac')
},{"getmac":6}],4:[function(require,module,exports){
'use strict';
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
/* eslint no-cond-assign:0 */
// Import
var typeChecker = require('typechecker');
// Eachr
module.exports = function eachr(subject, callback) {
// Handle
if (typeChecker.isArray(subject)) {
for (var key = 0; key < subject.length; ++key) {
var value = subject[key];
if (callback.call(subject, value, key, subject) === false) {
break;
}
}
} else if (typeChecker.isPlainObject(subject)) {
for (var _key in subject) {
if (subject.hasOwnProperty(_key)) {
var _value = subject[_key];
if (callback.call(subject, _value, _key, subject) === false) {
break;
}
}
}
} else if (typeChecker.isMap(subject)) {
var entries = subject.entries();
var entry = void 0;while (entry = entries.next().value) {
var _entry = entry;
var _entry2 = _slicedToArray(_entry, 2);
var _key2 = _entry2[0];
var _value2 = _entry2[1]; // destructuring
if (callback.call(subject, _value2, _key2, subject) === false) {
break;
}
}
} else {
// Perhaps falling back to a `for of` loop here would be sensible
throw new Error('eachr does not know how to iterate what was passed to it');
}
// Return
return subject;
};
},{"typechecker":7}],5:[function(require,module,exports){
'use strict';
// Import
var typeChecker = require('typechecker');
var eachr = require('eachr');
// Define
module.exports = function (opts, next) {
var config = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
// Empty, set default
if (config.completionCallbackNames == null) {
config.completionCallbackNames = ['next'];
}
// Not array, make array
else if (typeChecker.isArray(config.completionCallbackNames) === false) {
config.completionCallbackNames = [config.completionCallbackNames];
}
// Arguments
if (typeChecker.isFunction(opts) && next == null) {
next = opts;
opts = {};
} else if (!opts) {
opts = {};
}
// Completion callback
if (!next) {
// Cycle the completionCallbackNames to check if the completion callback name exists in opts
// if it does, then use it as the next and delete it's value
eachr(config.completionCallbackNames, function (completionCallbackName) {
if (typeof opts[completionCallbackName] !== 'undefined') {
next = opts[completionCallbackName];
delete opts[completionCallbackName];
return false; // break
// ^ why this only does the first, and not all, using the last, I don't know ...
// can be changed in a future major update
}
});
}
// Ensure
if (!next) next = null;
// Return
return [opts, next];
};
},{"eachr":4,"typechecker":7}],6:[function(require,module,exports){
(function (process){
// Generated by CoffeeScript 1.10.0
var exec, extractOptsAndCallback, getMac, isMac, isWindows, macRegex, zeroRegex;
exec = require('child_process').exec;
extractOptsAndCallback = require('extract-opts');
isWindows = process.platform.indexOf('win') === 0;
macRegex = /(?:[a-z0-9]{2}[:\-]){5}[a-z0-9]{2}/ig;
zeroRegex = /(?:[0]{2}[:\-]){5}[0]{2}/;
getMac = function(opts, next) {
var command, data, extractMac, ref;
ref = extractOptsAndCallback(opts, next), opts = ref[0], next = ref[1];
data = opts.data;
if (data == null) {
data = null;
}
command = isWindows ? "getmac" : "ifconfig -a || ip link";
extractMac = function(data, next) {
var err, isZero, macAddress, match, result;
result = null;
while (match = macRegex.exec(data)) {
macAddress = match[0];
isZero = zeroRegex.test(macAddress);
if (isZero === false) {
if (result == null) {
result = macAddress;
}
}
}
if (result === null) {
err = new Error('could not determine the mac address from:\n' + data);
return next(err);
}
return next(null, result);
};
if (data) {
return extractMac(data, next);
} else {
return exec(command, function(err, stdout, stderr) {
if (err) {
return next(err);
}
return extractMac(stdout, next);
});
}
};
isMac = function(macAddress) {
var ref;
return ((ref = String(macAddress).match(macRegex)) != null ? ref.length : void 0) === 1;
};
module.exports = {
macRegex: macRegex,
getMac: getMac,
isMac: isMac
};
}).call(this,require('_process'))
},{"_process":2,"child_process":1,"extract-opts":5}],7:[function(require,module,exports){
/* @flow */
/* eslint quote-props:0 */
'use strict';
// Character positions
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
var INDEX_OF_FUNCTION_NAME = 9; // "function X", X is at index 9
var FIRST_UPPERCASE_INDEX_IN_ASCII = 65; // A is at index 65 in ASCII
var LAST_UPPERCASE_INDEX_IN_ASCII = 90; // Z is at index 90 in ASCII
// -----------------------------------
// Values
/**
* Get the object type string
* @param {any} value
* @returns {string}
*/
function getObjectType(value /* :mixed */) /* :string */{
return Object.prototype.toString.call(value);
}
/**
* Checks to see if a value is an object
* @param {any} value
* @returns {boolean}
*/
function isObject(value /* :any */) /* :boolean */{
// null is object, hence the extra check
return value !== null && (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object';
}
/**
* Checks to see if a value is an object and only an object
* @param {any} value
* @returns {boolean}
*/
function isPlainObject(value /* :any */) /* :boolean */{
/* eslint no-proto:0 */
return isObject(value) && value.__proto__ === Object.prototype;
}
/**
* Checks to see if a value is empty
* @param {any} value
* @returns {boolean}
*/
function isEmpty(value /* :mixed */) /* :boolean */{
return value == null;
}
/**
* Is empty object
* @param {any} value
* @returns {boolean}
*/
function isEmptyObject(value /* :Object */) /* :boolean */{
// We could use Object.keys, but this is more effecient
for (var key in value) {
if (value.hasOwnProperty(key)) {
return false;
}
}
return true;
}
/**
* Is ES6+ class
* @param {any} value
* @returns {boolean}
*/
function isNativeClass(value /* :mixed */) /* :boolean */{
// NOTE TO DEVELOPER: If any of this changes, isClass must also be updated
return typeof value === 'function' && value.toString().indexOf('class') === 0;
}
/**
* Is Conventional Class
* Looks for function with capital first letter MyClass
* First letter is the 9th character
* If changed, isClass must also be updated
* @param {any} value
* @returns {boolean}
*/
function isConventionalClass(value /* :any */) /* :boolean */{
if (typeof value !== 'function') return false;
var c = value.toString().charCodeAt(INDEX_OF_FUNCTION_NAME);
return c >= FIRST_UPPERCASE_INDEX_IN_ASCII && c <= LAST_UPPERCASE_INDEX_IN_ASCII;
}
// There use to be code here that checked for CoffeeScript's "function _Class" at index 0 (which was sound)
// But it would also check for Babel's __classCallCheck anywhere in the function, which wasn't sound
// as somewhere in the function, another class could be defined, which would provide a false positive
// So instead, proxied classes are ignored, as we can't guarantee their accuracy, would also be an ever growing set
// -----------------------------------
// Types
/**
* Is Class
* @param {any} value
* @returns {boolean}
*/
function isClass(value /* :any */) /* :boolean */{
// NOTE TO DEVELOPER: If any of this changes, you may also need to update isNativeClass
if (typeof value !== 'function') return false;
var s = value.toString();
if (s.indexOf('class') === 0) return true;
var c = s.charCodeAt(INDEX_OF_FUNCTION_NAME);
return c >= FIRST_UPPERCASE_INDEX_IN_ASCII && c <= LAST_UPPERCASE_INDEX_IN_ASCII;
}
/**
* Checks to see if a value is an error
* @param {any} value
* @returns {boolean}
*/
function isError(value /* :mixed */) /* :boolean */{
return value instanceof Error;
}
/**
* Checks to see if a value is a date
* @param {any} value
* @returns {boolean}
*/
function isDate(value /* :mixed */) /* :boolean */{
return getObjectType(value) === '[object Date]';
}
/**
* Checks to see if a value is an arguments object
* @param {any} value
* @returns {boolean}
*/
function isArguments(value /* :mixed */) /* :boolean */{
return getObjectType(value) === '[object Arguments]';
}
/**
* Checks to see if a value is a function
* @param {any} value
* @returns {boolean}
*/
function isFunction(value /* :mixed */) /* :boolean */{
return getObjectType(value) === '[object Function]';
}
/**
* Checks to see if a value is an regex
* @param {any} value
* @returns {boolean}
*/
function isRegExp(value /* :mixed */) /* :boolean */{
return getObjectType(value) === '[object RegExp]';
}
/**
* Checks to see if a value is an array
* @param {any} value
* @returns {boolean}
*/
function isArray(value /* :mixed */) /* :boolean */{
return typeof Array.isArray === 'function' && Array.isArray(value) || getObjectType(value) === '[object Array]';
}
/**
* Checks to see if a valule is a number
* @param {any} value
* @returns {boolean}
*/
function isNumber(value /* :mixed */) /* :boolean */{
return typeof value === 'number' || getObjectType(value) === '[object Number]';
}
/**
* Checks to see if a value is a string
* @param {any} value
* @returns {boolean}
*/
function isString(value /* :mixed */) /* :boolean */{
return typeof value === 'string' || getObjectType(value) === '[object String]';
}
/**
* Checks to see if a valule is a boolean
* @param {any} value
* @returns {boolean}
*/
function isBoolean(value /* :mixed */) /* :boolean */{
return value === true || value === false || getObjectType(value) === '[object Boolean]';
}
/**
* Checks to see if a value is null
* @param {any} value
* @returns {boolean}
*/
function isNull(value /* :mixed */) /* :boolean */{
return value === null;
}
/**
* Checks to see if a value is undefined
* @param {any} value
* @returns {boolean}
*/
function isUndefined(value /* :mixed */) /* :boolean */{
return typeof value === 'undefined';
}
/**
* Checks to see if a value is a Map
* @param {any} value
* @returns {boolean}
*/
function isMap(value /* :mixed */) /* :boolean */{
return getObjectType(value) === '[object Map]';
}
/**
* Checks to see if a value is a WeakMap
* @param {any} value
* @returns {boolean}
*/
function isWeakMap(value /* :mixed */) /* :boolean */{
return getObjectType(value) === '[object WeakMap]';
}
// -----------------------------------
// General
/**
* The type mapping (type => method) to use for getType. Frozen.
*/
var typeMap = Object.freeze({
array: isArray,
boolean: isBoolean,
date: isDate,
error: isError,
class: isClass,
function: isFunction,
null: isNull,
number: isNumber,
regexp: isRegExp,
string: isString,
'undefined': isUndefined,
map: isMap,
weakmap: isWeakMap,
object: isObject
});
/**
* Get the type of the value in lowercase
* @param {any} value
* @param {Object} [customTypeMap] a custom type map (type => method) in case you have new types you wish to use
* @returns {?string}
*/
function getType(value /* :mixed */) /* :?string */{
var customTypeMap /* :Object */ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : typeMap;
// Cycle through our type map
for (var key in customTypeMap) {
if (customTypeMap.hasOwnProperty(key)) {
if (customTypeMap[key](value)) {
return key;
}
}
}
// No type was successful
return null;
}
// Export
module.exports = {
getObjectType: getObjectType,
isObject: isObject,
isPlainObject: isPlainObject,
isEmpty: isEmpty,
isEmptyObject: isEmptyObject,
isNativeClass: isNativeClass,
isConventionalClass: isConventionalClass,
isClass: isClass,
isError: isError,
isDate: isDate,
isArguments: isArguments,
isFunction: isFunction,
isRegExp: isRegExp,
isArray: isArray,
isNumber: isNumber,
isString: isString,
isBoolean: isBoolean,
isNull: isNull,
isUndefined: isUndefined,
isMap: isMap,
isWeakMap: isWeakMap,
typeMap: typeMap,
getType: getType
};
},{}]},{},[3]);
我是否遗漏了任何步骤或丢失了任何文件？或者是否可以使用browserify从浏览器中获取mac地址？