Обмен готовыми решениями

...
if (document.title=="Дрессировка собак")
  {
    document.write('<a href="index.html"><b>Home page</b></a> ');
  }
if (document.title!="Дрессировка собак")
  {
    document.write('<a href="index.html">Home page</a> ');
  }...

IE = (document.all);
NC = (document.layers);
Opera = (document.getElementById);
 
function getWidth() {
    if (IE || Opera)
        send = document.body.clientWidth;
    if (NC)
        send = window.innerWidth;
    return send;
}

// после создания экземпляра вызывает его метод Create с переданными параметрами
Function.prototype.Create = function() {
    // создаем экземпляр
    var o = new this;
    // если у него есть метод Create, то вызываем его с переданными параметрами
    if (typeof o.Create == 'function') {
        if (arguments.length) o.Create.apply(o, arguments);
        else o.Create();
    };
    return o;
};
 
// наследование от другой функции или от объекта Object
Function.prototype.Inherits = function(parent) {
    // если уже унаследован, то ошибка
    if (this.prototype && this.prototype.parent) {
        throw {message : 'Class already inherited'};
    };
    // если наследуем от функции
    if (parent && parent.constructor == Function) {
        this.prototype = new parent;
        this.prototype.constructor = this;
        this.prototype.parent = parent.prototype;
    }
    // если наследуем от Object
    else if (parent && parent.constructor == Object) {
        this.prototype = parent;
        this.prototype.constructor = this;
        this.prototype.parent = parent;
    }
    // иначе ошибка
    else {
        throw {message : 'Invalid type of parent'};
    };
    return this;
};
 
// декларация нового класса с необязательным родительским классом и необязательными полями
// метод Create будет использоваться как вызов конструктора
function Class(parent, fields) {
    // создаем реальный конструктор для наследования прототипов
    var C = function(){};
    // по умолчанию пустой прототип
    C.prototype = {};
    // наследуем от родителя
    if (parent) C.Inherits(parent);
    if (typeof fields == 'object') {
        // копируем поля в прототип
        for (var k in fields) {
            if (k != 'constructor') C.prototype[k] = fields[k];
        };
    };
    return C;
};

// определяем класс A без родителя
var A = Class(null, {
    Create : function(x) {
        alert('A.Create');
        this.x = x;
    },
    Show : function() {
        alert('A: [' + this.x + ']');
    },
    foo : function() {
        alert('A.foo');
    }
});
 
// определяем класс B наследованный от A
var B = Class(A, {
    Create : function(x, y) {
        alert('B.Create');
        // вызываем наследованный Create()
        this.parent.Create.call(this, x);
        this.y = y;
    },
    Show : function() {
        // нет вызова к наследованному Show()
        alert('B: [' + this.x + ',' + this.y + ']');
    },
    foo : function() {
        alert('B.foo');
        // вызываем наследованный foo()
        this.parent.foo.call(this);
    },
    bar : function() {
        alert('B.bar');
    }
});
 
// создаем объект класса A
// 'A.Create(5)' вместо 'new A(5)'
var a = A.Create(5); // выдает A.Create
a.Show(); // выдает A: [5]
 
// создаем объект класса B
var b = B.Create(2, 3); // выдает B.Create и наследованное A.Create
b.Show(); // выдает B: [2,3]
 
a.foo(); // выдает A.foo
b.foo(); // выдает B.foo и наследованное A.foo
b.bar(); // выдает B.bar

function fixHover(element) {
    if (/MSIE (5\.5|6).+Win/.test(navigator.userAgent) && element && !element.fixHoverCallback && element.attachEvent) {
        element.fixHoverCallback = function(e) {
            e = e || window.event;
            var o = e.target ? e.target : e.srcElement;
            while (o && o != element) o = o.parentNode;
            if (o) {
                var c = o.className, c1;
                c1 = c;
                if (e.type == 'mouseover') {
                    if (!(/(?:^|\s)hover(?:\s|$)/i.test(c))) c1 = c + ' hover';
                }
                else {
                    c1 = c.replace(/\s+hover\s+/gi, ' ').replace(/^hover\s+|\s+hover$/gi, '');
                };
                if (c1 != c) o.className = c1;
            };
        };
        element.attachEvent('onmouseover', element.fixHoverCallback);
        element.attachEvent('onmouseout', element.fixHoverCallback);
    };
};

 // вспомогательный объект для получения высоты и ширины клиентского окна браузера
var win = {
    w: function() { return window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth; },
    h: function() { return window.innerHeight || document.documentElement.clientHeight || document.body.clientHeight; }
}
// объект нашего снегопада
var snow = {
    flake_image: 'snow.gif',
    flakes: [],
    timer: false,
    init: function(flake_count) {
        this.flakes = [];
        for (var i = 0; i < flake_count; i++) {
            var img = new Image();
            img.src = this.flake_image;
            img.style.position = 'absolute';
            img.style.zIndex = i;
            document.body.appendChild(img);
            this.flakes[i] = {
                img: img, 
                pos: function (x, y) {
                    this.img.style.left = x + 'px';
                    this.img.style.top  = y + 'px';
                    return this;
                },
                x: Math.random() * (win.w() - 50),
                y: Math.random() * win.h(),
                a: Math.random() * 20,
                s: { x: Math.random() * 0.1 + 0.02, y: Math.random() + 0.7 },
                d: 0
            }
        }
    },
    start: function(flake_count) {
        this.init(flake_count || 10);
        this.timer = setInterval(this.live(this), 50);
    },
    stop: function() { if (this.timer) { clearInterval(this.timer); this.timer = false; }; },
    live: function(ctx) { // замыкание
        return function() {
            for (var i in ctx.flakes) {
                var f = ctx.flakes[i];
                if ((f.y += f.s.y) > (win.h() - 50)) {
                    f.pos(f.x = (Math.random() * (win.w() - 50)), f.y = 0);
                } else {
                    f.pos(f.a * Math.sin(f.d += f.s.x) + f.x, f.y);
                }
            }
        };
    }
}

