Sistema de tipo JavaScript: una comprensión integral de los objetos de fecha de fecha

Las palabras anteriores

El objeto Date es un tipo de datos incorporado en el idioma JavaScript y se utiliza para proporcionar una interfaz de operación para fechas y tiempos. El objeto de fecha se crea en función de la clase java.util.date en Java temprano. Por esta razón, el tipo de fecha utiliza milisegundos transcurridos a partir de las 0:00 el 1 de enero de 1970 para guardar la fecha. El rango de tiempo que puede representar es de 100 millones de días cada uno alrededor de las 0:00 del 1 de enero de 1970. Este artículo introducirá el uso de objetos de fecha en detalle

Métodos estáticos Antes de introducir el constructor del objeto Date, primero introduciremos los métodos estáticos. Porque el método estático del objeto de fecha está estrechamente relacionado con su constructor. El proceso de crear un objeto de fecha utilizando un constructor es similar al proceso de usar un método estático que usa una capa

Hay tres métodos estáticos en el objeto de fecha, a saber, date.now (), date.Parse () y date.utc (). Estos métodos se llaman a través del constructor de fecha (), en lugar de a través del objeto de instancia de fecha

Date.now ()

ECMAScript5 ha agregado el método Now (), que devuelve el número de milisegundos desde la hora actual a las 0:00 UTC el 1 de enero de 1970. Este método no admite los parámetros de aprobación

[Nota] Este método devuelve el número numérico

 console.log (date.now ()); // 1468297046050console.log (date.now ('2016,1,1')); // 1468297046050console.log (typeof date.now ()); // 'número'

En los navegadores que no admiten el método date.now (), puede usar el operador + para convertir el objeto de fecha en un número, y se pueden lograr efectos similares.

 console.log (nueva fecha ()); // martes 12 de julio de 2016 12:21:33 GMT+0800 (China Standard Time) Console.log (+nueva fecha ()); // 1468297293433console.log (+nueva fecha (2000,1,1)); // 949334400000000

Este método a menudo se usa para analizar el código.

 var start = date.now (); dosomethething (); var stop = date.Now (); resultado = stop - start;

Date.Parse ()

Este método se utiliza para analizar una cadena de fecha. El parámetro es una cadena que contiene la fecha y la hora a analizar, devolviendo el número de milisegundos a partir de las 0:00 el 1 de enero de 1970 a la fecha dada

Este método analiza el formato de la cadena de acuerdo con las reglas de formato de cadena de fecha y hora . Además del formato estándar, los siguientes formatos también son compatibles. Si no se reconoce la cadena, NAN se devolverá

1. 'Mes/día/año', como 13/06/2004

2. 'Mes, día, año' como el 12 de enero de 2004 o el 12 de enero de 2004

3. 'Semana, mes, día, año, hora: minuto, segunda zona horaria' martes 25 de mayo de 2004 00:00:00 GMT-0700

[Nota] El navegador no admite formatos de cadena que no representan fechas sino solo tiempo.

 console.log (date.parse ('6/13/2004')); // 10870560000000000000000000050500000500000Console (date.Parse ('12 de enero de 2004')); // 1073836800000console.log (date.Parse ('tue 25 de mayo de 2004 00:00:00 Gmt-0700 ')); // 1085468400000console.log (date.parse (' 2004-05-25T00: 00: 00 ')); // 1085443200000console.log (DAT E.Parse ('2016')); // 1451606400000console.log (date.parse ('t00: 00: 00'))); // nanconsole.log (date.parse ()); // nan

[Nota] En ECMAScript5, si una cadena que usa la regla de formato de cadena de fecha de fecha estándar tiene un prefijo de 0 antes de las matemáticas, se analizará como tiempo UTC, y si el tiempo no tiene prefijo como 0, se analizará como hora local. Otras situaciones generalmente se resuelven a la hora local

 console.log (date.parse ('7/12/2016')); // 1468252800000console.log (date.parse ('2016-7-7-12')); // 1468252800000console.log (date.parse ('2016-07-12')); // 1468281600000

Date.utc ()

Date.utc () también devuelve el número de milisegundos de una fecha determinada, pero sus parámetros no son una cadena, sino parámetros numéricos que representan año, mes, día, hora, minuto, segundo y milisegundo, respectivamente.

Date.UTC (año, mes, día, horas, minutos, segundos, MS), parámetros de año y mes se fijan, y los parámetros restantes son opcionales. Consulte aquí para obtener detalles sobre las reglas de formato de fecha y hora.

Debido a que la función tiene 7 parámetros formales, su valor de longitud es 7

 console.log (date.utc.length); // 7

