Quelle est la meilleure façon d'analyser une fois en Date objet de la saisie de l'utilisateur en Javascript?

Tous les exemples fournis ne fonctionnent fois à partir de 12:00 à 12:59 am. Ils ont également lever une erreur si la regex ne correspond pas à un temps. Le suivant traite de ce:

JS:

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

Cela fonctionne pour des chaînes qui contiennent une fois n'importe où à l'intérieur d'eux. Donc "abcde12:00pmdef" serait analysé et retour à 12h. Si le résultat souhaité est qu'il retourne uniquement un moment où la chaîne ne contient qu'un temps l'expression régulière suivante peut être utilisée à condition de remplacer "le temps[4]" avec "le temps[6]".

/^(\d+)(:(\d\d))?\s*((a|(p))m?)?$/i

La plupart des regex solutions ici de générer des erreurs lors de la chaîne ne peut pas être analysé, et pas beaucoup d'entre eux représentent des chaînes de caractères comme 1330 ou 130pm. Même si ces formats n'étaient pas spécifiés par l'OP, je trouve critiques pour l'analyse des dates d'entrée par l'homme.

Tout cela m'a fait penser que l'utilisation d'une expression régulière peut ne pas être la meilleure approche pour ce.

Ma solution est une fonction qui non seulement traite le moment, mais vous permet également de spécifier le format de sortie et une étape (intervalle) à qui à tour de minutes. À environ 70 lignes, c'est toujours léger et analyse tout ce qui précède, ainsi que les formats sans les deux-points.

• Démo: http://jsfiddle.net/HwwzS/1/
• Code: https://gist.github.com/claviska/4744736

JS:

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

Je suis tombé sur un couple de petits défauts dans la mise en œuvre de John Resig de la solution. Voici la modification de la fonction que j'ai été en utilisant basé sur sa réponse:

JS:

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

La le temps paquet est de 0,9 kbs en taille. Disponible avec NPM et bower les gestionnaires de paquets.

Voici un exemple directement à partir de la 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

Voici une solution de plus pour tous ceux qui sont à l'aide d'un 24 heures, qui soutient:

• 0820 -> 08:20
• 32 -> 03:02
• 124 -> 12:04

JS:

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

Voici une autre approche qui couvre l'original de la réplique, dans la mesure du raisonnable nombre de chiffres, de données d'entrée par les chats, et les erreurs logiques. L'algorithme suit:

1. Déterminer si méridien est post meridiem.
2. Convertir les données d'entrée de chiffres à une valeur entière.
3. Temps entre 0 et 24: l'heure est aux heures, pas de minutes (heures 12 PM).
4. Temps entre 100 et 2359: heures div 100 heures, minutes mod 100 reste.
5. Temps de 2400 sur: heures à minuit, avec le procès-verbal reste.
6. Quand la durée est supérieure à 12, soustraire 12 et de la force de post meridiem vrai.
7. Lorsque le procès-verbal dépasse 59, à force de 59.

De conversion les heures, les minutes, et post meridiem à un objet Date est un exercice pour le lecteur (de nombreuses autres réponses montrer comment faire cela).

JS:

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

Avec jQuery, la nouvelle définition de la Chaîne de prototype est utilisé comme suit:

  <input type="text" class="time" />

  $(".time").change( function() {
var $this = $(this);
$(this).val( time.toTime() );
});

/(\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 );

grâce

Une amélioration de Patrick McElhaney la solution de (sa ne gère pas les 12h correctement)

JS:

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

Si vous ne voulez secondes ici est un liner

const toSeconds = s => s.split(':').map(v => parseInt(v)).reverse().reduce((acc,e,i) => acc + e * Math.pow(60,i))

Après avoir bien tester et d'enquêter à travers mon autre compilation de réponse, j'en ai conclu que @Dave Jarvis la solution la plus proche de ce que je ressentais étaient raisonnables, les sorties et edge-le traitement des affaires. Pour référence, j'ai regardé ce que Google Calendrier de temps, les entrées reformaté le temps de après la sortie de la zone de texte.

Même encore, j'ai vu qu'il n'a pas à traiter certains (quoique bizarre) bord de cas que Google Agenda fait. J'ai donc retravaillé à partir du sol en place et c'est ce que je suis venu avec. J'ai aussi ajouté ça à ma compilation répondre.

//attempt to parse string as time. return js date object
static 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;
}

J'ai l'impression que c'est le plus proche que je peux obtenir pour mes besoins, mais les suggestions sont les bienvenues. Remarque: C'est à l'Américaine centrée sur que c'est par défaut am/pm pour certains modèles:

• 1 => 13:00 (1:00pm)
• 1100 => 23:00 (11:00pm)
• 456 => 16:56 (4:56pm)