-
-
Save ephys/9d0534a9ae5e54ff05a81f5c791e75aa to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
(function () { | |
console.table = function (tableData) { | |
const rows = Object.keys(tableData); | |
if (rows.length === 0) { | |
return ''; | |
} | |
const columns = Object.keys(tableData[rows[1]]); | |
if (columns.length === '0') { | |
return ''; | |
} | |
const table = [['']]; | |
for (column of columns) { | |
table.push([column]); | |
} | |
for (row of rows) { | |
table[0].push(row); | |
const rowData = tableData[row]; | |
const keys = Object.keys(rowData); | |
for (let i = 0; i < keys.length; i++) { | |
const column = table[i + 1]; | |
const item = rowData[keys[i]]; | |
column.push(stringify(item)); | |
} | |
} | |
const columnWidths = table.map(column => { | |
return Math.max(...column.map(item => item.length)); | |
}); | |
const stringifiedRows = []; | |
for (let rowNum = 0; rowNum < table[0].length; rowNum++) { | |
let stringifiedRow = '|'; | |
for (let colNum = 0; colNum < table.length; colNum++) { | |
const column = table[colNum]; | |
const width = columnWidths[colNum]; | |
const item = column[rowNum]; | |
stringifiedRow += ' ' + item.padEnd(width) + ' |'; | |
} | |
stringifiedRows.push(stringifiedRow); | |
} | |
let separator = '|'; | |
for (let columnWidth of columnWidths) { | |
separator += '|'.padStart(columnWidth + 3, '-') ; | |
} | |
stringifiedRows.splice(1, 0, separator); | |
console.log(stringifiedRows.join('\n')); | |
}; | |
const parsers = { | |
'parseInt(x, 10)': (val) => Number.parseInt(val, 10), | |
'parseInt(x)': (val) => Number.parseInt(val), | |
'parseFloat(x)': (val) => Number.parseFloat(val), | |
'Number(x)': Number, | |
// 'unary plus: +x': (val) => +val, | |
// 'Pow: x ** 1': (val) => val ** 1, | |
// 'Multiplication: x * 1': (val) => val * 1, | |
// 'Division: x / 1': (val) => val / 1, | |
// 'bitwise or: x | 0': (val) => val | 0, | |
'right shift: x >> 0': (val) => val >> 0, | |
// 'left shift: x << 0': (val) => val << 0, | |
'uright shift: x >>> 0': (val) => val >>> 0, | |
}; | |
function parseBatch(values) { | |
const results = {}; | |
for (const parserName of Object.keys(parsers)) { | |
const parser = parsers[parserName]; | |
const parserResults = results[parserName] = {}; | |
for (const value of values) { | |
const valueName = stringify(value); | |
try { | |
const result = parser(value); | |
parserResults[valueName] = result; | |
} catch (e) { | |
parserResults[valueName] = e.name; | |
} | |
} | |
} | |
return results; | |
} | |
const NUMBER_ABOVE_MAX = '1.7976931348623157e+309'; | |
const NUMBER_BELOW_MIN = '-1.7976931348623157e+309'; | |
const LOW_PRECISION = '1.1e-324'; | |
function stringify(item) { | |
if (Object.is(item, -0)) { | |
return '-0'; | |
} | |
if (Object.is(item, NaN)) { | |
return 'NaN'; | |
} | |
if (Object.is(item, Number.POSITIVE_INFINITY)) { | |
return '+Infinity'; | |
} | |
if (Object.is(item, Number.NEGATIVE_INFINITY)) { | |
return '-Infinity'; | |
} | |
if (item === Number.MAX_VALUE) { | |
return 'MAX_VALUE'; | |
} | |
if (item === -Number.MAX_VALUE) { | |
return '-MAX_VALUE'; | |
} | |
if (item === Number.MIN_VALUE) { | |
return 'MIN_VALUE'; | |
} | |
if (item === Number.MAX_SAFE_INTEGER) { | |
return 'MAX_SAFE_INTEGER'; | |
} | |
if (item === Number.MIN_SAFE_INTEGER) { | |
return 'MIN_SAFE_INTEGER'; | |
} | |
if (item === String(Number.MAX_VALUE)) { | |
return 'MAX_VALUE (as string)'; | |
} | |
if (item === String(-Number.MAX_VALUE)) { | |
return '-MAX_VALUE (as string)'; | |
} | |
if (item === String(Number.MIN_VALUE)) { | |
return 'MIN_VALUE (as string)'; | |
} | |
if (item === String(Number.MAX_SAFE_INTEGER)) { | |
return 'MAX_SAFE_INTEGER (as string)'; | |
} | |
if (item === String(Number.MIN_SAFE_INTEGER)) { | |
return 'MIN_SAFE_INTEGER (as string)'; | |
} | |
if (item === NUMBER_ABOVE_MAX) { | |
return '> MAX_VALUE (as string)'; | |
} | |
if (item === NUMBER_BELOW_MIN) { | |
return '< -MAX_VALUE (as string)'; | |
} | |
if (item === LOW_PRECISION) { | |
return 'LOW_PRECISION (as string)'; | |
} | |
if (item === null) { | |
return 'null'; | |
} | |
if (item === void 0) { | |
return 'undefined'; | |
} | |
const type = typeof item; | |
if (type === 'symbol') { | |
return String(item); | |
} | |
if (type === 'object' && item.name) { | |
return item.name; | |
} | |
return JSON.stringify(item); | |
} | |
console.clear(); | |
console.info('Primitives'); | |
console.table(parseBatch([ | |
true, | |
false, | |
null, | |
undefined, | |
Symbol('some symbol'), | |
])); | |
console.info('Objects'); | |
console.table(parseBatch([ | |
{}, | |
{ | |
name: '{ toString = 200 }', | |
toString() { | |
return '200'; | |
} | |
}, | |
{ | |
name: '{ toPrimitive = 50|\'100\' }', | |
[Symbol.toPrimitive](hint) { | |
if (hint === 'number') { | |
return 50; | |
} | |
if (hint === 'string') { | |
return '100'; | |
} | |
} | |
}, | |
{ | |
name: '{ toPrimitive = 50|\'100\', toString = 200 }', | |
[Symbol.toPrimitive](hint) { | |
if (hint === 'number') { | |
return 50; | |
} | |
if (hint === 'string') { | |
return '100'; | |
} | |
}, | |
toString() { | |
return '200'; | |
} | |
}, | |
{ | |
name: '{ valueOf = 300 }', | |
valueOf() { | |
return '300'; | |
} | |
}, | |
{ | |
name: '{ toPrimitive = 50|\'100\', toString = 200, valueOf = 300 }', | |
[Symbol.toPrimitive](hint) { | |
if (hint === 'number') { | |
return 50; | |
} | |
if (hint === 'string') { | |
return '100'; | |
} | |
}, | |
toString() { | |
return '200'; | |
}, | |
valueOf() { | |
return '300'; | |
} | |
}, | |
])); | |
console.info('Numbers'); | |
console.table(parseBatch([ | |
+0, | |
-0, | |
NaN, | |
0.45, | |
1.55, | |
Number.MAX_SAFE_INTEGER, | |
Number.MIN_SAFE_INTEGER, | |
Number.MAX_VALUE, | |
-Number.MAX_VALUE, | |
Number.MIN_VALUE, | |
])); | |
console.info('Regular numbers strings'); | |
console.table(parseBatch([ | |
'45', | |
' 45 ', | |
'45px', | |
'NaN', | |
'px45', | |
'1e2', | |
'0b10', | |
'0xff', | |
])); | |
console.info('decimal'); | |
console.table(parseBatch([ | |
'0.45', | |
'.45', | |
'1e-2', | |
'.1e-2', | |
'0b10.10', | |
'0xff.ff', | |
])); | |
console.info('Special Numbers strings'); | |
console.table(parseBatch([ | |
'', | |
'+0', | |
'-0', | |
String(Number.MAX_SAFE_INTEGER), | |
String(Number.MIN_SAFE_INTEGER), | |
String(Number.MAX_VALUE), | |
String(-Number.MAX_VALUE), | |
NUMBER_ABOVE_MAX, | |
NUMBER_BELOW_MIN, | |
String(Number.MIN_VALUE), | |
LOW_PRECISION, | |
])); | |
}()); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment