Точно, каково различие между “закрытием” и “блоком”?
не был должен это:
{{ user.item }}
быть этим?
{{ item }}
нет никакого пользовательского объекта в контексте в том цикле....?
4 ответа
В Windows этот файл можно запустить из командной строки в cscript.exe, и он представляет собой простую интерактивную оболочку. Без завершения.
// shell.js
// ------------------------------------------------------------------
//
// implements an interactive javascript shell.
//
// from
// http://kobyk.wordpress.com/2007/09/14/a-jscript-interactive-interpreter-shell-for-the-windows-script-host/
//
// Sat Nov 28 00:09:55 2009
//
var GSHELL = (function () {
var numberToHexString = function (n) {
if (n >= 0) {
return n.toString(16);
} else {
n += 0x100000000;
return n.toString(16);
}
};
var line, scriptText, previousLine, result;
return function() {
while(true) {
WScript.StdOut.Write("js> ");
if (WScript.StdIn.AtEndOfStream) {
WScript.Echo("Bye.");
break;
}
line = WScript.StdIn.ReadLine();
scriptText = line + "\n";
if (line === "") {
WScript.Echo(
"Enter two consecutive blank lines to terminate multi-line input.");
do {
if (WScript.StdIn.AtEndOfStream) {
break;
}
previousLine = line;
line = WScript.StdIn.ReadLine();
line += "\n";
scriptText += line;
} while(previousLine != "\n" || line != "\n");
}
try {
result = eval(scriptText);
} catch (error) {
WScript.Echo("0x" + numberToHexString(error.number) + " " + error.name + ": " +
error.message);
}
if (result) {
try {
WScript.Echo(result);
} catch (error) {
WScript.Echo("<<>>");
}
}
result = null;
}
};
})();
GSHELL();
Если хотите, вы можете дополнить это другими служебными библиотеками с помощью файла .wsf. Сохраните приведенное выше в "shell.js" и сохраните следующее в "shell.wsf":
<job>
<reference object="Scripting.FileSystemObject" />
<script language="JavaScript" src="util.js" />
<script language="JavaScript" src="shell.js" />
</job>
... где util.js - это:
var quit = function(x) { WScript.Quit(x);}
var say = function(s) { WScript.Echo(s); };
var echo = say;
var exit = quit;
var sleep = function(n) { WScript.Sleep(n*1000); };
... а затем запустите shell.wsf из командной строки.
Вы можете думать о замыкании как о функции, которая содержит то, что эта функция делает внутри себя.
Блоки полезны, потому что они позволяют определять область видимости переменных. Обычно, когда вы определяете переменную внутри области видимости, вы можете без проблем переопределить внешние определения, и новые определения будут существовать только во время выполнения блока.
for (int i = 0; i < 10; ++i)
{
int t = i*2;
printf("%d\r\n", t);
}
t определяется внутри блока (тело for ) и будет длиться внутри этого блока.
Блок - это нечто синтаксическое - логическая единица операторов (больше связана с областью действия , чем с закрытием ).
if (Condition) {
// Block here
}
else {
// Another block
}
Связано закрытие к анонимным функциям или классам - анонимный (функциональный) объект, фрагмент кода, который привязан к среде (с ее переменными).
def foo() {
var x = 0
return () => { x += 1; return x }
}
Здесь foo возвращает закрытие! Локальная переменная x сохраняется при закрытии даже после завершения foo и может быть увеличена посредством вызовов возвращенной анонимной функции.
val counter = foo()
print counter() // Returns 2
print counter() // Return 3
Обратите внимание, что это просто Ruby, в котором обрабатываются блок и закрытие. аналогично, поскольку то, что Ruby называет блоком , является закрытием :
(1..10).each do |x|
p x
end
Там каждому -методу передается функция закрытия (принимающая параметр x), которая называется блоком ] в Ruby.
Громкий бородатый человек говорит о замыканиях и блоках следующее:
http://martinfowler.com/bliki/Closure.html
В какой-то момент он говорит о закрытии - это блок, который можно передать в качестве аргумента методу.
Термины, которые вы используете, наиболее часто используются вместе в наши дни в Ruby, хотя конструкции ранее появлялись в Algol, Smalltalk и Scheme. Я бы процитировал стандарт Ruby, если бы он был.
Я не уверен, что смогу ответить на ваш точный вопрос, но могу проиллюстрировать. Приношу свои извинения, если вы это уже знаете ...
def f &x
yield
x
end
def g
y = "block"
t = f { p "I'm a #{y}" }
y = "closure"
t
end
t = g
t.call
И ...
$ ruby exam.rb
"I'm a block"
"I'm a closure"
$
Итак, блок - это анонимная функционально-подобная последовательность кода, прикрепленная к вызову метода. Он используется во всем Ruby API. Когда вы достаточно упростите создание анонимной функции, оказывается, что они полезны для всех видов вещей.
Но обратите внимание, что после возврата f возвращается g , мы удерживали блок, возвращая его из f (как x ), а затем из g (как t ). Теперь вызываем блок во второй раз. Снова обратите внимание, что g () вернулось. Но блок ссылается на локальную переменную в экземпляре функции (и в области видимости), которой больше не существует ?! И он получает новое значение y ?!
Таким образом, замыкание - это функционально-подобный объект, который закрыт по своей лексической области видимости. Их довольно сложно реализовать, поскольку они разрушают модель «сделай это со стеком», которая так полезна для локальных переменных в экземплярах вызовов функций.
1. Ruby имеет различные разновидности закрывающих функциональных объектов; это только один из них. Но блок ссылается на локальную переменную в экземпляре функции (и в области видимости), которой больше не существует ?! И он получает новое значение y ?!
Таким образом, замыкание - это функционально-подобный объект, который закрыт по своей лексической области видимости. Их довольно сложно реализовать, потому что они разрушают модель «сделай это со стеком», которая так полезна для локальных переменных в экземплярах вызовов функций.
1. Ruby имеет различные варианты закрывающих функциональных объектов; это только один из них. Но блок ссылается на локальную переменную в экземпляре функции (и в области видимости), которой больше не существует ?! И он получает новое значение y ?!
Таким образом, замыкание - это функционально-подобный объект, который закрыт по своей лексической области видимости. Их довольно сложно реализовать, поскольку они разрушают модель «сделай это со стеком», которая так полезна для локальных переменных в экземплярах вызовов функций.
1. Ruby имеет различные варианты закрывающих функциональных объектов; это только один из них. Их довольно сложно реализовать, потому что они разрушают модель «сделай это со стеком», которая так полезна для локальных переменных в экземплярах вызовов функций.
1. Ruby имеет различные разновидности закрывающих функциональных объектов; это только один из них. Их довольно сложно реализовать, поскольку они разрушают модель «сделай это со стеком», которая так полезна для локальных переменных в экземплярах вызовов функций.
1. Ruby имеет различные разновидности закрывающих функциональных объектов; это только один из них.