[Nota] Este método usa la hora UTC, no la hora local

 console.log (date.utc (1970)); // nanconsole.log (date.utc (1970,0)); // 0console.log (date.utc (1970,0,2)); // 86400000console.log te.Utc (1970,0,1,1)); // 36000000Console.log (date.utc (1970,0,1,1,59)); // 714000console.log (date.utc (1970,0,1,1,59,30)); // 717000

Constructor Date () El constructor tiene hasta 5 formas de usarlo

【0】 fecha ()

Los números se pueden llamar como una función sin el nuevo operador. Ignorará todos los parámetros entrantes y devolverá una representación de cadena de la fecha y hora actuales

 Fecha();

[Nota] Dado que la función date () no usa operadores, no se puede llamar realmente un constructor

 console.log (date ()); // "marzo 12 de julio de 2016 13:38:41 GMT+0800 (Tiempo estándar de China)" Console.log (fecha ('2016/1/1')); // "Tue 12 de julio de 2016 13:38:41 GMT+0800 (China Standard Time)" Console.log (TypeOf Date ()); // 'Striegue' '

【1】 Cuando la función date () usa el nuevo operador y no tiene parámetros, se creará un objeto de fecha en función de la hora y la fecha actuales

 nueva fecha ();

 console.log (nueva fecha ()); // marzo 12 de julio de 2016 13:41:45 GMT+0800 (China Standard Time) Console.log (nueva fecha); // Tue 12 de julio de 2016 13:41:45 GMT+0800 (Tiempo estándar de China) Console.log (tipo de typef Fecha nueva (); // 'Object' '

La función 【2】 date () puede aceptar un parámetro numérico, que representa el número de milisegundos entre el tiempo establecido y las 0 en punto el 1 de enero de 1970

 nueva fecha (milisegundos);

 console.log (nueva fecha (0)); // jer 01 de enero de 1970 08:00:00 GMT+0800 (Tiempo estándar de China) Console.log (nueva fecha (86400000)); // fri enero 02 1970 08:00:00 GMT+0800 (Tiempo estándar de China) Console.log (TypeOf New Date (0));

【3】 La función date () puede aceptar un parámetro de cadena, y el formulario de parámetros es similar al método date.Parse (). Pero el método parse () devuelve un número, mientras que la función date () devuelve un objeto

 nueva fecha (DataString); console.log (nueva fecha ('6/13/2004')); // Sol 13 de junio de 2004 00:00:00 GMT+0800 (China Standard Time) Console.log (date.Parse ('6/13/2004')); // 10870560000000console.log (tipo de Nueva Fecha (6/13/2004)); // ObjectConsole.log (typeof date.parse (6/13/2004)); // número

El procesamiento de 0 prefijo en la cadena de fecha y hora estándar también es similar al método date.parse (). Si hay 0 prefijo, es equivalente al tiempo de UTC, y si no hay no, es equivalente a la hora local. El resto suele ser hora local

 console.log (nueva fecha ('7/12/2016')); // Tue 12 de julio de 2016 00:00:00 GMT+0800 (China Standard Time) Console.log (nueva fecha ('2016-7-7-12')); // Tue 12 de julio de 2016 00:00:00 GMT+0800 (Tiempo estándar de China) Console.log (nueva fecha ('2016-207-12'); 12 de julio de 2016 08:00:00 GMT+0800 (hora estándar de China)

【4】 La función date () puede aceptar parámetros similares a los del método date.utc (), pero el método date.utc () devuelve una serie de milisegundos y es hora de UTC, mientras que la función date () devuelve un objeto y es local local

 console.log (nueva fecha (2016,7,12)); // viernes 12 de agosto de 2016 00:00:00 GMT+0800 (Tiempo estándar de China) Console.log (+nueva fecha (2016,7,12)); // 147093120000000000000000Console.log (tipo de tipo de nuevo Fecha (2016,7,12)); // 'object'console.log (date.utc (2016,7,12)); // 14709600000000Console.log (typeof date.utc (2016,7,12)); //' número '

[Nota] Cuando se usa un método similar a la función date.Parse (), si el objeto de fecha está fuera de rango, el navegador calculará automáticamente la fecha en un valor dentro del rango; Al usar un método similar a la función date.utc (), si el objeto de fecha está fuera de rango, el navegador provocará una fecha no válida

 console.log (nueva fecha (2016,7,32)); // thu 01 de septiembre de 2016 00:00:00 GMT+0800 (China Standard Time) Console.log (nueva fecha (2016,8,1)); // jueves 01 de 2016 00:00:00 GMT+0800 (Tiempo estándar de China) Console.Log (nueva fecha ('2016-8-32'); Dateconsole.log (nueva fecha ('2016-9-1')); // jueves 01 de septiembre de 2016 00:00:00 GMT+0800 (hora estándar de China)

Método de ejemplo

