我正在开发一个表单小部件，供用户在文本输入中输入一天中的时间（用于日历应用程序）。使用 JavaScript（我们使用 jQuery FWIW），我想找到解析用户输入到 JavaScriptDate()对象中的文本的最佳方法，以便我可以轻松地对其进行比较和其他操作。
我尝试了这种parse()方法，但它对我的需求来说有点太挑剔了。我希望它能够成功地将以下示例输入时间（除了其他逻辑上相似的时间格式）解析为同一个Date()对象：
我在想我可能会使用正则表达式来拆分输入并提取我想用来创建Date()对象的信息。做这个的最好方式是什么？
适用于您指定的输入的快速解决方案：
function parseTime( t ) {
var d = new Date();
var time = t.match( /(\d+)(?::(\d\d))?\s*(p?)/ );
d.setHours( parseInt( time[1]) + (time[3] ? 12 : 0) );
d.setMinutes( parseInt( time[2]) || 0 );
return d;
}
var tests = [
'1:00 pm','1:00 p.m.','1:00 p','1:00pm','1:00p.m.','1:00p','1 pm',
'1 p.m.','1 p','1pm','1p.m.', '1p', '13:00','13', '1a', '12', '12a', '12p', '12am', '12pm', '2400am', '2400pm', '2400',
'1000', '100', '123', '2459', '2359', '2359am', '1100', '123p',
'1234', '1', '9', '99', '999', '9999', '99999', '0000', '0011', '-1', 'mioaw' ];
for ( var i = 0; i < tests.length; i++ ) {
console.log( tests[i].padStart( 9, ' ' ) + " = " + parseTime(tests[i]) );
}它也应该适用于其他一些品种（例如，即使使用 am，它仍然可以工作）。显然这很粗糙，但也很轻巧（例如，使用它比使用完整的库便宜得多）。
警告：代码不适用于 12:00 AM 等。
提供的所有示例在上午 12:00 到上午 12:59 的时间段内都无法工作。如果正则表达式与时间不匹配，它们也会引发错误。下面处理这个：
function parseTime(timeString) {
if (timeString == '') return null;
var time = timeString.match(/(\d+)(:(\d\d))?\s*(p?)/i);
if (time == null) return null;
var hours = parseInt(time[1],10);
if (hours == 12 && !time[4]) {
hours = 0;
}
else {
hours += (hours < 12 && time[4])? 12 : 0;
}
var d = new Date();
d.setHours(hours);
d.setMinutes(parseInt(time[3],10) || 0);
d.setSeconds(0, 0);
return d;
}
var tests = [
'1:00 pm','1:00 p.m.','1:00 p','1:00pm','1:00p.m.','1:00p','1 pm',
'1 p.m.','1 p','1pm','1p.m.', '1p', '13:00','13', '1a', '12', '12a', '12p', '12am', '12pm', '2400am', '2400pm', '2400',
'1000', '100', '123', '2459', '2359', '2359am', '1100', '123p',
'1234', '1', '9', '99', '999', '9999', '99999', '0000', '0011', '-1', 'mioaw' ];
for ( var i = 0; i < tests.length; i++ ) {
console.log( tests[i].padStart( 9, ' ' ) + " = " + parseTime(tests[i]) );
}这适用于其中包含时间的字符串。因此“abcde12:00pmdef”将被解析并返回下午 12 点。如果期望的结果是它只返回字符串中仅包含时间的时间，则可以使用以下正则表达式，前提是您将“time[4]”替换为“time[6]”。
/^(\d+)(:(\d\d))?\s*((a|(p))m?)?$/i
不要费心自己做，只需使用datejs。
当无法解析字符串时，这里的大多数正则表达式解决方案都会引发错误，并且其中没有多少会考虑诸如1330or之类的字符串130pm。尽管 OP 没有指定这些格式，但我发现它们对于解析人类输入的日期至关重要。
所有这些让我想到使用正则表达式可能不是最好的方法。
我的解决方案是一个函数，它不仅解析时间，还允许您指定输出格式和将分钟舍入到的步长（间隔）。大约 70 行，它仍然是轻量级的，可以解析所有上述格式以及不带冒号的格式。
function parseTime(time, format, step) {
var hour, minute, stepMinute,
defaultFormat = 'g:ia',
pm = time.match(/p/i) !== null,
num = time.replace(/[^0-9]/g, '');
// Parse for hour and minute
switch(num.length) {
case 4:
hour = parseInt(num[0] + num[1], 10);
minute = parseInt(num[2] + num[3], 10);
break;
case 3:
hour = parseInt(num[0], 10);
minute = parseInt(num[1] + num[2], 10);
break;
case 2:
case 1:
hour = parseInt(num[0] + (num[1] || ''), 10);
minute = 0;
break;
default:
return '';
}
// Make sure hour is in 24 hour format
if( pm === true && hour > 0 && hour < 12 ) hour += 12;
// Force pm for hours between 13:00 and 23:00
if( hour >= 13 && hour <= 23 ) pm = true;
// Handle step
if( step ) {
// Step to the nearest hour requires 60, not 0
if( step === 0 ) step = 60;
// Round to nearest step
stepMinute = (Math.round(minute / step) * step) % 60;
// Do we need to round the hour up?
if( stepMinute === 0 && minute >= 30 ) {
hour++;
// Do we need to switch am/pm?
if( hour === 12 || hour === 24 ) pm = !pm;
}
minute = stepMinute;
}
// Keep within range
if( hour <= 0 || hour >= 24 ) hour = 0;
if( minute < 0 || minute > 59 ) minute = 0;
// Format output
return (format || defaultFormat)
// 12 hour without leading 0
.replace(/g/g, hour === 0 ? '12' : 'g')
.replace(/g/g, hour > 12 ? hour - 12 : hour)
// 24 hour without leading 0
.replace(/G/g, hour)
// 12 hour with leading 0
.replace(/h/g, hour.toString().length > 1 ? (hour > 12 ? hour - 12 : hour) : '0' + (hour > 12 ? hour - 12 : hour))
// 24 hour with leading 0
.replace(/H/g, hour.toString().length > 1 ? hour : '0' + hour)
// minutes with leading zero
.replace(/i/g, minute.toString().length > 1 ? minute : '0' + minute)
// simulate seconds
.replace(/s/g, '00')
// lowercase am/pm
.replace(/a/g, pm ? 'pm' : 'am')
// lowercase am/pm
.replace(/A/g, pm ? 'PM' : 'AM');
}
var tests = [
'1:00 pm','1:00 p.m.','1:00 p','1:00pm','1:00p.m.','1:00p','1 pm',
'1 p.m.','1 p','1pm','1p.m.', '1p', '13:00','13', '1a', '12', '12a', '12p', '12am', '12pm', '2400am', '2400pm', '2400',
'1000', '100', '123', '2459', '2359', '2359am', '1100', '123p',
'1234', '1', '9', '99', '999', '9999', '99999', '0000', '0011', '-1', 'mioaw' ];
for ( var i = 0; i < tests.length; i++ ) {
console.log( tests[i].padStart( 9, ' ' ) + " = " + parseTime(tests[i]) );
}这是对Joe 版本的改进。随意进一步编辑它。
function parseTime(timeString)
{
if (timeString == '') return null;
var d = new Date();
var time = timeString.match(/(\d+)(:(\d\d))?\s*(p?)/i);
d.setHours( parseInt(time[1],10) + ( ( parseInt(time[1],10) < 12 && time[4] ) ? 12 : 0) );
d.setMinutes( parseInt(time[3],10) || 0 );
d.setSeconds(0, 0);
return d;
}
var tests = [
'1:00 pm','1:00 p.m.','1:00 p','1:00pm','1:00p.m.','1:00p','1 pm',
'1 p.m.','1 p','1pm','1p.m.', '1p', '13:00','13', '1a', '12', '12a', '12p', '12am', '12pm', '2400am', '2400pm', '2400',
'1000', '100', '123', '2459', '2359', '2359am', '1100', '123p',
'1234', '1', '9', '99', '999', '9999', '99999', '0000', '0011', '-1', 'mioaw' ];
for ( var i = 0; i < tests.length; i++ ) {
console.log( tests[i].padStart( 9, ' ' ) + " = " + parseTime(tests[i]) );
}变化：
在实施 John Resig 的解决方案时，我遇到了一些问题。这是我根据他的回答一直在使用的修改后的功能：
function parseTime(timeString)
{
if (timeString == '') return null;
var d = new Date();
var time = timeString.match(/(\d+)(:(\d\d))?\s*(p?)/);
d.setHours( parseInt(time[1]) + ( ( parseInt(time[1]) < 12 && time[4] ) ? 12 : 0) );
d.setMinutes( parseInt(time[3]) || 0 );
d.setSeconds(0, 0);
return d;
} // parseTime()
var tests = [
'1:00 pm','1:00 p.m.','1:00 p','1:00pm','1:00p.m.','1:00p','1 pm',
'1 p.m.','1 p','1pm','1p.m.', '1p', '13:00','13', '1a', '12', '12a', '12p', '12am', '12pm', '2400am', '2400pm', '2400',
'1000', '100', '123', '2459', '2359', '2359am', '1100', '123p',
'1234', '1', '9', '99', '999', '9999', '99999', '0000', '0011', '-1', 'mioaw' ];
for ( var i = 0; i < tests.length; i++ ) {
console.log( tests[i].padStart( 9, ' ' ) + " = " + parseTime(tests[i]) );
}对于所有使用支持的 24 小时时钟的人来说，这里有一个解决方案：
function parseTime(text) {
var time = text.match(/(\d?\d):?(\d?\d?)/);
var h = parseInt(time[1], 10);
var m = parseInt(time[2], 10) || 0;
if (h > 24) {
// try a different format
time = text.match(/(\d)(\d?\d?)/);
h = parseInt(time[1], 10);
m = parseInt(time[2], 10) || 0;
}
var d = new Date();
d.setHours(h);
d.setMinutes(m);
return d;
}
var tests = [
'1:00 pm','1:00 p.m.','1:00 p','1:00pm','1:00p.m.','1:00p','1 pm',
'1 p.m.','1 p','1pm','1p.m.', '1p', '13:00','13', '1a', '12', '12a', '12p', '12am', '12pm', '2400am', '2400pm', '2400',
'1000', '100', '123', '2459', '2359', '2359am', '1100', '123p',
'1234', '1', '9', '99', '999', '9999', '99999', '0000', '0011', '-1', 'mioaw' ];
for ( var i = 0; i < tests.length; i++ ) {
console.log( tests[i].padStart( 9, ' ' ) + " = " + parseTime(tests[i]) );
}这是一种更可靠的方法，它考虑了用户打算如何使用这种类型的输入。例如，如果用户输入“12”，他们会认为是中午 12 点（中午），而不是上午 12 点。下面的函数处理所有这些。它也可以在这里找到：http ://blog.de-zwart.net/2010-02/javascript-parse-time/
/**
* Parse a string that looks like time and return a date object.
* @return Date object on success, false on error.
*/
String.prototype.parseTime = function() {
// trim it and reverse it so that the minutes will always be greedy first:
var value = this.trim().reverse();
// We need to reverse the string to match the minutes in greedy first, then hours
var timeParts = value.match(/(a|p)?\s*((\d{2})?:?)(\d{1,2})/i);
// This didnt match something we know
if (!timeParts) {
return false;
}
// reverse it:
timeParts = timeParts.reverse();
// Reverse the internal parts:
for( var i = 0; i < timeParts.length; i++ ) {
timeParts[i] = timeParts[i] === undefined ? '' : timeParts[i].reverse();
}
// Parse out the sections:
var minutes = parseInt(timeParts[1], 10) || 0;
var hours = parseInt(timeParts[0], 10);
var afternoon = timeParts[3].toLowerCase() == 'p' ? true : false;
// If meridian not set, and hours is 12, then assume afternoon.
afternoon = !timeParts[3] && hours == 12 ? true : afternoon;
// Anytime the hours are greater than 12, they mean afternoon
afternoon = hours > 12 ? true : afternoon;
// Make hours be between 0 and 12:
hours -= hours > 12 ? 12 : 0;
// Add 12 if its PM but not noon
hours += afternoon && hours != 12 ? 12 : 0;
// Remove 12 for midnight:
hours -= !afternoon && hours == 12 ? 12 : 0;
// Check number sanity:
if( minutes >= 60 || hours >= 24 ) {
return false;
}
// Return a date object with these values set.
var d = new Date();
d.setHours(hours);
d.setMinutes(minutes);
return d;
}
var tests = [
'1:00 pm','1:00 p.m.','1:00 p','1:00pm','1:00p.m.','1:00p','1 pm',
'1 p.m.','1 p','1pm','1p.m.', '1p', '13:00','13', '1a', '12', '12a', '12p', '12am', '12pm', '2400am', '2400pm', '2400',
'1000', '100', '123', '2459', '2359', '2359am', '1100', '123p',
'1234', '1', '9', '99', '999', '9999', '99999', '0000', '0011', '-1', 'mioaw' ];
for ( var i = 0; i < tests.length; i++ ) {
console.log( tests[i].padStart( 9, ' ' ) + " = " + tests[i].parseTime() );
}这是一个字符串原型，所以你可以像这样使用它：
var str = '12am';
var date = str.parseTime();
时间包大小为 0.9kbs 。可与 NPM 和 bower 包管理器一起使用。
这是一个直接来自的示例README.md：
var t = Time('2p');
t.hours(); // 2
t.minutes(); // 0
t.period(); // 'pm'
t.toString(); // '2:00 pm'
t.nextDate(); // Sep 10 2:00 (assuming it is 1 o'clock Sep 10)
t.format('hh:mm AM') // '02:00 PM'
t.isValid(); // true
Time.isValid('99:12'); // false
其他答案汇编表
首先，我不敢相信没有内置功能，甚至没有强大的第三方库可以处理这个问题。实际上，这是网络开发，所以我可以相信。
试图用所有这些不同的算法测试所有边缘情况让我头晕目眩，所以我冒昧地将这个线程中的所有答案和测试编译到一个方便的表格中。
代码（和结果表）对于包含内联来说毫无意义，所以我制作了一个 JSFiddle：
http://jsfiddle.net/jLv16ydb/4/show
// heres some filler code of the functions I included in the test,
// because StackOverfleaux wont let me have a jsfiddle link without code
Functions = [
JohnResig,
Qwertie,
PatrickMcElhaney,
Brad,
NathanVillaescusa,
DaveJarvis,
AndrewCetinic,
StefanHaberl,
PieterDeZwart,
JoeLencioni,
Claviska,
RobG,
DateJS,
MomentJS
];
// I didn't include `date-fns`, because it seems to have even more
// limited parsing than MomentJS or DateJS
请随时 fork 我的小提琴并添加更多算法和测试用例
我没有在结果和“预期”输出之间添加任何比较，因为在某些情况下“预期”输出可能会引起争论（例如，应该12解释为12:00am或12:00pm？）。您将不得不浏览表格，看看哪种算法对您最有意义。
注意：颜色不一定表示输出的质量或“预期”，它们仅表示输出的类型：
red= js 错误抛出
yellow=“假”值（undefined, null, NaN, "", "invalid date"）
green= jsDate()对象
light green=其他一切
如果Date()对象是输出，我将其转换为 24 小时HH:mm格式以便于比较。
AnyTime.Converter 可以解析多种不同格式的日期/时间：
我对上面的函数做了一些修改，以支持更多的格式。
还没有清理它，但适用于我能想到的一切。
function parseTime(timeString) {
if (timeString == '') return null;
var time = timeString.match(/^(\d+)([:\.](\d\d))?\s*((a|(p))m?)?$/i);
if (time == null) return null;
var m = parseInt(time[3], 10) || 0;
var hours = parseInt(time[1], 10);
if (time[4]) time[4] = time[4].toLowerCase();
// 12 hour time
if (hours == 12 && !time[4]) {
hours = 12;
}
else if (hours == 12 && (time[4] == "am" || time[4] == "a")) {
hours += 12;
}
else if (hours < 12 && (time[4] != "am" && time[4] != "a")) {
hours += 12;
}
// 24 hour time
else if(hours > 24 && hours.toString().length >= 3) {
if(hours.toString().length == 3) {
m = parseInt(hours.toString().substring(1,3), 10);
hours = parseInt(hours.toString().charAt(0), 10);
}
else if(hours.toString().length == 4) {
m = parseInt(hours.toString().substring(2,4), 10);
hours = parseInt(hours.toString().substring(0,2), 10);
}
}
var d = new Date();
d.setHours(hours);
d.setMinutes(m);
d.setSeconds(0, 0);
return d;
}
var tests = [
'1:00 pm','1:00 p.m.','1:00 p','1:00pm','1:00p.m.','1:00p','1 pm',
'1 p.m.','1 p','1pm','1p.m.', '1p', '13:00','13', '1a', '12', '12a', '12p', '12am', '12pm', '2400am', '2400pm', '2400',
'1000', '100', '123', '2459', '2359', '2359am', '1100', '123p',
'1234', '1', '9', '99', '999', '9999', '99999', '0000', '0011', '-1', 'mioaw' ];
for ( var i = 0; i < tests.length; i++ ) {
console.log( tests[i].padStart( 9, ' ' ) + " = " + parseTime(tests[i]) );
}很多答案，所以一个不会伤害。
/**
* Parse a time in nearly any format
* @param {string} time - Anything like 1 p, 13, 1:05 p.m., etc.
* @returns {Date} - Date object for the current date and time set to parsed time
*/
function parseTime(time) {
var b = time.match(/\d+/g);
// return undefined if no matches
if (!b) return;
var d = new Date();
d.setHours(b[0]>12? b[0] : b[0]%12 + (/p/i.test(time)? 12 : 0), // hours
/\d/.test(b[1])? b[1] : 0, // minutes
/\d/.test(b[2])? b[2] : 0); // seconds
return d;
}
var tests = [
'1:00 pm','1:00 p.m.','1:00 p','1:00pm','1:00p.m.','1:00p','1 pm',
'1 p.m.','1 p','1pm','1p.m.', '1p', '13:00','13', '1a', '12', '2400',
'1000', '100', '123', '2459', '2359', '2359am', '1100', '123p',
'1234', '1', '9', '99', '999', '9999', '99999', '0000', '0011', '-1', 'mioaw' ];
for ( var i = 0; i < tests.length; i++ ) {
console.log( tests[i].padStart( 9, ' ' ) + " = " + parseTime(tests[i]) );
}为了适当地健壮，它应该检查每个值是否在允许值的范围内，例如，如果上午/下午时间必须是 1 到 12（含），否则是 0 到 24（含）等。
这是另一种方法，涵盖了原始答案、任何合理的数字、猫的数据输入和逻辑谬误。算法如下：
将小时、分钟和 post meridiem 转换为 Date 对象是读者的练习（许多其他答案显示了如何执行此操作）。
"use strict";
String.prototype.toTime = function () {
var time = this;
var post_meridiem = false;
var ante_meridiem = false;
var hours = 0;
var minutes = 0;
if( time != null ) {
post_meridiem = time.match( /p/i ) !== null;
ante_meridiem = time.match( /a/i ) !== null;
// Preserve 2400h time by changing leading zeros to 24.
time = time.replace( /^00/, '24' );
// Strip the string down to digits and convert to a number.
time = parseInt( time.replace( /\D/g, '' ) );
}
else {
time = 0;
}
if( time > 0 && time < 24 ) {
// 1 through 23 become hours, no minutes.
hours = time;
}
else if( time >= 100 && time <= 2359 ) {
// 100 through 2359 become hours and two-digit minutes.
hours = ~~(time / 100);
minutes = time % 100;
}
else if( time >= 2400 ) {
// After 2400, it's midnight again.
minutes = (time % 100);
post_meridiem = false;
}
if( hours == 12 && ante_meridiem === false ) {
post_meridiem = true;
}
if( hours > 12 ) {
post_meridiem = true;
hours -= 12;
}
if( minutes > 59 ) {
minutes = 59;
}
var result =
(""+hours).padStart( 2, "0" ) + ":" + (""+minutes).padStart( 2, "0" ) +
(post_meridiem ? "PM" : "AM");
return result;
};
var tests = [
'1:00 pm','1:00 p.m.','1:00 p','1:00pm','1:00p.m.','1:00p','1 pm',
'1 p.m.','1 p','1pm','1p.m.', '1p', '13:00','13', '1a', '12', '12a', '12p', '12am', '12pm', '2400am', '2400pm', '2400',
'1000', '100', '123', '2459', '2359', '2359am', '1100', '123p',
'1234', '1', '9', '99', '999', '9999', '99999', '0000', '0011', '-1', 'mioaw' ];
for ( var i = 0; i < tests.length; i++ ) {
console.log( tests[i].padStart( 9, ' ' ) + " = " + tests[i].toTime() );
}使用 jQuery，新定义的 String 原型使用如下：
<input type="text" class="time" />
$(".time").change( function() {
var $this = $(this);
$(this).val( time.toTime() );
});
我对其他答案不满意，所以我又做了一个。这个版本：
undefined无效输入，例如“13:00pm”或“11:65”localDate参数，则返回本地时间，否则返回 Unix 纪元（1970 年 1 月 1 日）的 UTC 时间。1330（要禁用，请在正则表达式中设置第一个'：'）^\s*在正则表达式中删除）编辑：它现在是一个包含格式化程序的包：timeToStringnpm i simplertime
/**
* Parses a string into a Date. Supports several formats: "12", "1234",
* "12:34", "12:34pm", "12:34 PM", "12:34:56 pm", and "12:34:56.789".
* The time must be at the beginning of the string but can have leading spaces.
* Anything is allowed after the time as long as the time itself appears to
* be valid, e.g. "12:34*Z" is OK but "12345" is not.
* @param {string} t Time string, e.g. "1435" or "2:35 PM" or "14:35:00.0"
* @param {Date|undefined} localDate If this parameter is provided, setHours
* is called on it. Otherwise, setUTCHours is called on 1970/1/1.
* @returns {Date|undefined} The parsed date, if parsing succeeded.
*/
function parseTime(t, localDate) {
// ?: means non-capturing group and ?! is zero-width negative lookahead
var time = t.match(/^\s*(\d\d?)(?::?(\d\d))?(?::(\d\d))?(?!\d)(\.\d+)?\s*(pm?|am?)?/i);
if (time) {
var hour = parseInt(time[1]), pm = (time[5] || ' ')[0].toUpperCase();
var min = time[2] ? parseInt(time[2]) : 0;
var sec = time[3] ? parseInt(time[3]) : 0;
var ms = (time[4] ? parseFloat(time[4]) * 1000 : 0);
if (pm !== ' ' && (hour == 0 || hour > 12) || hour > 24 || min >= 60 || sec >= 60)
return undefined;
if (pm === 'A' && hour === 12) hour = 0;
if (pm === 'P' && hour !== 12) hour += 12;
if (hour === 24) hour = 0;
var date = new Date(localDate!==undefined ? localDate.valueOf() : 0);
var set = (localDate!==undefined ? date.setHours : date.setUTCHours);
set.call(date, hour, min, sec, ms);
return date;
}
return undefined;
}
var testSuite = {
'1300': ['1:00 pm','1:00 P.M.','1:00 p','1:00pm','1:00p.m.','1:00p','1 pm',
'1 p.m.','1 p','1pm','1p.m.', '1p', '13:00','13', '1:00:00PM', '1300', '13'],
'1100': ['11:00am', '11:00 AM', '11:00', '11:00:00', '1100'],
'1359': ['1:59 PM', '13:59', '13:59:00', '1359', '1359:00', '0159pm'],
'100': ['1:00am', '1:00 am', '0100', '1', '1a', '1 am'],
'0': ['00:00', '24:00', '12:00am', '12am', '12:00:00 AM', '0000', '1200 AM'],
'30': ['0:30', '00:30', '24:30', '00:30:00', '12:30:00 am', '0030', '1230am'],
'1435': ["2:35 PM", "14:35:00.0", "1435"],
'715.5': ["7:15:30", "7:15:30am"],
'109': ['109'], // Three-digit numbers work (I wasn't sure if they would)
'': ['12:60', '11:59:99', '-12:00', 'foo', '0660', '12345', '25:00'],
};
var passed = 0;
for (var key in testSuite) {
let num = parseFloat(key), h = num / 100 | 0;
let m = num % 100 | 0, s = (num % 1) * 60;
let expected = Date.UTC(1970, 0, 1, h, m, s); // Month is zero-based
let strings = testSuite[key];
for (let i = 0; i < strings.length; i++) {
var result = parseTime(strings[i]);
if (result === undefined ? key !== '' : key === '' || expected !== result.valueOf()) {
console.log(`Test failed at ${key}:"${strings[i]}" with result ${result ? result.toUTCString() : 'undefined'}`);
} else {
passed++;
}
}
}
console.log(passed + ' tests passed.');
为什么不使用验证来缩小用户可以输入的范围并简化列表以仅包含可以解析（或经过一些调整后解析）的格式。
我认为要求用户以受支持的格式投入时间并不过分。
dd:dd A(m)/P(m)
dd A(米)/P(米)
dd
/(\d+)(?::(\d\d))(?::(\d\d))?\s*([pP]?)/
// added test for p or P
// added seconds
d.setHours( parseInt(time[1]) + (time[4] ? 12 : 0) ); // care with new indexes
d.setMinutes( parseInt(time[2]) || 0 );
d.setSeconds( parseInt(time[3]) || 0 );
谢谢
Patrick McElhaney 的解决方案的改进（他没有正确处理上午 12 点）
function parseTime( timeString ) {
var d = new Date();
var time = timeString.match(/(\d+)(:(\d\d))?\s*([pP]?)/i);
var h = parseInt(time[1], 10);
if (time[4])
{
if (h < 12)
h += 12;
}
else if (h == 12)
h = 0;
d.setHours(h);
d.setMinutes(parseInt(time[3], 10) || 0);
d.setSeconds(0, 0);
return d;
}
var tests = [
'1:00 pm','1:00 p.m.','1:00 p','1:00pm','1:00p.m.','1:00p','1 pm',
'1 p.m.','1 p','1pm','1p.m.', '1p', '13:00','13', '1a', '12', '2400',
'1000', '100', '123', '2459', '2359', '2359am', '1100', '123p',
'1234', '1', '9', '99', '999', '9999', '99999', '0000', '0011', '-1', 'mioaw' ];
for ( var i = 0; i < tests.length; i++ ) {
console.log( tests[i].padStart( 9, ' ' ) + " = " + parseTime(tests[i]) );
}如果你只想要几秒钟这里是一个班轮
const toSeconds = s => s.split(':').map(v => parseInt(v)).reverse().reduce((acc,e,i) => acc + e * Math.pow(60,i))
在通过我的其他编译答案进行彻底测试和调查后，我得出结论，@Dave Jarvis 的解决方案最接近我认为的合理输出和边缘情况处理。作为参考，我查看了退出文本框后谷歌日历的时间输入将时间重新格式化为什么。
尽管如此，我还是看到它没有处理谷歌日历所做的一些（尽管很奇怪）边缘情况。所以我从头开始重新设计它，这就是我想出的。我还将它添加到我的编译答案中。
// attempt to parse string as time. return js date object
function parseTime(string) {
string = String(string);
var am = null;
// check if "apm" or "pm" explicitly specified, otherwise null
if (string.toLowerCase().includes("p")) am = false;
else if (string.toLowerCase().includes("a")) am = true;
string = string.replace(/\D/g, ""); // remove non-digit characters
string = string.substring(0, 4); // take only first 4 digits
if (string.length === 3) string = "0" + string; // consider eg "030" as "0030"
string = string.replace(/^00/, "24"); // add 24 hours to preserve eg "0012" as "00:12" instead of "12:00", since will be converted to integer
var time = parseInt(string); // convert to integer
// default time if all else fails
var hours = 12,
minutes = 0;
// if able to parse as int
if (Number.isInteger(time)) {
// treat eg "4" as "4:00pm" (or "4:00am" if "am" explicitly specified)
if (time >= 0 && time <= 12) {
hours = time;
minutes = 0;
// if "am" or "pm" not specified, establish from number
if (am === null) {
if (hours >= 1 && hours <= 12) am = false;
else am = true;
}
}
// treat eg "20" as "8:00pm"
else if (time >= 13 && time <= 99) {
hours = time % 24;
minutes = 0;
// if "am" or "pm" not specified, force "am"
if (am === null) am = true;
}
// treat eg "52:95" as 52 hours 95 minutes
else if (time >= 100) {
hours = Math.floor(time / 100); // take first two digits as hour
minutes = time % 100; // take last two digits as minute
// if "am" or "pm" not specified, establish from number
if (am === null) {
if (hours >= 1 && hours <= 12) am = false;
else am = true;
}
}
// add 12 hours if "pm"
if (am === false && hours !== 12) hours += 12;
// sub 12 hours if "12:00am" (midnight), making "00:00"
if (am === true && hours === 12) hours = 0;
// keep hours within 24 and minutes within 60
// eg 52 hours 95 minutes becomes 4 hours 35 minutes
hours = hours % 24;
minutes = minutes % 60;
}
// convert to js date object
var date = new Date();
date.setHours(hours);
date.setMinutes(minutes);
date.setSeconds(0);
return date;
}
var tests = [
'1:00 pm','1:00 p.m.','1:00 p','1:00pm','1:00p.m.','1:00p','1 pm',
'1 p.m.','1 p','1pm','1p.m.', '1p', '13:00','13', '1a', '12', '12a', '12p', '12am', '12pm', '2400am', '2400pm', '2400',
'1000', '100', '123', '2459', '2359', '2359am', '1100', '123p',
'1234', '1', '9', '99', '999', '9999', '99999', '0000', '0011', '-1', 'mioaw' ];
for ( var i = 0; i < tests.length; i++ ) {
console.log( tests[i].padStart( 9, ' ' ) + " = " + parseTime(tests[i]) );
}我觉得这是我能满足我需求的最接近的方法，但欢迎提出建议。注意：这是以美国为中心的，因为它对于某些模式默认为 am/pm：
1=> 13:00( 1:00pm)1100=> 23:00( 11:00pm)456=> 16:56( 4:56pm)我需要一个时间解析器功能，并且根据一些答案，我最终得到了这个功能
function parse(time){
let post_meridiem = time.match(/p/i) !== null;
let result;
time = time.replace(/[^\d:-]/g, '');
let hours = 0;
let minutes = 0;
if (!time) return;
let parts = time.split(':');
if (parts.length > 2) time = parts[0] + ':' + parts[1];
if (parts[0] > 59 && parts.length === 2) time = parts[0];
if (!parts[0] && parts[1] < 60) minutes = parts[1];
else if (!parts[0] && parts[1] >= 60) return;
time = time.replace(/^00/, '24');
time = parseInt(time.replace(/\D/g, ''));
if (time >= 2500) return;
if (time > 0 && time < 24 && parts.length === 1) hours = time;
else if (time < 59) minutes = time;
else if (time >= 60 && time <= 99 && parts[0]) {
hours = ('' + time)[0];
minutes = ('' + time)[1];
} else if (time >= 100 && time <= 2359) {
hours = ~~(time / 100);
minutes = time % 100;
} else if (time >= 2400) {
hours = ~~(time / 100) - 24;
minutes = time % 100;
post_meridiem = false;
}
if (hours > 59 || minutes > 59) return;
if (post_meridiem && hours !== 0) hours += 12;
if (minutes > 59) minutes = 59;
if (hours > 23) hours = 0;
result = ('' + hours).padStart(2, '0') + ':' + ('' + minutes).padStart(2, '0');
return result;
}
var tests = [
'1:00 pm','1:00 p.m.','1:00 p','1:00pm','1:00p.m.','1:00p','1 pm',
'1 p.m.','1 p','1pm','1p.m.', '1p', '13:00','13', '1a', '12', '12a', '12p', '12am', '12pm', '2400am', '2400pm', '2400',
'1000', '100', '123', '2459', '2359', '2359am', '1100', '123p',
'1234', '1', '9', '99', '999', '9999', '0000', '0011', '-1', 'mioaw',
"0820",
"32",
"124",
"1330",
"130pm",
"456",
":40",
":90",
"12:69",
"50:90",
"aaa12:34aaa",
"aaa50:00aaa",
];
for ( var i = 0; i < tests.length; i++ ) {
console.log( tests[i].padStart( 9, ' ' ) + " = " + parse(tests[i]) );
}主要投票和选择的答案给我带来了麻烦并输出了荒谬的结果。下面是我的尝试，它似乎解决了大多数人遇到的所有问题，包括我的。我的一个附加功能是能够将“am”或“pm”指定为一天中的时间，以默认用户输入未指定（例如 1:00）。默认情况下，它设置为“pm”。
需要注意的一点是，此函数假定用户想要（并试图）提供一个表示时间输入的字符串。正因为如此，“输入验证和清理”只能排除任何会导致错误的东西，而不是任何看起来不一定像时间的东西。这最好由代码片段底部的数组中的最后三个测试条目来表示。
const parseTime = (timeString, assumedTimeOfDay = "pm") => {
// Validate timeString input
if (!timeString) return null
const regex = /(\d{1,2})(\d{2})?([a|p]m?)?/
const noOfDigits = timeString.replace(/[^\d]/g, "").length
if (noOfDigits === 0) return null
// Seconds are unsupported (rare use case in my eyes, feel free to edit)
if (noOfDigits > 4) return null
// Add a leading 0 to prevent bad regex match (i.e. 100 = 1hr 00min, not 10hr 0min)
const sanitized = `${noOfDigits === 3 ? "0" : ""}${timeString}`
.toLowerCase()
.replace(/[^\dapm]/g, "")
const parsed = sanitized.match(regex)
if (!parsed) return null
// Clean up and name parsed data
const {
input,
hours,
minutes,
meridian
} = {
input: parsed[0],
hours: Number(parsed[1] || 0),
minutes: Number(parsed[2] || 0),
// Defaults to pm if user provided assumedTimeOfDay is not am or pm
meridian: /am/.test(`${parsed[3] || assumedTimeOfDay.toLowerCase()}m`) ?
"am" : "pm",
}
// Quick check for valid numbers
if (hours < 0 || hours >= 24 || minutes < 0 || minutes >= 60) return null
// Convert hours to 24hr format
const timeOfDay = hours >= 13 ? "pm" : meridian
const newHours =
hours >= 13 ?
hours :
hours === 12 && timeOfDay === "am" ?
0 :
(hours === 12 && timeOfDay === "pm") || timeOfDay === "am" ?
hours :
hours + 12
// Convert data to Date object and return
return new Date(new Date().setHours(newHours, minutes, 0))
}
const times = [
'12',
'12p',
'12pm',
'12p.m.',
'12 p',
'12 pm',
'12 p.m.',
'12:00',
'12:00p',
'12:00pm',
'12:00p.m.',
'12:00 p',
'12:00 pm',
'12:00 p.m.',
'12:00',
'12:00p',
'12:00pm',
'12:00p.m.',
'12:00 p',
'12:00 pm',
'12:00 p.m.',
'1200',
'1200p',
'1200pm',
'1200p.m.',
'1200 p',
'1200 pm',
'1200 p.m.',
'12',
'1200',
'12:00',
'1',
'1p',
'1pm',
'1p.m.',
'1 p',
'1 pm',
'1 p.m.',
'1:00',
'1:00p',
'1:00pm',
'1:00p.m.',
'1:00 p',
'1:00 pm',
'1:00 p.m.',
'01:00',
'01:00p',
'01:00pm',
'01:00p.m.',
'01:00 p',
'01:00 pm',
'01:00 p.m.',
'0100',
'0100p',
'0100pm',
'0100p.m.',
'0100 p',
'0100 pm',
'0100 p.m.',
'13',
'1300',
'13:00',
'random',
'092fsd9)*(U243',
'092fsd9)*(U'
]
times.map(t => {
const parsed = parseTime(t)
if (parsed) {
console.log(`${parsed.toLocaleTimeString()} from ${t}`)
} else {
console.log(`Invalid Time (${t})`)
}
})Although I've tested this quite a bit, I'm sure I tunnel-visioned on something. If someone is able to break it (in a reasonable way), please comment and I'll see about updating!