Отправлено: 31.05.07 10:01. Заголовок: Блоки кода

Люди, не умею работать с конструкциями типа {||.}. Может, кто-нить напишет пример, как можно заменить обычным кодом блок кода, чтобы понять как это работает

 Отправлено: 31.05.07 10:47. Заголовок: Пример

Используем блок кода для подсчета удаленных записей в базе:
*--------------------------------------------------------*
Function DeleteRecords()
*--------------------------------------------------------*
Local nDeleted := 0

DBEVAL( { || nDeleted++ }, { || Deleted() } )

RETURN nDeleted

Решаем ту же задачу без использования блоков кода (команда):
*--------------------------------------------------------*
Function DeleteRecords()
*--------------------------------------------------------*
Local nDeleted := 0

COUNT TO nDeleted FOR Deleted()

RETURN nDeleted

или так (цикл)
*--------------------------------------------------------*
Function DeleteRecords()
*--------------------------------------------------------*
Local nDeleted := 0

GO TOP
DO WHILE !EOF()
IF Deleted()
nDeleted++
ENDIF
SKIP
ENDDO

RETURN nDeleted

Вывод: блоки кода эффективны для замены циклических операций (и не только )

 Отправлено: 31.05.07 10:56. Заголовок: Re:

Например так :

N=ASCAN(ARRAY1,{ |x| SUBSTR(x,2,2) == "AB" })
*******************************************
FOR K=1 TO LEN(ARRAY1)
IF SUBSTR(ARRAY1[K],2,2)="AB"
N=K
EXIT
ENDIF
NEXT

 Отправлено: 31.05.07 11:36. Заголовок: Re:

Блок кода - это отдельная маленькая функция, которой доступны локальные переменные функции в которой бк определен
Передача бк в качастве параметра - \то фактически передача адреса этой функции
В дальнейшем этот бк можно вызвать на выполнение

Простейший пример: использование бк для ф-ии dbEval(<бк для выполнение>, <бк-фильтр по базе>)

Пример 1. К-во записей с положительным полем Sum

nk:=0
dbEval({|| nk++}, {|| Summa > 0})


Пример 2. К-во записей с отрицательным полеи полем Sum

nk:=0
dbEval({|| nk++}, {|| Summa < 0})

Пример с параметрами: построение графика

b2 := {|n| n**2}
b3 := {|n| n**3}
b4 := {|n| Sin(n)}

Graf(b1, 1, 10)
Graf(b2, 1, 10)
Graf(b3, 1, 10)

retu

func Graf(bk, n1, n2)
Local n
for n := n1 to n2
? n, Eval(bk, n)
next
retu nil

 Отправлено: 31.05.07 11:45. Заголовок: Re:

Еще по теме
http://www.spb4plus.ru/modules/myarticles/article.php?storyid=2

 Отправлено: 31.05.07 12:17. Заголовок: Re:

Всем огромное спасибо.

 Отправлено: 31.05.07 13:49. Заголовок: Re:

Вообще-то, что такое EVAL()? Это есть вычислить выражение. EVAL() вычисляет выражение, которое, как известно может быть списком выражений, передавая ему параметры если требуется.
Блок кода - это параметризированное выражение. В этом состоит его ценность.

Например, у вас есть выражение в виде единственной функции F(x).
В коде программы вы могли бы написать просто

F( a )

если к моменту вычисления выражения вам было бы точно известно, что x будет равен значению a. А ечли вы заранее не знаете, каким будет значение x, и само выражение надо использовать в нескольких местах кода программы, то упростить это можно было бы с помощью параметризованного выражения.
Вы оформляете свео выражение следующим образом
{ | x | F( x ) }
Теперь это параметризованное выражение вы можете использовать в любом месте программы, передавая ему в качестве аргумента выражения конкретное значение, то есть получим

EVAL( { |x| F( x ) }, a )

Выгода в том. что вы само выражение можете обозначить именем какой-нибудь переменной, например,

bExp = { |x| F( x ) }

И затем вместо самого выражения, которое может быть порой очень громоздким, использовать переменную

EVAL( bExp, a )

Еще одно достоинство состоит в том, что теперь вы можете само это параметризованное выражение передавать в качестве параметра другим функциям и процедурам, а внутри этих функций и процедур вычислить выражение со своими, существующими только в этих функциях или процедурах значениями.

Например,

G( bExp )

FUNCTION G( bExp )
LOCAL x

x = 10

EVAL( bExp, x )
...

RETURN NIL

 Отправлено: 01.06.07 09:10. Заголовок: Re:

Т.е. блок кода - это вроде переменной типа "функция", имеющейся в некоторых языках (напр., в старом добром PL/1), только лучше, т.к. простые блоки можно описать без применения функций, а сложные обычно (в т.ч. для читабельности) содержат вызов функции, специально для этого написанной.