Вот один лайнер, который можно добавить к формам:
$(':input',document.myForm).bind("change", function() {
enablePrompt(true); }); // Prevent accidental navigation away
И затем можно сделать enableUnloadPrompt () функцией для целого сайта:
function enablePrompt(enabled) {
window.onbeforeunload = enabled ? "Your changes are not saved!" : null;
}
И наконец перед представлением формы правильно удостоверьтесь, что:
enablePrompt(false);
Это не проверит, чтобы видеть, отличается ли форма в значениях, только если форма когда-либо изменялась пользователем. Но, это просто и просто в использовании.
Массивы Ruby не реализованы как односвязные списки, поэтому не так полезно иметь car, cdr и прочее.
Если вы действительно хотите, вы можете сделать
[1,2,3][0] => 1
[1,2,3].first => 1
[1,2,3][1..-1] => [2,3]
[1] + [2,3] => [1,2,3]
Вот как можно реализовать lisp-подобные односвязные списки в ruby:
class Object
def list?
false
end
end
class LispNilClass
include Enumerable
def each
end
def inspect
"lnil"
end
def cons(car)
Cell.new(car, self)
end
def list?
true
end
end
LispNil = LispNilClass.new
class LispNilClass
private :initialize
end
class Cell
include Enumerable
attr_accessor :car, :cdr
def initialize(car, cdr)
@car = car
@cdr = cdr
end
def self.list(*elements)
if elements.empty?
LispNil
else
first, *rest = elements
Cell.new(first, list(*rest))
end
end
def cons(new_car)
Cell.new(new_car, self)
end
def list?
cdr.list?
end
# Do not use this (or any Enumerable methods) on Cells that aren't lists
def each
yield car
cdr.each {|e| yield e}
end
def inspect
if list?
"(#{ to_a.join(", ") })"
else
"(#{car} . #{cdr})"
end
end
end
list = Cell.list(1, 2, 3) #=> (1, 2, 3)
list.list? #=> true
list.car #=> 1
list.cdr #=> (2, 3)
list.cdr.cdr.cdr #=> lnil
list.cons(4) #=> (4, 1, 2, 3)
notlist = Cell.new(1,2) #=> (1 . 2)
notlist.list? #=> false
notlist.car #=> 1
notlist.cdr #=> 2
notlist.cons(3) #=> (3 . (1 . 2))
Полусерьезно, если вам нужны МИНУСЫ, CAR и CDR в Ruby, вы могли бы сделать хуже, чем
def cons(x,y) return lambda {|m| m.call(x,y)} end def car(z) z.call(lambda {|p,q| p}) end def cdr(z) z.call(lambda {|p,q| q}) end
И тогда вы можете определить свой список процедуры,
def interval(low, high) if (low > high) return nil else return cons(low, interval(low + 1, high)) end end def map(f, l) if (l == nil) return nil else cons(f.call(car(l)), map(f, cdr(l))) end end def filter(p, l) if (l == nil) return nil elsif (p.call(car(l))) return cons(car(l), filter(p, cdr(l))) else return filter(p, cdr(l)) end end def reduce(f, f0, l) if (l == nil) return f0 else return f.call(car(l), reduce(f, f0, cdr(l))) end end
А затем вы можете получить сумму нечетных квадратов в диапазоне от 1 до 10:
reduce(lambda {|x, y| x + y}, 0, filter(lambda {|x| x % 2 == 1}, map(lambda {|x| x * x}, interval(1, 10)))) => 165
>> [1,2,3].drop 1
=> [2, 3]
>> [1,2,3].first
=> 1
Конечно, как вы знаете, они не слишком близки к Лиспу. Настоящий эквивалент рубина будет выглядеть примерно так [1, [2, [3, nil]]]
. Вы всегда можете написать класс List ... или где-нибудь его найти.
Глава 8 из Практические проекты Ruby называется Реализация Lisp в Ruby .
Я бы рекомендовал прочитать Ruby API для Array
. Там есть много методов и операторов, которые могут делать именно то, что вам нужно.