1.json to string
A cópia do código é a seguinte:
função json2str (o) {
var arr = [];
var fmt = função (s) {
if (typeof s == 'objeto' && s! = null) retorna json2str (s);
return /^(String|Number)$/.test(Typeof s)? "'" " + s +"' ": s;
};
para (var i em o) arr.push ("'" + i + "':" + fmt (o [i]));
return '{' + arr.join (',') + '}';
}
2. Converta o timestamp até o momento
A cópia do código é a seguinte:
função deunixtime (timestamp) {
if (! Timestamp || timestamp <1000 || timestamp == '') retorna "";
var thedate = nova data (parseint (registro de data e hora) * 1000);
retornar o thedate;
}
3.Data-formato
A cópia do código é a seguinte:
// Autor: Meizz
// Extensão da data, converta a data em string no formato especificado
// 1-2 os espaços espaços de espaços reservados podem ser usados para mês (m), dia (d), hora (h), minuto (m), segundos (s) e trimestre (q).
// ano (y) pode ser usado com 1-4 espaços reservados, milissegundos só podem usar 1 espaço reservado (é um número de 1-3 dígitos)
// exemplo:
// (new Date ()). Formato ("AA YYYY-MM-DD HH: MM: SS.S") ==> 2012-12-02 08: 12: 04.423
// (new Date ()). Formato ("Aaaaa-md h: m: ss") ==> 2012-12-02 8: 12: 4.18
Date.prototype.format = function (fmt) {
var o = {
"M +": this.getmonth () + 1, // mês
"D+": this.getdate (), // dia
"H+": this.gethours (), // horas
"M+": this.getminutes (), // min
"S+": this.getSeconds (), // Sec
"q +": math.floor ((this.getmonth () + 3) /3), // trimestralmente
"S": this.getMillisEconds () // MS
};
if (/(y+)/.test(fmt))
fmt = fmt.replace (regexp. $ 1, (this.getlyear () + "") .substr (4 - regexp. $ 1.Length));
para (var k em o)
if (novo regexp ("(" + k + ")"). Teste (fmt))
fmt = fmt.replace (regexp. $ 1, (regexp. $ 1.Length == 1)? (O [k]): (("00" + o [k]). substr (("" + o [k]). comprimento));
retornar FMT;
};
4. Adicione n dias até o momento
A cópia do código é a seguinte:
função addday (número) {
Retornar deUnixTime (new Date (). getTime () / 1000 + 24 * 60 * 60 * número);
}
5. Ao usar um iframe, a chamada mútua entre o formulário pai e o formulário filho
A cópia do código é a seguinte:
// O formulário pai chama funções em forma de criança
window.frames ['ifm_id']. valuechange ("id_101");
// o formulário infantil chama a função do formulário pai
parent.RefreshTree ("nodeid_202");
6. Formulário pop -up e valor de retorno
A cópia do código é a seguinte:
// formulário pop -up
var url = "http://www.baidu.com";
win = window.showModaldialog (URL, Window, "Dialogleft: 400; Dialogtop: 200; Dialogwidth: 560px; DialogHeight: 380px; Scroll: Sim; Menubar: Não; barra de ferramentas: Não; Status: Não;");
// Defina o valor de retorno em forma pop-up
var resultado = new Array ();
resultado [0] = "id_101";
resultado [1] = "name_202";
window.returnValue = resultado;
window.close ();
7. Escopo de JavaScript [apenas escopo global e escopo da função, JavaScript não tem escopo de bloco]
A cópia do código é a seguinte:
// 1. Escopo global
var id = "variável global"; // 1.1 variável definida fora da função
função showmsg () {
message = "Mensagem global"; // 1.2 variáveis que são atribuídas diretamente sem definição
// define como uma variável global quando usado pela primeira vez
}
// 2. Escopo de função
function docheck () {
var dados = "Dados da função"; // 2.1 variáveis definidas dentro da função
}
8. Mecanismo de herança de JavaScript
A cópia do código é a seguinte:
// 1. Herança de representação do objeto
Função Pessoa (strname) {
// Campos privados
var name = strname;
// Métodos públicos
this.getName = function () {
Nome de retorno;
};
}
Função Student (Strname, Strschool) {
// Defina as propriedades e métodos da classe pai
this.parent = pessoa;
this.parent (strname);
exclua este.parent; // Excluir pai variável temporário
// define novas propriedades e métodos
// Campos privados
Var School = Strschool;
// Métodos públicos
this.getSchool = function () {
escola de retorno;
};
}
// 2. Ligue para (..) ou aplique (..) herança do objeto de função
// A diferença entre chamada e aplicação é:
// O segundo parâmetro de chamada é um parâmetro variável;
// O segundo parâmetro de aplicação é a matriz;
Função Animal (strname, Intage) {
// Campos privados
var name = strname;
var Age = Intage;
// Métodos públicos
this.getName = function () {
Nome de retorno;
};
this.getage = function () {
idade de retorno;
};
}
função gat (strname, intrage, strcolor) {
// Defina as propriedades e métodos da classe pai
Animal.Call (isto, strname, Intage);
// Animal.Apply (isto, nova matriz (strname, Intage));
// define novas propriedades e métodos
// Campos privados
var color = strcolor;
// Métodos públicos
this.getInfo = function () {
Retorne "Nome:" + this.getName () + "/n"
+ "idade:" + this.getage () + "/n"
+ "cor:" + cor;
};
}
// 3. Herança de protótipo
// As propriedades e métodos declarados do protótipo são compartilhados por todos os objetos
// O protótipo será usado apenas ao ler atributos
Function.prototype.extend = function (superclass) {
// O F aqui é evitar subclasses que acessam propriedades this.xxx na classe dos pais
função f () {};
F.prototype = superclass.prototype;
// Construtor de classe pai
this.superconstructor = superclass;
this.superclass = superclass.prototype;
this.prototype = new f ();
this.prototype.constructor = this;
};
Function.prototype.mixin = function (props) {
para (var p em adereços) {
this.prototype [p] = props [p];
}
};
caixa de função () {}
Box.prototype = {
getText: function () {
retornar este.Text;
},
setText: function (text) {
this.Text = text;
}
};
Função de seleção () {}
Caixa de seleção.extend (caixa);
Checkbox.mixin ({
isCHECKED: function () {
devolver isso.
},
SetChecked: function (verificado) {
this.checked = verificado;
}
});
9. Ligue, aplique e vincule
A cópia do código é a seguinte:
// thisarg representa o objeto indicado por isso quando a diversão está dentro
// Ligue e aplicar será imediatamente executado e retornará o resultado
var resultado = fun.call (thisArg, arg1, ...);
var resultado = fun.apply (thisArg, [argSarray]);
// thisarg representa o objeto indicado por isso quando a diversão está dentro
// Bind retorna uma função anônima
var tmpfun = fun.bind (thisArg);
var resultado = tmpfun (arg1, ...);
A cópia do código é a seguinte:
<script type = "text/javascript">
/**
* Estender a funcionalidade da função
*/
Function.prototype.bind = function (obj) {
var método = this;
var tmpfun = function () {
Método de retorno.Apply (OBJ, argumentos);
};
retornar tmpfun;
}
função parent () {
this.name = "pai";
}
função child () {
this.name = "Child";
this.getName = function (tempo) {
tempo de retorno + "" + this.name;
};
}
var pai = new Parent ();
Var Child = New Child ();
alerta (Child.getName (1)); // Mostrar 1 criança
alerta (Child.getName.Call (Parent, 2)); // Mostrar 2 Pai [Call & Apply será executado imediatamente]
var tmpfun = child.getname.bind (pai); // bind não será executado imediatamente
alerta (tmpfun (3)); // mostra 3 pais
</script>
10. JS "==" Operador
A cópia do código é a seguinte:
Regras de conversão
Se um operando for um valor booleano, converta -o em um número antes da comparação: false -> 0, true -> 1;
Se um operando for um número e o outro operando é uma string, converta a sequência em um número antes da comparação;
Se um operando for um objeto e o outro é um número ou uma string, o objeto será convertido em um tipo primitivo antes da comparação.
O mecanismo primeiro tentará chamar ValueOf (), se o valueof () não tiver substituir ou retornar um objeto,
Em seguida, o motor tentará ligar para o ToString () e, se o ToString () não tiver substituir ou retornar um objeto, uma exceção será lançada;
Se dois objetos forem comparados, determine se eles se referem ao mesmo objeto;
Se um operando for nan, == retornará falso ,! = retornará true;
Nulo e indefinido retornará falso se comparado a outros valores.
Mas nulo == nulo, indefinido == indefinido, nulo == indefinido;
Nulo e indefinido não pode ser convertido em outros valores ao participar da comparação;