test-parse-number.js

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