I created the following Typescript extension to convert a string to Number:
declare global {
interface String {
toNumber(): number | null;
}
}
String.prototype.toNumber = function(this: string) {
return parseFloat(this);
}
When it is not possible to parse the string to number either because it is invalid, null, undefined, etc I would always like to return null.
How can I do this?
I am assuming you already understand the differences between parseFloat / Number as conversion mechanisms.
Effectively all you need to do is check if the output is NaN. You can do this by:
String.prototype.toNumber = function(this: string) {
const num = parseFloat(this);
return Number.isNaN(num) ? null : num;
}
If you want to return either a non-zero valid number (well, note that NaN is a number, but I think I know what you mean), then check for what you don't want before returning:
Object.defineProperty(String.prototype, "toNumber", {
value: function(str) {
let num = Number(str);
return num === 0 || isNaN(num) ? null : num;
}
});
(Defining properties directly on the prototype is a bad habit and can lead to weird behavior; using .defineProperty gives you a property that is not enumerable.)
Oh, and that's JavaScript, obviously, not Typescript.
A simple answer would be to use return Number(this) || null;
The Number function will convert to a number or NaN, NaN || null will return null (because NaN is falsey).
Updated added testing for zero condition, which with the above code would have also returned null. If that is not what you want, this code will allow zero to return. (Note that this can be done many different ways!):
const parsedValue = Number(this);
return parsedValue === 0 ? parsedValue : parsedValue || null;
Updated to use the parseFloat function, example of early exit for string of '0'. Very similar to the previous updated example.
if (this === '0') {
return 0;
}
return parseFloat(this) || null;
I have the following strings:
a='Check 134', a='2020-01-15T10:47:54Z', a='1234', a= some object
I want to check, whether the string is a date or not.
I tried:
new Date(a) instanceof Date &&
!isNaN(new Date(a).getTime())
, but it returns true for a='Check 123', whenever it has numbers.
What could be a better solution?
Note: I do not want to use momentjs, because of project restrictions
Actually, the question should be: how to determine if a given string can be converted to a real Date object?
Now, more things than you like may be converted to a Date (e.g., try new Date("") or new Date(0)). So you may want to use your own restrictions as to what you want to convert. Here's a method that restricts input to either a real Date object or a String:
const canConvertToDate = trial =>
[String, Date].includes(trial.constructor) &&
!isNaN(new Date(trial));
console.log(`canConvertToDate(\`\`): ${canConvertToDate(``)}`);
console.log(`canConvertToDate(\`no dice\`): ${canConvertToDate(`no dice`)}`);
console.log(`canConvertToDate(new Date): ${canConvertToDate(new Date)}`);
console.log(`canConvertToDate(\`2020-03-03 00:00:00\`): ${
canConvertToDate(`2020-03-03 00:00:00`)}`);
console.log(`canConvertToDate(0): ${canConvertToDate(0)}`);
console.log(`canConvertToDate(\`Wed, 11 Mar 2020 09:27:50 GMT\`): ${
canConvertToDate(`Wed, 11 Mar 2020 09:27:50 GMT`)}`);
console.log(`canConvertToDate(new Date().toUTCString()): ${
canConvertToDate(new Date().toUTCString())}`);
console.log(`canConvertToDate(134): ${canConvertToDate(134)}`);
// Please note the browser difference (Chrome / Firefox)
console.log(`canConvertToDate(\`134\`): ${canConvertToDate(`134`)}`);
.as-console-wrapper { top: 0; max-height: 100% !important; }
The previous snippet will not always give you the desired result (see comments).
Alternatively you can also write a parser of some kind to determine if the given string can be converted to Date, to be more (but not 100%) certain that a string is convertable to Date. Something like:
console.log(`tryParseDate(\`\`): ${tryParseDate(``).date}`);
console.log(`tryParseDate(new Date): ${tryParseDate(new Date).date}`);
console.log(`tryParseDate(\`Wed, 11 Mar 2020 09:27:50 GMT\`): ${
tryParseDate(`Wed, 11 Mar 2020 09:27:50 GMT`).date}`);
console.log(`tryParseDate(\`check 134\`): ${tryParseDate(`check 134`).date}`);
console.log(`tryParseDate(\`3-3-2005\`, \`ddmmyyyy\`): ${
tryParseDate(`03-03-2005`, `ddmmyyyy`).date}`);
console.log(`tryParseDate(\`12-22-1998 22:22:10.345\`, \`mmddyyyy\`): ${
tryParseDate(`12-22-1998 22:22:10.345`, `mmddyyyy`).date}`);
console.log(`tryParseDate(\`29-02-2019 22:22:10.345\`, \`ddmmyyyy\`): ${
tryParseDate(`29-02-2019 22:22:10.345`, `ddmmyyyy`).date}`);
function tryParseDate(someString, format = `yyyymmdd`) {
const invalid = {cando: false, date: new Date(`invalid`)};
if (someString.constructor !== String) { return { ...invalid, date: `Invalid Date: input not a string` }; }
const between = (val, lower, upper) => val >= lower && val <= upper;
const d = someString.split(/[/\- T:.]/g);
if (d.length < 3) { return {...invalid, date: `Invalid Date: can't split to anything useful`}; }
const formats = format.match(/(yyyy)|(mm)|(dd)/gi);
const values = {
year: +d[formats.findIndex(v => v === `yyyy`)],
month: +d[formats.findIndex(v => v === `mm`)],
date: +d[formats.findIndex(v => v === `dd`)] };
const cando = !isNaN(values.year) && values.year > 0 &&
!isNaN(values.month) && between(values.month, 1, 12)
!isNaN(values.date) && between(values.date, 1, 31);
if (!cando) {
return {...invalid, date: `Invalid Date: the given value is not valid`};
}
const date2Parse = `${d[formats.findIndex(v => v=== `yyyy`)]}/${
d[formats.findIndex(v => v=== `mm`)]}/${
d[formats.findIndex(v => v=== `dd`)]} ${
d.slice(3).map((v, i) => !i ? v : i > 2 ? `.${v}` : `:${v}`).join(``)}`;
const parsed = new Date(date2Parse);
const checkLeap = parsed.getMonth() + 1 === values.month;
const error = `Impossible Date: ${
!checkLeap ? `${values.year} not a leap year` : `parsing failed`}`;
return isNaN(parsed) || !checkLeap
? {...invalid, date: error}
: {cando: true, date: parsed};
}
.as-console-wrapper { top: 0; max-height: 100% !important; }
Since you already know the format of the dates that you want to check, use may be momentjs and check against the format
var moment = require("moment");
var res = moment("Check 123", "YYYY-MM-DD", true).isValid();
console.log(res);
It is possible to check whether the string contains year, month, day. In addition, we can add some conditions to have stricter rules to define whether string is Date:
const isDate = str => {
let [y,M,d,h,m,s] = str.split(/[- : T Z]/);
return (y && M <= 12 && d <= 31) ? true : false;
}
An example:
const isDate = str => {
let [y,M,d,h,m,s] = str.split(/[- : T Z]/);
return (y && M <= 12 && d <= 31) ? true : false;
}
console.log('Check 134', isDate('Check 134'))
console.log('2020-01-15T10:47:54Z', isDate('2020-01-15T10:47:54Z'))
console.log('1234', isDate('1234'))
console.log('13-13-13', isDate('13-13-13'))
Here is a simple function that uses Date.parse() internally; when you pass a string with whitespaces to Date.parse(), it will ignore non-digit chars and will return positive; hence you need to remove the space characters before passing it to Date.parse()
const a= 'Check 134';
const b= '2020-01-15T10:47:54Z';
const c= '1234';
const tricky = '1'; // a number from -12 to 13 is valid
function isValidDate (str) {
// optional condition to eliminate the tricky ones
// since chrome will prepend zeros (000...) to the string and then parse it
let noSpace = str.replace(/\s/g, '')
if( noSpace.length < 3) {
return false
}
return Date.parse(noSpace) > 0
}
console.log(a,isValidDate(a))
console.log(b,isValidDate(b))
console.log(c,isValidDate(c))
console.log(tricky,isValidDate(tricky))
// only in chrome
console.log("'1' is ", Date.parse('1') > 1 ," since it can be ", new Date('1').toString())
Edit: there are still some caveats to work Date in Chrome since it has open issue on that, there is lots of discussion around it, check this SO question the tricky corner cases in chrome are a more than that; It seems the best way to run it Chrome is to know your expected input type and validate it according to it; (e.g. RFC 2822/ISO 8601 date format). there are robust regexes for known date formats to use and confirm but trying to validate all available date formats in chrome at the moment have lots corner cases and potential false positives
You can try to use Date.parse() and then check for a positive number (date > 0).
For example:
Date.parse('2020-01-15T10:47:54Z') // 1579085274000
Date.parse('123') // -23225875200000
Date.parse('Check 134') // -57938551324000
https://jsfiddle.net/zmLbh0tu/
You can use Date.parse(). If it returns positive value then it's valid otherwise not. For ex:-
Date.parse("2020-01-15T10:47:54Z")
Just use typeof operator. No need to user any external libraries.
if (typeof date === 'object') {
// date is object
}
if (typeof date === 'string') {
//date is string
}
I have for example a date and amount property stored in the url als query params
...?date=2019-06-12T06:20:39.465Z&amount=20000
I want to be able to parse ALL query params and assign them to their proper type with javascript.
currently I'm using
paramMap.keys.forEach(key => {
let value: any = paramMap.get(key);
if (isFinite(Date.parse(value))) {
// keep as string
} else if (isFinite(parseInt(value, 10))) {
value = isInteger(value) ? parseInt(value, 10) : parseFloat(value);
} else if (value === 'true' || value === 'false') {
value = value === 'true';
}
obj[key] = value;
});
return obj;
In this case the amount=20000 will get recognised by Date.parse.
also
2019-06-12T06:20:39.465Z will be parsed to 2019 with parseInt...
isFinie, parseInt and isInteger are imported from lodash.
If possible I dont want to use regex.
EDIT: Please assume that I don't know the name of the key. Hence the script should work for all properties.
ISO may omit seconds or timezone or milliseconds, but if you ignore those and check everything else you can reliably check against different ISO formats.
console.log(isISO('2019-06-12T06:20:39.234Z'))
console.log(isISO('2019-06-12T06:20:39'))
console.log(isISO('2019-06-12T06:20'))
console.log(isISO("2019-1-1"))
console.log(isISO('2019-06-12T06:20:39+05'))
console.log(isISO('ketchup'))
function isISO(str) {
try {
str = str.split('+')[0];
var iso = new Date(str).toISOString();
var [date, time] = iso.split('T');
var [y, m, d] = date.split('-');
return iso.indexOf(`${y}-${m}-${d}`) === 0;
} catch (e) {
return false;
}
}
Use the + operator, the Number function, or lodash's _.toNumber() which will return NaN for strings with mixed numbers:
console.log(+'2019-06-12T06:20:39.465Z')
console.log(+'20000')
So the logic would be:
const parseParam = value => {
let v = +value
if (!isNaN(v)) return v
v = Date.parse(value)
if (!isNaN(v)) return v
if (value === 'true' || value === 'false') return value === 'true'
return value
}
console.log(parseParam('2019-06-12T06:20:39.465Z'))
console.log(parseParam('20000'))
console.log(parseParam('false'))
console.log(parseParam('cats'))
I have a TypeScript class without any import statement at the top. When I new calculateDate() and execute addMonth(new Date(), 1), it adds 11 months to today instead of 2. The m variable is always a result of string concatenation, instead of math addition operation. I even tried parseInt() with the string form of the two operands, it still performs string concatenation. Please help. Thanks.
export class calculateDate {
addMonth(thisDate:Date, monthCount:number){
if (thisDate && monthCount && monthCount != -1) {
let m : number = thisDate.getMonth() + monthCount;
console.log('m=', m);
let newDate: Date = new Date(thisDate.setMonth(m));
return newDate;
}
else
return null;
}
}
You are adding up two strings, try to parse them as int or use this syntax +thisDate.getMonth() + (+monthCount)
I have a user database like this:
const user = {
subscription: {
plan: 'free_trial',
},
};
I need to check some condition before user changes plan.
const currentDate = new Date();
if (user.subscription.trialExpDate > currentDate) {
// do something
} else {
// trialExpDate is either undefined or <= currentDate
user.subscription.trialExpDate = currentDate;
}
My question is, for some users trialExpDate will be undefined. Is it okay to compare undefined against currentDate object? Or do I need to check if trialExpDate exist first?
I would suggest check with hasownproperty.
Sample:
if (user.subscription.hasOwnProperty('trialExpDate') && user.subscription.trialExpDate > currentDate) {
// do something
} else {
// trialExpDate is either undefined or <= currentDate
user.subscription.trialExpDate = currentDate;
}
You can just check if it is null.
if (user.subscription.trialExpDate != null || user.subscription.trialExpDate > currentDate) {
// do something
}
else {
// do something else
}
The variable != null will simultaneously check if the variable is null or undefined.
In short: if you're sure that user.subscription.trialExpDate cannot be a null, using your original code is very okay.
See how the JavaScript relational comparison operators coerce types.
If user.subscription always exist and it is always an object, comparison between a Date object, and an undefined or a NaN, is evaluated as false. However, for a null, it is evaluated as +0, thus null < (new Date) will be true, null > (new Date) will be false.
When JavaScript relational comparison works,
A Date object is converted to its timestamp, which is (The Date object).valueOf().
A primitive is converted to a number, which means:
an undefined is converted to a NaN;
a null is converted to +0.
Then the comparison is performed between each item as you'd expect for the operator. Note that any comparison involving a NaN evaluates to false.