window.onload = function() { 
    // картинка со снежинкой (png или gif, чтобы прозрачности были)
    snow.flake_image = 'http://www.sunshineworldpoland.com/images/snowflake.png';
    // стартуем (параметр - количество хлопьев)
    snow.start(50);
}

function clone(o) {
        var c = 'function' === typeof o.pop ? [] : {},
            p, v;
        for (p in o) {
            if (o.hasOwnProperty(p)) {
                v = o[p];
                if (v && 'object' === typeof v) {
                    c[p] = this.clone(v);
                }
                else {
                    c[p] = v;
                }
            }
        }
        return c;
    }

/**
      Объект calculateCredit имеет два метода:
    differ и annuitet. Первый метод рассчитывает кредит с
    дифференцированными платежами, второй --- с аннуитетными.
    
      Оба метода принимают три параметра: 
    sum (сумма кредита), 
    term (срок кредита), 
    rate (процентная ставка по кредиту). 
    
      Оба метода возвращают объект, содержащий:
    overpay: переплату по кредиту за весь срок,
    payments: массив, включающий все платежи по кредиту.
    (Метод annuitet возвращает массив, состоящий из 
    одного элемента, поскольку все платежи одинаковы).
    total:  общую сумму, которую нужно будет вернуть Банку.
    (с) GuardCat2012
*/
 
calculateCredit = (
 
  function() {
  
     var 
       errMsg = "Ошибочка. Проверьте введённые цифры",
      wrongResult = {
        overpay: errMsg, 
        payments: [errMsg],
        total: errMsg 
      }
    ;
    
    return {
    
      differ: function(sum, term, rate) {
         var 
           overpay, payment, count, x,
           result = { 
            total: 0,
            overpay: 0,
            payments: [ ]
          }
         ;
  
        for(var x in arguments) {
          arguments[x] = parseFloat(arguments[x]);
          if( isNaN( arguments[x] ) ) return wrongResult;
          if( arguments[x] === 0) arguments[x] = 0.0000000000001;
        }
 
        if(rate) rate = rate / 100 / 12; 
        while(term) {
          payment = sum / term;
          overpay =  sum * rate;
          result.overpay += overpay;
          count = result.payments.length; 
          result.payments.push( +(payment + overpay ).toFixed( 2 ) );
          result.total += result.payments[count];
          term--;
          sum -= payment;
        }
        result.total = result.total.toFixed(2);
        result.overpay = result.overpay.toFixed(2);
        return result
        
      },
      
      annuitet: function(sum, term, rate) {
        var 
          x, koeffAnn  ,
          result = { 
            total: 0,
            overpay: 0,
            payments: [ ]
          }
        ;
  
        for(var x in arguments) {
          arguments[x] = parseFloat(arguments[x]);
          if( isNaN( arguments[x] ) ) return wrongResult;
          if( arguments[x] === 0) arguments[x] = 0.0000000000001;
        }
        
        if(rate) rate = rate / 100 / 12; 
        koeffAnn = rate * Math.pow( ( 1 + rate ), term ) / (  Math.pow( ( 1 + rate ), term ) - 1 );
        result.payments.push( ( sum * koeffAnn ).toFixed( 2 ) );
        result.total = ( result.payments[0] * term ).toFixed( 2 );
        result.overpay = ( result.total - sum ).toFixed( 2 );
 
        return result;
      }
    }//object
    
  }//anonymous function
  
)()

function animate(opts) {
    var start = new Date();
    var timer = setInterval(function() {
        var progress = (new Date - start) / opts.duration;
        if (progress > 1) progress = 1;
        opts.step(opts.delta(progress));
        if (progress == 1) {
            clearInterval(timer);
            opts.compleat && opts.compleat(opts.elem);
        };
    }, opts.delay || 40);
    return timer;
}
 
 
function Prop(opts) {
    opts.step = function(prog) {
        var value;
        for (var i = opts.prop.length; i--;) {
            value = opts.start[i] + ((opts.value[i] - opts.start[i]) * prog);
            opts.elem.style[opts.prop[i]] = value + opts.units;
        };
    }
    if (!opts.delta) {
        opts.delta = function(progress) {
            return progress;
        }
    }
    return animate(opts);
}
/* 
анимация нескольких свойств:
 
-можно анимировать несколько свойств ['opacity','width']
  тогда start передается так [0,100](100 - начальное значение ширины) , а value так [1,500](500 -    конечное значение ширины)
 
*/
Prop({
    elem: document.getElementById('testBlock'), //элемент на котором происходит анимация 
    start: [0, 0], // начальное значение
    value: [100, 300], // конечное значение
    prop: ['top', 'left'], // свойство анимации
    duration: 2000, // время анимации
    units: 'px', //единицы измерение px || % || ''-без единици измерения
    delta: function(progress) { // НЕ обязательные параметр задающий вид анимации
        for (var a = 0, b = 1, result; 1; a += b, b /= 2) {
            if (progress >= (7 - 4 * a) / 11) {
                return -Math.pow((11 - 6 * a - 11 * progress) / 4, 2) + Math.pow(b, 2)
            }
        }
    }
});