Este é o código-fonte do plug-in de rolagem JS que escrevi durante o Ano Novo Chinês. Não estou satisfeito com os resultados dos resultados. Voltei a consolidar e aprender JS em profundidade. Este plug-in tem os seguintes aspectos insatisfatórios:
Para efeitos excessivos do conteúdo, você pode consultar a barra de rolagem na recente lista de sessões do cliente QQ. Sua rolagem é muito tranquila, simplesmente colocada, não possui efeitos de transição de animação.
Não é uma compatibilidade perfeita, o estilo de IE6 e 7 ainda é um pouco falho.
O estilo é imperfeito, como a barra de rolagem é exibida apenas quando o mouse é suspenso e o efeito oculto após a remoção não é escrito.
A estrutura interna é confusa e a estrutura de conteúdo precisa ser ajustada.
A imagem da barra de rolagem não é um artista, afinal, e é tão nojento cortar a imagem sozinho ...
No geral, ainda é possível assistir, mas ainda há uma falta de animação. Quando escrevi esse plug-in, percebi que meu plug-in usava algumas funções relativamente básicas, então pensei que essas funções deveriam ser encapsuladas. Eu tenho estudado JS de profundidade recentemente. Depois de ler o livro em questão, devo começar a escrever este plug-in básico de função. Obviamente, um mecanismo de animação é indispensável. Sem mais delongas, o código-fonte está aqui (Nota: A versão completa deste plug-in possui imagens, faça o download do plug-in completo no anexo no final do artigo):
CSS
A cópia do código é a seguinte:
.lf_scroll, .lf_scroll li {preenchimento: 0; margem: 0; estilo de lista: nenhum; Fonte: 14px/24px "Helvetica Neue", Helvetica, Arial, 'Microsoft Yahei', Sans-Serif; Esboço: Nenhum; }
.lf_scroll {cursor: pointer; Largura: 10px; Posição: Absoluto; Direita: 0; topo: 0; filtro: alfa (opacidade = 50); -Moz-Opacity: 0,5; -khtml-opacidade: 0,5; Opacidade: 0,5; }
.lf_scrollfocus {filtro: alpha (opacidade = 100); -Moz-Opacity: 1; -khtml-opacidade: 1; opacidade: 1; }
.lfs_top, .lfs_center, .lfs_bottom {background: url ('scrollbar.gif'); Largura: 10px; Altura: 10px; }
.lfs_top {posição de fundo: 1px 0px; }
.lfs_center {posição de fundo: centro 0; Altura: 100px; }
.lfs_bottom {posição de fundo: -22px 0; }
/*Desenvolvedores Config*/
.rolldiv {altura: 100%; largura: 100%; estouro: oculto; Posição: relativa; }
JavaScript
A cópia do código é a seguinte:
/*
* Este plug -in é definido na barra de rolagem da página da simulação, insira -se após a ligação para eventos DOM
*
* Versão de comentário: 1.0.0
* Autor: Linkfly
* Sina: Concentre -se em meio século para você | CNBlogs: http://www.cnblogs.com/silin6/ | E -mail: [email protected]
* Data: 2014-02-05 02:38:35
*
*
* Dual licenciado sob as licenças do MIT e GPL:
* http://www.opensource.org/license/mit-license.php
* http://www.gnu.org/license/gpl.html
*
*/
(função (janela, indefinida) {
// Informações do parâmetro de configuração
var config = {
Auto: verdadeiro,
Altura: 'Auto',
Largura: 'Auto'
};
var linkflyscroll = function (dom, opções) {
/// <summary>
/// 1: Gere um objeto de barra de rolagem simulada, [vinte eventos ao objeto especificado depois que esse objeto funcionar, caso contrário, os eventos que você vinculou anteriormente não funcionará]
/// 1.1 - LinkFLYSCROLL (DOM) - Gere o objeto ScrollBar no DOM especificado
/// 1.2 - LinkFlyScroll (DOM, Opções) - Gere objetos de scrollbar e forneça uma série de parâmetros que permitam personalizar o modelo de trabalho para configurar o objeto.
/// </summary>
/// <param name = "dom" type = "string ou elemento">
/// passa no objeto JS DO
/// </param>
/// <param name = "options" type = "json">
/// Personalize o modelo de trabalho desse objeto, com as seguintes opções:
/// [opcional] Auto (booleano): quando o conteúdo não atingir a altura do contêiner, a barra de rolagem será automaticamente oculta? O padrão é verdadeiro (sim)
/// [opcional] Hight (int ou string): a unidade padrão é PX, que pode ser int e string. Se o valor for automático, a altura do CSS será usada por padrão.
/// [opcional] Largura (int ou string): a unidade padrão é PX, que pode ser int e string. Se o valor for automático, a largura do CSS será usada por padrão.
/// </param>
/// <returns type = "linkflyscroll"/>
if (typeof (dom) === 'string') {
DOM = document.getElementById (DOM);
}
// nenhum dom especificado e nenhum dom válido encontrado
// linkflyscroll (""), linkflyscroll (null), linkflyscroll (indefinido)
if (! dom ||! Dom.nodetype)
devolver isso;
// Crie objeto de contêiner
var scrollobj = document.createElement ('div');
// O objeto de conteúdo é profundamente clonado e não contém eventos; portanto, você precisa esperar até que o objeto LinkFLYScroll termine de funcionar antes de vincular eventos ao objeto DOM.
var cloneobj = dom.clonode (true);
scrollobj.className = 'rolldiv';
scrollobj.appendChild (cloneobj);
// Substitua o objeto atual na página
dom.parentnode.replacechild (scrollobj, dom);
Retorne new linkflyscroll.prototype.init (scrollobj, opções? Opções: {});
};
linkflyscroll.prototype.init = function (dom, opções) {
/// <summary>
/// 1: Este objeto é o objeto real. A maneira especial de trabalhar é porque pode haver chamadas estáticas e chamadas instanciadas do LinkFlyScroll
/// 1.1 - init (DOM, Opções) - Gere o objeto ScrollBar no DOM especificado
/// </summary>
/// <param name = "dom" tipo = "elemento">
/// objeto dom
/// </param>
/// <param name = "options" type = "json">
/// Personalize o modelo de trabalho desse objeto, com as seguintes opções:
/// [opcional] Auto (booleano): quando o conteúdo não atingir a altura do contêiner, a barra de rolagem será automaticamente oculta? O padrão é verdadeiro (sim)
/// [opcional] Hight (int ou string): a unidade padrão é PX, que pode ser int e string. Se o valor for automático, a altura do CSS será usada por padrão.
/// [opcional] Largura (int ou string): a unidade padrão é PX, que pode ser int e string. Se o valor for automático, a largura do CSS será usada por padrão.
/// </param>
/// <returns type = "linkflyscroll"/>
/*
* Este objeto contém as seguintes propriedades:
* ISDRAG: A barra de rolagem está sendo arrastada
* STARTTOP: (funcionando) Scroll Brancy Start Scrolling Position
* ENDTOP: (funcionando) Posição de rolagem da barra de rolagem
* TopLimit: posição limite superior da barra de rolagem
* BottomLimit: a posição limite na parte inferior da barra de rolagem
* Contexto: Conteúdo Dom
* scrollRadix: rolando cardinalidade
* Alvo: contêiner DOM
*/
// A corrente esse objeto, para impedir que esse ponteiro mude com frequência no ambiente (por exemplo, ao vincular eventos), salve o objeto atual.
varcrScroll = this;
// domelement
if (dom.nodetype) {
// Salvar contêiner e conteúdo dom
CurrScroll.target = dom;
CurrScroll.Context = Dom.FirstChild;
// Mesclar parâmetros de configuração
GurrScroll.Options = Tool.Extend (Config, Options);
if (GurrScroll.Options.Width! == 'Auto') {
dom.style.width = Tool.convertValue (CurrScroll.Options.Width);
}
if (GurrScroll.Options.Height! == 'Auto') {
dom.style.Height = Tool.ConvertValue (GurrScroll.Options.Height);
}
// Encontre um DOM válido
while (CurrScroll.Context.NodeType! = 1) {
CurrScroll.Context = CurrScroll.Context.Nextsibling;
}
// Crie scrollbar dom
CurrScroll.scrollul = document.createElement ('ul');
CurrScroll.scrollul.className = 'lf_scroll';
CurrScroll.Scrollul.AppendChild (Tool.SetClass ('Li', 'LFS_TOP'));
CurrScroll.Scrollul.AppendChild (Tool.SetClass ('Li', 'LFS_Center'));
CurrScroll.Scrollul.AppendChild (Tool.SetClass ('Li', 'LFS_BOTTOM'));
CurrScroll.Context.style.Position = 'relativo';
// Apresentar na página antes de poder ler os dados do local
dom.appendChild (CurrScroll.scrollul);
this.change ();
Tool.addsCrollevent (CurrScroll.Context, função (e) {
// Bind Mouse Wheel Event, unidade de rolagem de 3px
if (e.wheel> 0) {// a roda de rolagem rola para cima
var Currtop = CurrScroll.endtop -= 3;
CurrScroll.Scrollevent.Call (CurrScroll, currtop);
} else {// a roda de rolagem rola para baixo
var Currtop = CurrScroll.endtop += 3;
CurrScroll.Scrollevent.Call (CurrScroll, currtop);
}
});
// O texto proibido é selecionado ao arrastar TODO
// Clique no evento sob o mouse e você precisa determinar se é um clique esquerdo. Atualmente, o clique com o botão direito do mouse também perceberá rolando.
Tool.Addevent (CurrScroll.Scrollul, 'Mousedown', função (e) {
mousedown.call (GurrScroll, e);
});
// Adicione eventos para implementar o monitoramento no corpo para uma melhor experiência do usuário
Tool.Addevent (document.body, 'mousemove', função (e) {
if (GurrScroll.isdrag) {
// Obtenha a posição atual do mouse
var position = ferramenta.getMousePos (e);
// A posição superior da barra de rolagem atual
var Currtop = (CurrScroll.endtop + position.Y - CurrScroll.Starttop);
// A chamada é fazer com que este ponteiro aponte para este objeto funcional com precisão
CurrScroll.Scrollevent.Call (CurrScroll, currtop);
}
retornar falso;
});
// Adicione um evento de liberação do mouse e ouça o corpo para capturar com precisão o evento de liberação
ferramenta.addevent (document.body, 'mouseup', function () {
mouseup.call (GurrScroll, []);
});
var mousedown = função (e) {
/// <summary>
/// 1: Evento de imprensa do mouse
/// 1.1 - Mousedown (E) - Evento de Mousedown na prensa de rolagem
/// </summary>
/// <param name = "e" type = "event">
/// Objeto de evento
/// </param>
/// <returns type = "linkflyscroll"/>
CurrScroll.isdrag = true;
// Obtenha a posição atual do mouse y
CurrScroll.Starttop = Tool.getMousePos (e) .y;
Tool.addclass (CurrScroll.scrollul, 'lf_scrollfocus');
retornar falso;
};
var mouseup = function () {
/// <summary>
/// 1: Evento de liberação do mouse
/// 1.1 - MouseUp () - MouseUp () - Release Evento de ScrollBar na barra de rolagem
/// </summary>
/// <returns type = "linkflyscroll"/>
gurrScroll.isdrag = false;
CurrScroll.endtop = CurrScroll.scrollul.style.top? parseInt (CurrScroll.scrollul.style.top): 0;
Tool.RemoveClass (CurrScroll.Scrollul, 'lf_scrollfocus');
retornar falso;
};
CurrScroll.Scrollevent = função (currtop) {
/// <summary>
/// 1: Evento de rolagem (núcleo), basta passar nas coordenadas que precisam ser roladas (barra de rolagem)
/// 1.1 - Scrollevent (currtop) - Evento de rolagem do núcleo
/// </summary>
/// <param name = "currtop" type = "int">
/// O valor superior da parte superior da barra de rolagem é da camada anterior do contêiner
/// </param>
/// <returns type = "void"/>
if (currtop <= CurrScroll.toplimit || currtop <0) {// limite superior
currtop = CurrScroll.toplimit;
} else if (currtop> =crrScroll.bottomlimit) {// Limite inferior
currtop = currScroll.bottomlimit;
}
// Efeito de deslocamento do ScrollBar
CurrScroll.scrollul.style.top = currtop + 'px';
var temptop = parseInt (GurrScroll.Context.style.top? CurrScroll.Context.style.top: 0);
// Código de depuração
// document.getElementById('postionInfo').innerHTML = 'currTop:' + currTop + ' scrolling cardinality:' + currScroll.scrollRadix + ' bottomLimit:' + currScroll.bottomLimit + ' endTop:' + currScroll.endTop + ' startTop:' + currScroll.startTop + " Y:" + currTop + "OFFSETTOP:" + CurrScroll.Scrollul.OffSetTop + "Compute:" + (Currtop * CurrScroll.ScrollRadix * -1) + 'px';
// Código de texto
// Rolagem de conteúdo: a barra de rolagem atual* Cardinalidade leva o número negativo
CurrScroll.Context.style.top = currtop * CurrScroll.ScrollRadix * -1 + 'PX';
};
return gurrScroll;
};
};
linkflyscroll.prototype.init.prototype.change = function () {
/// <summary>
/// 1: Alterar a função do conteúdo da barra de rolagem
/// 1.1 - alteração () - Esta função representa os dados que atualizam esse objeto de barra de rolagem. Em alguns casos, os dados do conteúdo estão mudando constantemente. Você pode chamar essa função para atualizar os dados ao objeto atual da barra de rolagem.
/// </summary>
/// <returns type = "linkflyscroll"/>
/*
* As propriedades contidas no LinkFLYScroll são principalmente inicializadas ou redefinidas nesta função:
* ISDRAG: A barra de rolagem está sendo arrastada
* STARTTOP: (funcionando) Scroll Brancy Start Scrolling Position
* ENDTOP: (funcionando) Posição de rolagem da barra de rolagem
* TopLimit: posição limite superior da barra de rolagem
* BottomLimit: a posição limite na parte inferior da barra de rolagem
* Contexto: Conteúdo Dom
* scrollRadix: rolando cardinalidade
* Alvo: contêiner DOM
*/
// Redefinir ou ler uma série de dados
varcrScroll = this;
gurrScroll.isdrag = false,
CurrScroll.starttop = 0,
CurrScroll.endtop = (CurrScroll.Scrollul.style.top? Parseint (CurrScroll.scrollul.style.top): 0),
CurrScroll.toplimit =crrScroll.target.scrolltop,
CurrScroll.bottomlimit =crrScroll.target.clientHeight,
CurrScroll.ScrollRadix = 10;
// Obtenha a altura da barra de rolagem: altura do conteúdo* (altura do contêiner/altura do conteúdo = contêiner como uma porcentagem de conteúdo)
var scrollpx =crrScroll.target.clientHeight * (CurrScroll.Target.ClientHeight / CurrScroll.Context.OffSethEight);
// altura da barra de rolagem
CurrScroll.scrollul.childnodes [1] .style.height = scrollpx + 'px';
if (CurrScroll.Context.ClientHeight <= CurrScroll.target.clientHeight && CurrScroll.Options.auto) {
CurrScroll.scrollul.style.display = 'None';
} outro {
CurrScroll.scrollul.style.display = 'bloco';
// Quando a barra de rolagem é exibida, corrija os dados máximos de posição
CurrScroll.bottomlimit -= CurrScroll.Scrollul.OffSethEight;
}
// Defina a cardinalidade de rolagem da barra de rolagem (a barra de rolagem não rola o pixel de rolagem de conteúdo 1px): (altura do conteúdo - altura do contêiner [porque o contêiner atual foi exibido para uma tela])/barra de rolagem (a barra de rolagem está em branco e pode ser rolada)
CurrScroll.ScrollRadix = (CurrScroll.Context.OffsethEight - CurrScroll.target.clientHeight) / CurrScroll.bottomlimit;
return gurrScroll;
};
linkflyscroll.prototype.init.prototype.roll = function (value) {
/// <summary>
/// 1: Método de deslocamento da barra de rolagem
/// 1.1 - Roll (valor) - Método de rolagem de barra de rolagem
/// </summary>
/// <param name = "value" type = "int">
/// porcentagem de alvos de rolagem
/// </param>
/// <returns type = "linkflyscroll"/>
varcrScroll = this;
if (typeof (valor)! == 'número') {
return gurrScroll;
}
var Currtop = (CurrScroll.bottomlimit - CurrScroll.toplimit) * Value / 100;
CurrScroll.Scrollevent (currtop);
CurrScroll.endtop = currtop;
return gurrScroll;
};
/*
* Ferramentas
*/
var ferramenta = {
setClass: function (elemento, className) {
/// <summary>
/// 1: Defina o atributo de classe do nó do elemento
/// 1.1 - setClass (elemento, classe) - Defina o atributo de classe do nó do elemento. Se não houver esse nó, crie o nó e retorne o objeto de nó modificado
/// </summary>
/// <param name = "element" type = "elemento ou string">
/// Crie o nó passando na string, caso contrário, modifique o nó
/// </param>
/// <param name = "className" type = "string">
/// Nome da classe
/// </param>
/// <returns type = "element"/>
if (tipoof elemento === 'string') {
elemento = document.createElement (elemento);
}
element.className = ClassName;
elemento de retorno;
},
Hasclass: function (elemento, className) {
/// <summary>
/// 1: determine se o elemento tem uma classe
/// 1.1 - Hasclass (Element, ClassName) - determina se o elemento tem uma classe, exceções no negócio (basicamente não ocorre essa situação) e a classe tem um verdadeiro, caso contrário, retorna falsa
/// </summary>
/// <param name = "element" type = "elemento ou string">
/// Objeto do nó
/// </param>
/// <param name = "className" type = "string">
/// Nome da classe
/// </param>
/// <returns type = "element"/>
if (! Element || element.nodetype! == 1) // Deixe a exceção passar, e nenhum processamento é realizado fora
retornar true;
var elementClassName = element.className;
if (elementClassName.length <1) {
retornar falso;
}
if (elementClassName == ClassName || ElementClassName.match (novo regexp ("(^| // s)" + className + "(// s | $)))) {
retornar true;
}
retornar falso;
},
addclass: function (elemento, classe) {
/// <summary>
/// 1: [Adicionar] classe para elemento
/// 1.1 - addclass (elemento, className) - Anexe ao elemento e retorne a classe modificada
/// </summary>
/// <param name = "element" type = "elemento ou string">
/// Objeto do nó
/// </param>
/// <param name = "className" type = "string">
/// Nome da classe
/// </param>
/// <returns type = "element"/>
if (! Tool.hasclass (elemento, className)) {
if (element.className.length <1) {
element.className = ClassName;
} outro {
element.className + = '' + ClassName;
}
}
elemento de retorno;
},
removeclass: function (elemento, classe) {
/// <summary>
/// 1: Remova a classe para elemento
/// 1.1 - addclass (elemento, classe) - Remova a classe para elemento e retorne a classe modificada
/// </summary>
/// <param name = "element" type = "elemento ou string">
/// Objeto do nó
/// </param>
/// <param name = "className" type = "string">
/// Nome da classe
/// </param>
/// <returns type = "element"/>
if (tool.hasclass (elemento, classe)) {
var reg = new regexp ("(^| // s)" + className + "(// s | $)");
element.className = element.className.replace (reg, '');
}
elemento de retorno;
},
CSS: function (elemento, chave) {
/// <summary>
/// 1: Obtenha o valor do atributo especificado pelo elemento CSS
/// 1.1 - CSS (Element, ClassName) - Obtenha o valor do atributo especificado pelo elemento CSS
/// </summary>
/// <param name = "element" type = "elemento ou string">
/// Objeto do nó
/// </param>
/// <param name = "key" type = "string">
/// o atributo CSS para obter
/// </param>
/// <returns type = "string"/>
Return Element.CurrentStyle? Element.CurrentStyle [key]: document.defaultView.getComputedStyle (elemento, false) [key];
},
addEvent: function (elemento, tipo, fn) {
/// <summary>
/// 1: Anexar eventos aos elementos
/// 1.1 - CSS (elemento, tipo, FN) - Anexar eventos ao elemento, este ponto para a fonte do evento na função
/// </summary>
/// <param name = "element" type = "elemento ou string">
/// Objeto do nó
/// </param>
/// <param name = "type" type = "string">
/// anexar o nome do evento, sem caracteres em
/// </param>
/// <param name = "fn" type = "function">
/// Objeto de evento
/// </param>
/// <returns type = "void"/>
if (element.attachevent) {
elemento ['e' + tipo + fn] = fn;
elemento [tipo + fn] = function () {elemento ['e' + tipo + fn] (window.event); }
element.attachevent ('on' + tipo, elemento [tipo + fn]);
} else if (element.addeventListener) {
element.AddeventListener (tipo, fn, false);
}
},
// RemoverEvent: function (elemento, tipo, fn) {
// /// <summary>
// /// 1: Excluir eventos para elementos, esta função não foi usada
// /// 1.1 - Remow
// /// </summary>
// /// <param name = "elemento" tipo = "elemento ou string">>
// /// objeto de nó
// /// </param>
// /// <param name = "type" type = "string">
// /// Nome do evento excluído
// /// </param>
// /// <param name = "key" type = "string">
// /// Nome da função do evento excluído
// /// </param>
// /// <returns type = "void"/>
// if (element.detachevent) {
// element.Detachevent ('on' + tipo, elemento [tipo + fn]);
// elemento [tipo + fn] = null;
//} else if (element.removeEventListener) {
// element.removeEventListener (tipo, fn, false);
//}
//},
AddScrollevent: function (elemento, fn) {
/// <summary>
/// 1: Appender Scrollevent Event
/// 1.1 - AddScrollevent (elemento, FN) - Anexar o evento Scrollevent ao elemento (evento especial, evento de rolagem da roda do mouse no elemento)
/// </summary>
/// <param name = "element" type = "elemento ou string">
/// Nó do elemento
/// </param>
/// <param name = "fn" type = "function">
/// Método de evento
/// </param>
/// <returns type = "void"/>
var bindScrollfn = function (e) {
e = e || Window.Event;
// julga a direção de rolagem da roda de rolagem: o Firefox é diferente de outros navegadores
e.wheel = (e.weeldelta? E.weeldelta: -e.detail)> 0? 1: -1; // julga a roda do mouse invertida pelo evento, 1 é para cima e -1 é para baixo
// bloqueia o comportamento padrão do navegador
if (e.preventDefault) {// ff
E.PreventDefault ();
} outro {
e.returnValue = false; // ou seja
}
fn.call (elemento, e);
}
if (document.addeventListener) {
// ff
Element.AddeventListener ('DommousCroll', bindScrollfn, false);
// w3c
Element.AddeventListener ('Mouse Wheel', bindScrollfn, false);
} else // ou seja
{
element.attachevent ('onmousewheel', bindScrollfn);
}
},
getEvent: function () {
/// <summary>
/// 1: Obtenha objeto de evento
/// 1.1 - getEvent () - Obtenha objeto de evento sem parâmetros, enquanto as compatibilidades lidam com o IE e o FF
/// </summary>
/// <returns type = "event"/>
if (document.all) {
retornar janela.event;
}
func = getEvent.caller;
while (func! = null) {
var arg0 = func.arguments [0];
if (arg0) {
if ((arg0.Constructor == Event || arg0.Constructor == mouseevent) || (typeof (arg0) == "object" && arg0.preventDefault && arg0.stoppropagation)) {
retornar arg0;
}
}
func = func.caller;
}
retornar nulo;
},
getMousePos: function (ev) {
/// <summary>
/// 1: Obtenha as coordenadas atuais do mouse
/// 1.1 - getMousePos (EV) - Obtenha as coordenadas atuais do mouse, processamento de compatibilidade e o formato de objeto retornado: {x: coordenadas do mouse x, y: mouse y coordenadas}
/// </summary>
/// <param name = "ev" type = "event">
/// Objeto de evento
/// </param>
/// <returns type = "json"/>
if (! Ev) {
EV = CurrScroll.Getevent ();
}
if (ev.pagex || ev.pagey) {
retornar {
x: ev.pagex,
Y: Ev.Pagey
};
}
if (document.documentElement && document.documentElement.scrolltop) {
retornar {
x: ev.clientx + document.documentElement.scrollleft - document.documentElement.clientleft,
y: ev.clienty + document.documentElement.scrolltop - document.documentElement.clienttop
};
}
else if (document.body) {
retornar {
x: ev.clientx + document.body.scrollleft - document.body.clientleft,
y: ev.clienty + document.body.scrolltop - document.body.clienttop
};
}
},
estender: function (Oldobj, newobj) {
/// <summary>
/// 1: mesclar dois objetos
/// 1.1 - Extend (Oldobj, Newobj) - Mesclar dois objetos e devolver o objeto mesclado, implementando -o no clone, para que não tenha impacto nos dois objetos
/// </summary>
/// <param name = "Oldobj" type = "objeto">
/// Objeto A a ser mesclado, que é usado como objeto base, substitui o atributo do mesmo nome do novo objeto no objeto base
/// </param>
/// <param name = "newobj" type = "objeto">
/// objeto B a ser mesclado
/// </param>
/// <returns type = "objeto"/>
var tempobJ = Tool.Clone (OldObj);
para (tecla var em newobj) {
if (newobj.HasownProperty (key) &&! Tempobj.HasownProperty (Key)) {
tempobj [key] = newobj [key];
}
}
retornar tempobj;
},
Clone: function (obj) {
/// <summary>
/// 1: Clonando um objeto
/// 1.1 - clone (obj) - clone um objeto e retorne o novo objeto clonado. O protótipo do objeto é o objeto clonado
/// </summary>
/// <param name = "obj" type = "objeto">
/// o objeto para clonar
/// </param>
/// <returns type = "objeto"/>
função clone () {}
Clone.prototype = obj;
var newobj = new clone ();
para (tecla var em newobj) {
if (typeof newobj [key] == "objeto") {
newobj [key] = ferramenta.clone (newobj [key]);
}
}
retornar newobj;
},
ConvertValue: function (value) {
/// <summary>
/// 1: converta o valor em um valor válido
/// 1.1 - ConvertValue (valor) - Converta o valor CSS configurado por JSON em um valor válido, verifique se o valor do valor não é "automático"
/// </summary>
/// <param name = "value" type = "objeto">
/// o valor a ser convertido
/// </param>
/// <returns type = "objeto"/>
var reg =/^/d+$/g;
if (typeof (value) === 'número' || reg.test (value)) {
Valor de retorno + 'px';
} outro
valor de retorno;
}
};
// Registre -se na janela
window.linkflyscroll = linkflyscroll;
// Registre -se no espaço de nome da janela.so
if (! window.so) {
window.so = {};
}
window.so.scroll = window.linkflyscroll;
})(janela);
Exemplo de código
A cópia do código é a seguinte:
<! Doctype html public "-// w3c // dtd xhtml 1.0 transitional // pt" "http://www.w3.org/tr/xhtml1/dtd/xhtml1-bransitional.dtd">
<html xmlns = "http://www.w3.org/1999/xhtml">
<head>
<Title> </title>
<link href = "linkflyscroll/linkflyrollcss.css" rel = "stylesheet" type = "text/css"/>
<script src = "linkflyscroll/linkflyscroll-1.0.0.js" type = "text/javascript"> </sCript>
<script type = "text/javascript">
window.onload = function () {
var config = {
Auto: true, // Quando o conteúdo não atingir a altura do contêiner, a barra de rolagem será automaticamente oculta
Altura: '100', // A altura de trabalho do objeto de barra de rolagem (a barra de rolagem será exibida se exceder essa altura), o automóvel obtém a altura atual do objeto
Largura: 'Auto' // Objeto Scrollbar Working Largura
};
var scrollobJ = SO.Scroll ('obj', config);
// scrollobj.change (); // Quando o conteúdo da barra de rolagem muda, a tela de barra de rolagem precisa ser atualizada, então esse método é chamado
// scrollobj.roll (value); // posicionar a barra de rolagem até um determinado ponto, o valor é a porcentagem em relação ao objeto da barra de rolagem
};
</script>
</head>
<Body>
<div id = "obj">
<div>
Atualmente, um novo "estilo de moda" está surgindo no campo da gestão corporativa, e algumas empresas gigantes estão "diminuindo" para si e se transformando em empresas mais inteligentes e mais ágeis. Entende-se que o Oracle Software está mudando cada vez mais os principais custos de manutenção de seus clientes para consultores e fornecedores de terceiros.
"Na China, 90% dos negócios da Oracle são realizados através desses parceiros. Além disso, para garantir ainda mais a receita da Oracle, o CEO Ellison também comprou uma pequena ilha no Havaí", disse Craig Guarente.
Como vice -presidente global, o Guarente está muito ciente das estratégias da Oracle. O Guarente tem 16 anos de experiência profissional e tem uma rica experiência em gerenciamento de contratos, gerenciamento de licença de software e auditoria de software. Depois de deixar o Oracle em 2011, ele ingressou na Palisade, cujo principal negócio é ajudar os clientes da Oracle a fornecer contratação de software, intervenção de auditoria e licenciar "otimização".
O Guarente disse que os negócios da Palisade estão se desenvolvendo muito rapidamente. Como uma organização de terceiros, a Palisade ajuda os clientes a ganhar grandes pedidos porque estão mais próximos do mercado e podem entender que o usuário precisa de mais precisão.
De um modo geral, as empresas de consultoria ajudam os clientes a resolver suas necessidades reais e o que o próprio software pode fornecer. O Guarente deu uma explicação detalhada por meio de operações práticas. Por exemplo, "se você deseja criar um novo data center, inicie um novo plano de recuperação de desastres ou se deseja entrar na nuvem, uma empresa de terceiros desenvolverá primeiro um mapa de planejamento e finalmente o implementará para atingir a meta final do usuário. Se o software é possível que o software possa ser implantado em muitos locais, o Software é um software. Os administradores podem diagnosticar problemas de banco de dados por meio de relatórios automáticos de repositório de carga (AWR).
Nos últimos anos, com a ascensão da onda de auditoria de software, muitas empresas estão instalando ferramentas de gerenciamento de ativos de software para determinar qual software eles usam, quanto tempo ele pode durar e quantas pessoas em uma empresa o estão usando. Mas o analista sênior de gerenciamento Hegedus disse: "Nenhuma ferramenta pode entender com precisão as regras corporativas, especialmente os aplicativos de produtos da Oracle, e as organizações profissionais de terceiros são necessárias para ajudar os usuários a entender as regras de software".
Então, como posso corrigir os aplicativos de software da Oracle? O presidente da Oracle, Mark Hurd, disse na semana passada que, no início dos aplicativos corporativos, as instituições de terceiros devem ser definidas como apoiadores de serviços, para que as empresas possam obter reparos gratuitos de patches e outros apoio no futuro, em vez de apenas comprar direitos de propriedade intelectual do produto. Além disso, as empresas devem utilizar efetivamente os consultores para apoiar a primeira etapa no controle de custos ao entender qual software a empresa usa e o que o contrato deve incluir. Não deixe cegamente o fornecedor de software e o software de compra de acordo com o processo de suas previsões e suposições.
</div>
</div>
</body>
</html>
O exposto acima é todo o conteúdo deste artigo, e a explicação é muito detalhada. Espero que gostem.