El objeto de fecha no tiene propiedades que se puedan leer y escribir directamente, y todos los accesos a fechas y tiempos deben pasar a través de métodos. La mayoría de los métodos de objetos de fecha se dividen en dos formas: uno es usar la hora local y el otro es usar la hora UTC, que se enumeran a continuación. Por ejemplo, Get [UTC] Day () representa a GetDay () y GetUtcday ()

Hay 46 métodos de instancia en el objeto de fecha, que se pueden dividir en las siguientes 3 categorías: a clase, obtener clase y establecer clase

【A la clase】

El método de clase a la clase devuelve una cadena desde el objeto de fecha, lo que indica el tiempo especificado

toString ()

Devuelve la cadena de fecha de la zona horaria local

toutCstring ()

Devuelve la cadena de fecha de la hora UTC

toisoString ()

Devuelve la cadena de formato de cadena de fecha de fecha del objeto de fecha del objeto de fecha

Totimestring ()

Devuelve la cadena que devuelve la parte de tiempo del objeto de fecha

tojson ()

Devuelve una cadena de fecha que se ajusta al formato JSON, que es exactamente lo mismo que el resultado de retorno del método de toisoString

 console.log (nueva fecha ('2016-7-7-12'). toString ()); // marzo 12 de julio de 2016 00:00:00 GMT+0800 (China Standard Time) Console.log (nueva fecha ('2016-7-12'). ToutCString (); // Mon, 11 Jul 2016 16:00 gmtconsole.log (neweN Fecha ('2016-7-12'). ToisosString ()); // 2016-07-11T16: 00: 00.000zconsole.log (nueva fecha ('2016-7-7-12'). ToDatEdring ()); // tue 12 de julio 2016console.log (nueva fecha ('2016-7-12'). Totimestrring ()); (Tiempo estándar de China) Console.log (nueva fecha ('2016-7-7-12'). TEJSON ()); // 2016-07-11T16: 00: 00.000Z

TOLOCALECRING ()

Conversión localizada del método toString ()

tolocaletimestring ()

Conversión localizada del método TotiMeTring ()

tolocaledateString ()

Conversión localizada del método de TODATETESTRING ()

 console.log (nueva fecha ('2016-7-7-12'). toString ()); // marzo 12 de julio de 2016 00:00:00 GMT+0800 (hora estándar de China) Console.log (nueva fecha ('2016-7-12'). TolocaleString ()); // 2016/7/12 12:00:00 Console.log (Nueva Fecha ('2016-7-12'). TODATESTRING ()); // TUE JUL 2016 2016Console.log (nueva fecha ('2016-7-7-12'). TOLOCALEDETESTRING ()); // 2016/7/12Console.log (New Fecha ('2016-7-7-12'). Totimestrring ()); // 00:00:00 Gmt+0800 (China (2016-7-12 '). Tiempo) console.log (nueva fecha ('2016-7-12'). TOLOCALETIMETRING ()); // 12:00:00 AM

【Obtener clase】

El objeto Date proporciona una serie de métodos de clase GET para obtener el valor de un cierto aspecto del objeto de instancia.

Antes de introducir el método Get Class, primero debemos introducir el método ValueOf ()

valor de ()

Devuelve el número de milisegundos a partir de las 0:00 del 1 de enero de 1970

Por lo tanto, es conveniente usar el operador de comparación para comparar los valores de la fecha

 var fecha1 = nueva fecha (2007,0,1); var date2 = nueva fecha (2007,1,1); console.log (date1> date2); // Falseconsole.log (date1 <date2); // true

GetTime ()

Devuelve el número de milisegundos a partir de las 0:00 del 1 de enero de 1970, igual que valueOf ()

Antes de ECMAScript5, puede usar el método getTime () para implementar date.now ()

 Date.now = function () {return (new Date ()). GetTime ()}

getTimezoneOffset ()

Devuelve la diferencia de zona horaria entre la hora actual y UTC, expresada en minutos (8*60 = 480 minutos). El resultado de la devolución tiene en cuenta los factores de tiempo de ahorro de verano.

 console.log(new Date('2016-7-12').valueOf());//1468252800000console.log(new Date('2016-7-12').getTime());//1468252800000console.log(new Date('2016-7-12').getTimezoneOffset());//-480

getyear ()

Devuelve el número de años a partir de 1900 (anticuado)

Obtenga [UTC] Complety ()

Año de regreso (4 dígitos)

Obtener [utc] mes ()

Regreso al mes (0-11)

Obtener [UTC] fecha ()

Vuelve a qué día (1-31)

Obtenga el día [UTC] ()

Regrese al día de la semana (0-6)

Obtener [utc] horas ()

Valor de la hora de retorno (0-23)

Obtenga [UTC] minutos ()

Devuelve el valor minuto (0-59)

Obtener [utc] segundos ()

Devuelve el segundo valor (0-59)

Obtenga [UTC] MilliseConds ()

Valor de retorno de milisegundos (0-999)

