☰

debugout

主要用于日志检测脚本的调用

此脚本不应直接安装，它是一个供其他脚本使用的外部库。如果您需要使用该库，请在脚本元属性加入：// @require https://update.cn-greasyfork.org/scripts/440535/1021754/debugout.js 

  1. /*
  2.  
  3.     debugout.js
  4.     by @inorganik
  5.     
  6. */
  7.  
  8. // save all the console.logs
  9. function debugout() {
  10. 	var self = this;
  11.  
  12. 	// OPTIONS
  13. 	self.realTimeLoggingOn = true; // log in real time (forwards to console.log)
  14. 	self.useTimestamps = false; // insert a timestamp in front of each log
  15. 	self.useLocalStorage = false; // store the output using window.localStorage() and continuously add to the same log each session
  16. 	self.recordLogs = true; // set to false after you're done debugging to avoid the log eating up memory
  17. 	self.autoTrim = true; // to avoid the log eating up potentially endless memory
  18. 	self.maxLines = 2500; // if autoTrim is true, this many most recent lines are saved
  19. 	self.tailNumLines = 100; // how many lines tail() will retrieve
  20. 	self.logFilename = 'debugout.txt'; // filename of log downloaded with downloadLog()
  21.  
  22. 	// vars
  23. 	self.depth = 0;
  24. 	self.parentSizes = [0];
  25. 	self.currentResult = '';
  26. 	self.startTime = new Date();
  27. 	self.output = '';
  28.  
  29. 	this.version = function() { return '0.5.0' }
  30.  
  31. 	/*
  32. 		USER METHODS
  33. 	*/
  34. 	this.getLog = function() {
  35. 		var retrievalTime = new Date();
  36. 		// if recording is off, so dev knows why they don't have any logs
  37. 		if (!self.recordLogs) {
  38. 			self.log('[debugout.js] log recording is off.');
  39. 		}
  40. 		// if using local storage, get values
  41. 		if (self.useLocalStorage) {
  42. 			var saved = window.localStorage.getItem('debugout.js');
  43. 			if (saved) {
  44. 				saved = JSON.parse(saved);
  45. 				self.startTime = new Date(saved.startTime);
  46. 				self.output = saved.log;
  47. 				retrievalTime = new Date(saved.lastLog);
  48. 			}
  49. 		}
  50. 		return self.output
  51. 			+ '\n---- Log retrieved: '+retrievalTime+' ----\n'
  52. 			+ self.formatSessionDuration(self.startTime, retrievalTime);
  53. 	}
  54. 	// accepts optional number or uses the default for number of lines
  55. 	this.tail = function(numLines) {
  56. 		var numLines = numLines || self.tailLines;
  57. 		return self.trimLog(self.getLog(), numLines);
  58. 	}
  59. 	// accepts a string to search for
  60. 	this.search = function(string) {
  61. 		var lines = self.output.split('\n');
  62. 		var rgx = new RegExp(string);
  63. 		var matched = [];
  64. 		// can't use a simple Array.prototype.filter() here
  65. 		// because we need to add the line number
  66. 		for (var i = 0; i < lines.length; i++) {
  67. 			var addr = '['+i+'] ';
  68. 			if (lines[i].match(rgx)) {
  69. 				matched.push(addr + lines[i]);
  70. 			}
  71. 		}
  72. 		var result = matched.join('\n');
  73. 		if (result.length == 0) result = 'Nothing found for "'+string+'".';
  74. 		return result
  75. 	}
  76. 	// accepts the starting line and how many lines after the starting line you want
  77. 	this.getSlice = function(lineNumber, numLines) {
  78. 		var lines = self.output.split('\n');
  79. 		var segment = lines.slice(lineNumber, lineNumber + numLines);
  80. 		return segment.join('\n');
  81. 	}
  82. 	// immediately downloads the log - for desktop browser use
  83. 	this.downloadLog = function() {
  84. 		var file = "data:text/plain;charset=utf-8,";
  85. 		var logFile = self.getLog();
  86. 		var encoded = encodeURIComponent(logFile);
  87. 		file += encoded;
  88. 		var a = document.createElement('a');
  89. 		a.href = file;
  90. 		a.target   = '_blank';
  91. 		a.download = self.logFilename;
  92. 		document.body.appendChild(a);
  93. 		a.click();
  94. 		a.remove();
  95. 	}
  96. 	// clears the log
  97. 	this.clear = function() {
  98. 		var clearTime = new Date();
  99. 		self.output = '---- Log cleared: '+clearTime+' ----\n';
  100. 		if (self.useLocalStorage) {
  101. 			// local storage
  102. 			var saveObject = {
  103. 				startTime: self.startTime,
  104. 				log: self.output,
  105. 				lastLog: clearTime
  106. 			}
  107. 			saveObject = JSON.stringify(saveObject);
  108. 			window.localStorage.setItem('debugout.js', saveObject);
  109. 		}
  110. 		if (self.realTimeLoggingOn) console.log('[debugout.js] clear()');
  111. 	}
  112. 	// records a log
  113. 	this.log = function(obj) {
  114. 		// log in real time
  115. 		if (self.realTimeLoggingOn) console.log(obj);
  116. 		// record log
  117. 		var type = self.determineType(obj);
  118. 		if (type != null && self.recordLogs) {
  119. 			var addition = self.formatType(type, obj);
  120. 			// timestamp, formatted for brevity
  121. 			if (self.useTimestamps) {
  122. 				var logTime = new Date();
  123. 				self.output += self.formatTimestamp(logTime);
  124. 			}
  125. 			self.output += addition+'\n';
  126. 			if (self.autoTrim) self.output = self.trimLog(self.output, self.maxLines);
  127. 			// local storage
  128. 			if (self.useLocalStorage) {
  129. 				var last = new Date();
  130. 				var saveObject = {
  131. 					startTime: self.startTime,
  132. 					log: self.output,
  133. 					lastLog: last
  134. 				}
  135. 				saveObject = JSON.stringify(saveObject);
  136. 				window.localStorage.setItem('debugout.js', saveObject);
  137. 			}
  138. 		}
  139. 		self.depth = 0;
  140. 		self.parentSizes = [0];
  141. 		self.currentResult = '';
  142. 	}
  143. 	/*
  144. 		METHODS FOR CONSTRUCTING THE LOG
  145. 	*/
  146.  
  147. 	// like typeof but classifies objects of type 'object'
  148. 	// kept separate from formatType() so you can use at your convenience!
  149. 	this.determineType = function(object) {
  150. 		if (object != null) {
  151. 			var typeResult;
  152. 			var type = typeof object;
  153. 			if (type == 'object') {
  154. 				var len = object.length;
  155. 				if (len == null) {
  156. 					if (typeof object.getTime == 'function') {
  157. 						typeResult = 'Date';
  158. 					}
  159. 					else if (typeof object.test == 'function') {
  160. 						typeResult = 'RegExp';
  161. 					}
  162. 					else {
  163. 						typeResult = 'Object';
  164. 					}
  165. 				} else {
  166. 					typeResult = 'Array';
  167. 				}
  168. 			} else {
  169. 				typeResult = type;
  170. 			}
  171. 			return typeResult;
  172. 		} else {
  173. 			return null;
  174. 		}
  175. 	}
  176. 	// format type accordingly, recursively if necessary
  177. 	this.formatType = function(type, obj) {
  178. 		switch(type) {
  179. 			case 'Object' :
  180. 				self.currentResult += '{\n';
  181. 				self.depth++;
  182. 				self.parentSizes.push(self.objectSize(obj));
  183. 				var i = 0;
  184. 				for (var prop in obj) {
  185. 					self.currentResult += self.indentsForDepth(self.depth);
  186. 					self.currentResult += prop + ': ';
  187. 					var subtype = self.determineType(obj[prop]);
  188. 					var subresult = self.formatType(subtype, obj[prop]);
  189. 					if (subresult) {
  190. 						self.currentResult += subresult;
  191. 						if (i != self.parentSizes[self.depth]-1) self.currentResult += ',';
  192. 						self.currentResult += '\n';
  193. 					} else {
  194. 						if (i != self.parentSizes[self.depth]-1) self.currentResult += ',';
  195. 						self.currentResult += '\n';
  196. 					}
  197. 					i++;
  198. 				}
  199. 				self.depth--;
  200. 				self.parentSizes.pop();
  201. 				self.currentResult += self.indentsForDepth(self.depth);
  202. 				self.currentResult += '}';
  203. 				if (self.depth == 0) return self.currentResult;
  204. 				break;
  205. 			case 'Array' :
  206. 				self.currentResult += '[';
  207. 				self.depth++;
  208. 				self.parentSizes.push(obj.length);
  209. 				for (var i = 0; i < obj.length; i++) {
  210. 					var subtype = self.determineType(obj[i]);
  211. 					if (subtype == 'Object' || subtype == 'Array') self.currentResult += '\n' + self.indentsForDepth(self.depth);
  212. 					var subresult = self.formatType(subtype, obj[i]);
  213. 					if (subresult) {
  214. 						self.currentResult += subresult;
  215. 						if (i != self.parentSizes[self.depth]-1) self.currentResult += ', ';
  216. 						if (subtype == 'Array') self.currentResult += '\n';
  217. 					} else {
  218. 						if (i != self.parentSizes[self.depth]-1) self.currentResult += ', ';
  219. 						if (subtype != 'Object') self.currentResult += '\n';
  220. 						else if (i == self.parentSizes[self.depth]-1) self.currentResult += '\n';
  221. 					}
  222. 				}
  223. 				self.depth--;
  224. 				self.parentSizes.pop();
  225. 				self.currentResult += ']';
  226. 				if (self.depth == 0) return self.currentResult;
  227. 				break;
  228. 			case 'function' :
  229. 				obj += '';
  230. 				var lines = obj.split('\n');
  231. 				for (var i = 0; i < lines.length; i++) {
  232. 					if (lines[i].match(/\}/)) self.depth--;
  233. 					self.currentResult += self.indentsForDepth(self.depth);
  234. 					if (lines[i].match(/\{/)) self.depth++;
  235. 					self.currentResult += lines[i] + '\n';
  236. 				}
  237. 				return self.currentResult;
  238. 				break;
  239. 			case 'RegExp' :
  240. 				return '/'+obj.source+'/';
  241. 				break;
  242. 			case 'Date' :
  243. 			case 'string' :
  244. 				if (self.depth > 0 || obj.length == 0) {
  245. 					return '"'+obj+'"';
  246. 				} else {
  247. 					return obj;
  248. 				}
  249. 			case 'boolean' :
  250. 				if (obj) return 'true';
  251. 				else return 'false';
  252. 			case 'number' :
  253. 				return obj+'';
  254. 				break;
  255. 		}
  256. 	}
  257. 	this.indentsForDepth = function(depth) {
  258. 		var str = '';
  259. 		for (var i = 0; i < depth; i++) {
  260. 			str += '\t';
  261. 		}
  262. 		return str;
  263. 	}
  264. 	this.trimLog = function(log, maxLines) {
  265. 		var lines = log.split('\n');
  266. 		if (lines.length > maxLines) {
  267. 			lines = lines.slice(lines.length - maxLines);
  268. 		}
  269. 		return lines.join('\n');
  270. 	}
  271. 	this.lines = function() {
  272. 		return self.output.split('\n').length;
  273. 	}
  274. 	// calculate testing time
  275. 	this.formatSessionDuration = function(startTime, endTime) {
  276. 		var msec = endTime - startTime;
  277. 		var hh = Math.floor(msec / 1000 / 60 / 60);
  278. 		var hrs = ('0' + hh).slice(-2);
  279. 		msec -= hh * 1000 * 60 * 60;
  280. 		var mm = Math.floor(msec / 1000 / 60);
  281. 		var mins = ('0' + mm).slice(-2);
  282. 		msec -= mm * 1000 * 60;
  283. 		var ss = Math.floor(msec / 1000);
  284. 		var secs = ('0' + ss).slice(-2);
  285. 		msec -= ss * 1000;
  286. 		return '---- Session duration: '+hrs+':'+mins+':'+secs+' ----'
  287. 	}
  288. 	this.formatTimestamp = function(timestamp) {
  289. 		var year = timestamp.getFullYear();
  290. 		var date = timestamp.getDate();
  291. 		var month = ('0' + (timestamp.getMonth() +1)).slice(-2);
  292. 		var hrs = Number(timestamp.getHours());
  293. 		var mins = ('0' + timestamp.getMinutes()).slice(-2);
  294. 		var secs = ('0' + timestamp.getSeconds()).slice(-2);
  295. 		return '['+ year + '-' + month + '-' + date + ' ' + hrs + ':' + mins + ':'+secs + ']: ';
  296. 	}
  297. 	this.objectSize = function(obj) {
  298. 		var size = 0, key;
  299. 		for (key in obj) {
  300. 			if (obj.hasOwnProperty(key)) size++;
  301. 		}
  302. 		return size;
  303. 	}
  304.  
  305. 	/*
  306. 		START/RESUME LOG
  307. 	*/
  308. 	if (self.useLocalStorage) {
  309. 		var saved = window.localStorage.getItem('debugout.js');
  310. 		if (saved) {
  311. 			saved = JSON.parse(saved);
  312. 			self.output = saved.log;
  313. 			var start = new Date(saved.startTime);
  314. 			var end = new Date(saved.lastLog);
  315. 			self.output += '\n---- Session end: '+saved.lastLog+' ----\n';
  316. 			self.output += self.formatSessionDuration(start, end);
  317. 			self.output += '\n\n';
  318. 		}
  319. 	}
  320. 	self.output += '---- Session started: '+self.startTime+' ----\n\n';
  321. }