Uma de nossas práticas mais comuns para a expansão do JavaScript é a expansão da data.Prototype. Porque sabemos que a classe de data fornece apenas vários métodos de obtenção de elementos de data, como getDate (), getMinute () ... mas nenhum dos métodos de formatação convertidos em string específica. Portanto, use esses métodos sutis para encapsular e combinar o formulário de string de data que desejamos. De um modo geral, essa função de formatização pode ser definida no protótipo do objeto Data, ou pode ser escrito de forma independente. A operação do protótipo de definição é como date.prototype.format = function (date) {...}, e diretamente New Date (). . No entanto, o método de protótipo de definição é ligeiramente suspeito da falta de protótipo JS de "invasão". Este problema deve ser considerado ao projetar API. Minha sugestão é que os usuários tomem decisões de acordo com seu próprio julgamento, mas o método de chamada é diferente e a lógica do processo não afeta o processo.
O exemplo a seguir é a função de formatação da data do JavaScript, escrita por funções independentes, uma função de formato independente. De volta a esse ponto de formatação do conhecimento, examinamos como e quais princípios foram usados. Embora a costura tradicional da String, como o Indexof ()+Subster (), possa ser alcançado, obviamente não é apenas baixa eficiência, mas também o código é longo. Em seguida, corresponda aos resultados dos resultados. Vamos primeiro olhar para exemplos de Steven Levithan:
Copie o código do código da seguinte forma:
/**
* Formato de data 1.2.3
* @Credit Steven Levithan <stevenlevithan.com> Inclui aprimoramentos de Scott Trenda <Scott.trenda.net> e Kris Kowal <cixar.com/~kris.kowal/>
* Aceita uma data, um mestre ou uma data e um mestre.
* Retorne uma versão formatada da data fornecida.
* A data indica a data/hora atual.
* A máscara é padronizada para datar o formato.
*/
DateFormat = (function () {
// Notas regulares, 1. Aqui, isso significa que é simples corresponder a qualquer caractere, mas não é entendido no momento em que ou citações únicas).
Vartoken = /D {1,4} | /g,
// 2. Filho horário, [PMCEA] [SDP] gera o consumo de dois caracteres;
fuso horário = // b (?: [pmcea] [sdp] t | (?: Pacífico | montanha | central | leste | atlântico) (?: padrão | luz do dia | -+]/d {4})?)/b/g,
Timezoneclip =/[^-+/da-z]/g,
// em menos de dois caráter de preenchimento de bits, ou o número de posicionamento pode ser posicionado
pad = função (valor, len) {
value = string (val);
len = len || 2;
While (val.length <len) val = "0" + valor;
Valor de retorno;
};
// Por que retorna uma função, porque as variáveis explicadas anteriormente se tornaram constantes, e os parâmetros retornados abaixo são a função do tempo real. Isso é implementado fechando a escrita. Como comentários em inglês, você pode acelerar.
// Regexes e funções de suporte são armazenados em cache através do fechamento
// Parâmetro Descrição: Data: Data ou nova data;
Função de retorno (data, máscara, UTC) {
var i18n = dateFormat.i18n;
var máscara = dateFormat.masks;
// Você não pode fornecer UTC se pular outros args (use o prefixo "UTC:" Mask)
// Se houver apenas um parâmetro, esse parâmetro é uma sequência que não contém números, que é considerada máscara. A data é gerada por nova data na próxima se, então a data é a data atual.
If (argumes.length == 1 && object.prototype.tostring.call (date) == "[objeto string]" &&! // d /test (date)) {
máscara = data;
data = indefinido;
}
// Data de aprovação de três noca
Data = Data?
if (isnan (data)) lança sintaxerror ("data inválida");
// está claro o que é a máscara julgando em muitos casos, por mais que a especificasse anteriormente. Preste atenção às habilidades de ||.
Máscara = string (máscara [máscara] || máscara || máscaras ["default"]);
// permite definir o argumento UTC através da máscara
if (mask.slice (0, 4) == "utc:") {{
Mask = Mask.slice (4);
Utc = true;
}
// Dois casos, use a situação e geral no formato UTC. Observe que os índices literais de JS também podem retornar aos membros do método.
var_ = utc?
d = data [_ + "Date"] ,,,
D = data [_ + "dia"] () ,,
m = data [_ + "mês"] () ,,
y = data [_ + "totalmente"] (),
H = data [_ + "hold"] () ,,,
M = data [_ + "minutos"] (),
s = data [_ + "segundos"] () ,,,
L = data [_ + "milissegundos"] () ,,
O = UTC?
Sinalizadores = {
D: D,
Dd: pad (d),
ddd: i18n.daynames [d],
dddd: i18n.daynames [d + 7], // largura de bit: 7, consulte DateFormat.dayNames.
M: m + 1, // a partir de 0
mm: bloco (m + 1) ,,
mmm: i18n.monthnames [m],
mmmm: i18n.monthnames [m + 12], // largura de bit: 12, consulte DateFormat.monthnames
Yy: string (y) .slice (2), // string slice () uso
AYYY: Y,
H: H % 12 || 12, // H significa 12 horas, H divide 12 (porque duodos) e o resultado do restante é de 12 horas.
HH: PAD (H % 12 || 12),
H: H,
Hh: pad (h),
M: M,
Mm: pad (m),
s: s,
Ss: pad (s),
L: PAD (L, 3), // Max, 999ms
L: PAD (L> 99? Math.Round (L / 10): L),
// patrocinar a influência
T: H <12? "A": "P",
TT: H <12?
T: H <12? "A": "P",
TT: H <12?
// Procure fuso horário nesta etapa, basta lidar com isso.
// O artigo anterior é o fuso horário, timezoneclip =/[^-+/da-z]/g,
// string o formulário da string da data de retorno, incluindo uma informação longa ... UTC ...
// se não, [""] .pop () retorna o personagem vazio
Z: UTC? "),," ""), ""), ""), ""), ""), ""), ""), ""), ""), "" ")," ")," ""), " , ""
// 4 -BIT TimeZoneOffset
o: (o> 0? "-": " +") + pad (math.floor (math.abs (o) / 60) * 100 + math.abs (o) % 60, 4),
// Encontre em inglês ["th", "st", "nd", "rd"], de acordo com os dígitos de D D
S: ["Th", "St", "ND", "RD"] [D % 10> 3?
};
Return Mask.Replace (Token, função ($ 0 /* é bom $ 0, observe $ 1, $ 2 pelo sistema ocupado* /) {) {) {) {) {) {) {) {) {) { ) {)
// Como detectar os atributos especificados em um determinado objeto? Apenas detecte!
// $ 0.slice (1, $ 0.Length -1);? O que isso significa?
Retornar $ 0 em sinalizadores?
});
};
}) ();
O código é considerado abrangente sobre o processamento da data, por isso entramos no princípio para ver seu mistério -como lidar com a data!
No modelo de strings de data, concordamos em usar símbolos significativos de sim/mm/dd, etc., respectivamente, indicam um certo elemento na data, como y, que é um ano, mês, mês, se você estiver superior, você também deve Preste atenção ao distinto. Em resumo, este é um contrato padronizado, ou seja, a "máscara" chamada de código acima. Quanto à data da análise, primeiro de acordo com todos os requisitos da máscara, obtenha cada elemento de cada data um por um (getDate (), getMinute ()) ... você pode obtê -lo em breve) e depois siga o real As condições de máscara, ou seja, mascaram o método .Place (regular, elemento) para substituir o modelo de string e o elemento, e o processo de substituição ainda é uma tabela de comparação que corresponde ao sinalizador por sinalizador. Quanto à parte regular, a chave é o processo de compreensão da função Token e Substituir (). Participe dos comentários do código acima para entender os detalhes internos.
Não é cansativo inserir a longa corda de máscara sempre? Podemos reduzir nossa carga de trabalho definindo métodos constantes:
Copie o código do código da seguinte forma:
DateFormat.masks = {
"Padrão": "ddd mmm dd yyyy hh: mm: ss",
ShortDate: "m/d/yy",
shortDate2: "yy/m/d/h: mm: ss" ,,
MediumDate: "Mmm D, AAA",
LongDate: "Mmmm D, AAA",
FullDate: "DDDD, Mmmm D, AAA", ",
curto tempo: "h: mm tt",
Média: "H: MM: SS TT",
longa data: "h: mm: ss tt z",
Isodato: "AAAA-MM-DD",
Isotime: "hh: mm: ss",
ISODATETIME: "AAAA-MM-DDD't't't'HH: MM: SS",
IsoutcdateTime: "utc: aaaaaa-mm-não, não não
// Adicione a data da China @Edit 2010.8.11
.
}
dateFormat.i18n = {
DayNames: [[
"Sun", "Mon", "Ter", "Wed", "Thu", "Fri", "Sat",
"Domingo", "Segunda -feira", "Terça", "quarta -feira", "Quinta -feira", "sexta
] ,,,
MonthNames: [[
"Jan", "Fev", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
"Janeiro", "fevereiro", "março", "abril", "maio", "junho", "julho", "agosto", "setembro", "outubro", "novembro", "dezembro"
]
};
O DateFormat de Steve é suficiente para concluir a tarefa da maioria da conversão de data, mas no vasto código, encontramos uma solução melhor, sem as 20 linhas de código, e o uso regular é gratuito, ou seja, JS do sênior da lua sombra!
Copie o código do código da seguinte forma:
Date.prototype.format = function (formato) // Autor: Meizz
{{
var o = {
"M+": this.getmonth () +1, // mês
"D+": this.getdate (), // dia
"H+": this.gethours (), // hora
"M+": this.getminutes (), // minuto
"S+": this.getSeconds (), // Segundo
"q+": math.floor ((this.getmonth ())+3), // trimestre
"S": this.getMillisEconds () // milissegundos
}
if (/(y+)/. teste (formato)) formato = formato.preplace (regexp. $ 1,
(this.getlyear ()+"").
for (var k in O) if (new regexp ("(" " + k +"). teste (formato))
Formato = formato.Replace (regexp. $ 1,
Regexp.
("00"+ o [k]).
Formato de retorno;
}
alerta (new date (). formato ("yyyy-mm-dd hh: mm: ss");
O princípio é semelhante ao método Steve, mas o código mais concentrado integra habilidades e abrangência. A partir da 12ª linha de código -fonte, o método test () pode não apenas detectar a função mínima da correspondência, mas também há resultados de correspondência de memória. Em seguida, use o novo regexp para criar uma instância de expressão regular na forma de uma string e é um local inteligente, porque está diretamente conectado à tabela de hash diretamente com O! Então, de acordo com a lei, a cabaça é testada para a correspondência da vida primeiro e, se alguns, substitua -a.
Além disso, o ("00" + o [k]). O objetivo original era levar os dois últimos da matriz. Essa é uma habilidade que usa o método Subster () do primeiro parâmetro do substrato é o índice que começa a interceptar. Como resultado, quantos dígitos adicionamos antecipadamente e o comprimento original da corda fixa é inalterado (o [k] .Lengen), então quantos dígitos foram deixados. (PS "00" é equivalente a um símbolo de colocação e também pode ser usado com outra string "xx" em vez de nenhuma diferença)
Você ainda acha que esse código tem muitas dificuldades? Tentamos reescrever a função da sombra da lua como uma forte legibilidade. o código de Yueying.
Copie o código do código da seguinte forma:
data = {
Formato: function (data, formato) {
Data = New Date (Data);
data = {
Ano: Date.GetlyEar ()
, Mês: date.getmonth () + 1 // mês, o mês começa em zero
, Dia: date.getdate ()
, Hora: date.gethours () ()
, Minuto: date.getminutes ()
, Segundo: date.getSeconds ()
, Milute: date.getMillisEconds ()
};
Var
corresponder
, Reg = /(y+) |
While ((match = reg.exec (formato))! = Null) {
Match = Match [0];
if (/y/i.test (correspondência)) {
Formato = format.Replace (correspondência, data.year);
}
if (match.indexof ('m')! = -1) {
Formato = format.Replace (correspondência, date.month);
}
if (match.indexof ('d')! = -1) {
Formato = format.Replace (correspondência, data.day);
}
if (match.indexof ('h')! = -1) {
Formato = format.Replace (correspondência, data.hour);
}
if (match.indexof ('m')! = -1) {
Formato = format.Replace (correspondência, data.Minute);
}
if (match.indexof ('s')! = -1) {
Formato = formato.Replace (correspondência, Date.Second);
}
if (match.indexof ('u')! = -1) {
Formato = format.Replace (correspondência, data.milute);
}
}
Formato de retorno;
}
};
2011--1-7:
Como posso transformar a string para a data padrão do JS? Veja como o novo ext é feito?
Copie o código do código da seguinte forma:
/**
* De acordo com a data de formatação de formato específica.
* Analise um valor Inspo um usuário de data formatada usando o padrão de formato especificado.
* @param {string/date} valor para formatação (a sequência deve atender aos requisitos de formato do objeto JavaScript Data, consulte <a href = "http://www.w3schools.com/jsref/jsref_parser.asp" mce_href = = = "http://www.w.w3schools.com/jsref/jsref_parse.asp"> parse () </a>) o valor a ser formato (as sequências devem estar em conformidade com o formato esperado pelo JavaScrift
* Data do objeto <a href = "http://www.w3schools.com/jsref/jsref_parse.asp" mce_href = "http://www.w3schools.com/jsref_parse.asp" (parse ") </a> método )
* @param {string} formato (opcional) formating string. (Opcional) (Opcional) Qualquer string de formato de data válida (padrão para 'm/d/y')
* @Return {string} formatou a string. A string de data formatada
*/
Data: função (v, formato) {
if (! v) {{
Retornar "" ";
}
if (! Ext.isdate (v)) {
v = nova data (date.pars (v));
}
Return v.dateFormat (formato || ext.util.format.defaultDateFormat);
}
O construtor de data também pode determinar a data calculando o número de milissegundos a partir de 1970? —P, tudo bem, isto é, da outra maneira, da perspectiva desse problema, a unidade com a menor data de JS é milissegundos.
Versão final:
Copie o código do código da seguinte forma:
/**
* Formatação de data. Para detalhes, consulte a postagem do blog: http://blog.csdn.net/zhangxin09/archive/2011/01/6111294.aspx
* Por exemplo: New Date ().
* @param {string} formato
* @Return {string}
*/
Date.prototype.format = function (formato) {
var $ 1, o = {
"M +": this.getmonth () + 1, // mês, comece de 0
"D+": this.getdate (), // data
"H+": this.gethours (), // horas
"M+": this.getminutes (), // minutos
"S+": this.getSeconds (), // segundos
// Quarter Quate
"Q +": math.floor ((this.getmonth () + 3) / 3),
"S": this.getMillisEconds () // milhares de segundos
};
tecla var, valor;
if (//y+)/.test (formato)) {{
$ 1 = regexp.
Format = format.Replace ($ 1, string (this.getlyear ()). Substr (4 -$ 1));
}
Para (chave em O) {// Se o parâmetro não for especificado, o sub -cordão continuará até o final do Stringvar.
if (novo regexp ("(" + key + ")"). teste (formato) {
$ 1 = regexp.
Value = string (o [chave]),
Valor = $ 1.Length == 1?
Format = format.Replace ($ 1, valor);
}
}
Formato de retorno;
}