[Nota] La hora de UTC se establece mediante la cadena de formato de fecha y hora estándar y tiene configuración de parámetros en forma de pre-0.

 console.log (nueva fecha ('2016-07-12T10: 00'). getyear ()); // 116console.log (nueva fecha ('2016-07-07-12T10: 00'). getFloyear ()); // 2016console.log (nueva fecha ('2016-07-12T10: 00'). Fecha ('2016-07-12T10: 00'). GetMonth ()); // 6console.log (nueva fecha ('2016-07-12T10: 00'). GetUtcmonth ()); // 6console.log (nueva fecha ('2016-07-12T10: 00'). GetDate ()); // 12console.log (neweN Fecha ('2016-07-12T10: 00'). GetUtcdate ())); // 2console.log (nueva fecha ('2016-07-12T10: 00'). GetUtcday ()); // 2console.log (nueva fecha ('2016-07-12T10: 00'). Getutcday ()); // 2console Fecha ('2016-07-12T10: 00'). Gethours ()); // 18Console.log (nueva fecha ('2016-07-12T10: 00'). GetUtChours ()); // 10console.log (nueva fecha ('2016-07-12T10: 00'). GetMinutes ()); // 0console Fecha ('2016-07-12T10: 00'). GetUtcminutes ()); // 0console.log (nueva fecha ('2016-07-12T10: 00'). GetSeconds ()); // 0console.log (New Fecha ('2016-07-12T10: 00'). Fecha ('2016-07-12T10: 00'). GetMilliseConds ()); // 0console.log (nueva fecha ('2016-07-12T10: 00'). GetUtcmilliseConds ()); // 0

 // La hora actual es 16: 35Console.log (nueva fecha (). Gethours ()); // 16console.log (nueva fecha (). GetUtThours ()); // 8

【Establezca clase】

El objeto Date proporciona una serie de métodos de clase establecidos para establecer varios aspectos del objeto de instancia.

El método establecido se corresponde básicamente con el método GET. El método establecido pasa en un parámetro similar a la fecha.utc () y devuelve el número de milisegundos internos de la fecha ajustada

[Nota] solo consigue en la semana, no establecido

setTime ()

Use el formato MilliseCond para establecer el valor de un objeto de fecha

 var d = nueva fecha ('2016-07-12T10: 00'); console.log (d.setTime (86400000), d); // 86400000 viernes de enero 02 1970 08:00:00 GMT+0800 (hora estándar de China)

setyear ()

Año establecido (anticuado)

 var d = nueva fecha ('2016-07-12T10: 00'); console.log (d.setyear (2000), d, d.getyear ()); // 9633960000 mi miércoles 12 de julio de 2000 18:00:00 GMT+0800 (Tiempo estándar de China) 100

establecer [utc] totalmentear ()

Establecer año (4 dígitos) y valores opcionales de mes y fecha

establecer [utc] mes ()

Establecer un mes (0-11) y valores de fecha opcionales

establecer [utc] date ()

Establecer el día (1-31)

 var d = nueva fecha ('2016-07-12T10: 00'); console.log (d.settyfulfyear (2015,1,1), d.gettyfulfyear ()); // 1422784800000 2015console.log (d.setMonth (2), d.getMonth ()); // 1425204000000 2Console.log (d.setDate (20), d.getDate ()); // 1426845600000 20Console.log (d.tolocalEstring ()); // 2015/3/20 6:00:00 PM

establecer [utc] horas ()

Establecer valores de hora (0-23), así como valores de minuto opcionales, segundos valores y valores de milisegundos

establecer [utc] minutos ()

Establezca el valor minuto (0-59), así como el segundo valor opcional y el valor de milisegundos

establecer [utc] segundos ()

Establezca el segundo valor (0-59) y el valor opcional de milisegundos

establecer [utc] miliseConds ()

Establecer el valor de milisegundos (0-999)

 var d = nueva fecha ('2016-07-12T10: 20: 30'); console.log (d.sethours (1,2,3), d.gethours ()); // 1468256523000 1console.log (d.setminutes (2,3), d.getminutes ()); // 1468256523000 2console.log (d.setSeconds (3), d.getSeconds ()); // 1468256523000 3console.log (d.tolocaletimestring ()) // 1:02:03 am

 var d = nueva fecha ('2016-07-12T10: 20: 30'); console.log (d.setUtTours (1,2,3), d.gethours ()); // 1468285323000 9console.log (d.setutcminutes (2,3), d.getminutes (); // 1468285323000 2console.log (d.setUtcSeconds (3), d.getSeconds ()); // 1468285323000 3console.log (d.tolocaletimestring ()) // 9:02:03 am

El artículo anterior sobre el sistema de tipo JavaScript: una comprensión integral del objeto Fecha de fecha es todo el contenido que he compartido con usted. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.