方案：如果条件有多个过程

Question

我想弄清楚如何让我的 if 语句执行多项任务，但只执行 return 一件事，如果这有意义的话。另外，我不知道如何在同一行中打印一个字符串和一个变量。

比如scheme中这样的事情你会怎么做（以下是java）

if(num < x){
  num++;
  x = 0;
  System.out.println("The value of x is " + x " and num is now" + num);
}

其他 System.out.println("error");

这是我尝试过的：

(if (< num x) 
( (define num (+ 1 num))
   (define x 0)
   ;idk how to print it
   )
"error";else
)

Answer 1

我没有 java 方面的经验，但我想这就是你要找的东西

class IfElseDemo {
public static void main(String[] args) {

    int testscore = 76;
    char grade;

    if (testscore >= 90) {
        grade = 'A';
    } else if (testscore >= 80) {
        grade = 'B';
    } else if (testscore >= 70) {
        grade = 'C';
    } else if (testscore >= 60) {
        grade = 'D';
    } else {
        grade = 'F';
    }
    System.out.println("Grade = " + grade);
}

}

详情看这里：

https://docs.oracle.com/javase/tutorial/java/nutsandbolts/if.html

Why does this code not work as intended?

Answer 2

您可以使用begin来评估一系列表达式的效果， return 最后一个。您也可以使用 printf 来打印：

(if (< num x)
    (begin
      (set! num (add1 num))
      (set! x 0)
      (printf "The value of x is ~a and num is now ~a\n" x num))
    "error")

但是请记住，使用 set! 破坏（变异）变量在球拍中不鼓励。最好 return 新值。这个很难（硬向您展示如何做到这一点，在这里，没有一个稍微大一点的例子和更多上下文。无论如何，如果你有兴趣，那应该是这里有它自己的新问题。

Answer 3

首先我会说我不确定你想要你的代码做什么，因为我不知道 java。

不过我可以说的是，内部定义表达式肯定会让您感到困惑。在 racket 中，您通常不能在表达式中定义全局变量，而是创建一个具有以下形式的局部绑定：

(let ([identifier expression]
        ...
        [id-n expression-n])
    body-expressions)

通过它使用指定的绑定计算主体表达式，最后一个绑定 returned 作为整个 let 表达式的结果。这是做多件事和 return 一个结果的一种方法。在 (if test consequent alternative)

的上下文中

语句您可以使用 (begin expression...) 形式将多个表达式组合在一起（例如作为结果），它执行所有表达式并且 return 是最后一个表达式的结果。另一种方法是使用 cond 表达式，其形式为：

(cond [test conequents]
        ...
        [test-n cons-n]
        [else expression])

每个这样的测试都可以有多个结果，所以这可能比使用多个开始更清楚。

另外，如果你真的想改变 num 和 x 的值，你可以使用 (set! id value) 过程，但这对于球拍来说是不合常理的，因为函数递归形式是首选。

超越这些点需要我进行一些猜测，但看起来您正在一个函数中工作，该函数接受两个参数 x 和 num，并且想要递增 num 直到它达到 x 的值，打印这些值一路上的 x 和 num，如果给定的 x 值大于 num，你想要 return 一个错误

在球拍中你可以像这样递归地做这个：

(define inc-print ;defining inc-print
  (lambda (x num) ;a function of two arguments
    (cond [(> num x) "error"]
          [(< num x)
           ;the printf command takes a string and prints it.
           ;you can add values to the string by inserting ~a's followed by as many
           ;expressions as ~a's
           ;\n is shorthand for (newline) so that subsequent calls to printf print on a newline
           (printf "The value of x is ~a and num is now ~a\n" x num)
           ;a recursive call to inc-print with num incremented by 1 and x the same
           (inc-print x (+ num 1))]
          [else num])))

示例：

> (inc-print 5 2)
The value of x is 5 and num is now 2
The value of x is 5 and num is now 3
The value of x is 5 and num is now 4
5

如果这回答了您的问题，请告诉我！

Answer 4

如果要合并 if 和 define，可以使用 let。这很常见，所以 cond 让整个事情变得更简单：

(if (< num x) 
    (let () ; use let in order to use define in an expression context
      (define num (+ 1 num))
      (define x 0)
      (displayln (list 'num num 'x x))
      x)
    (displayln "error"))

(cond
  [(< num x) (define num (+ 1 num))
             (define x 0)
             (displayln (list 'num num 'x x))
             x]
  [else     (displayln "error")])

Answer 5

首先。您可以在 Scheme 中使用 display 向终端显示文本，在 #!racket 中您可以使用 displayln 以及 lot of other more specialized procedures。

在java（以及许多其他C descendants/dialects）中，if 的格式几乎与Scheme 中的相同：

if ( x < 3 )
    return 0;
else
    return 10;

在 Scheme 中它看起来非常相似：

(if (< x 3)
    0
    10)

如果您需要在需要一个语句的地方做更多的事情，您需要将它们分组。在 Java（和所有 C 后代）中，我们通过用 {} 将许多语句组合成一个。例如：

{
    System.out.println("Side effect " + localVar);
    return 10;
}

以上是任何允许声明的地方的有效块。在 Scheme 中，你用 begin

表示块

(begin (display "Side effect\n")
       10)

据说程序体和 let 形式具有显式 begin。这意味着它允许不止一种表达。不过，只有尾部表达式被认为是 "return"。

许多特殊形式在 Scheme 中都有明确的 begin。你在 Java 中没有那个，因为在那些情况下你需要使用卷曲。示例是程序的主体：

(lambda (arg)
  (define test 10) ; one expression
  (+ test arg))    ; another expression

let、let*、letrec、...只是匿名过程调用，因此它们的主体继承了 lambda 的显式开头。在 cond 后果和备选方案中你有它们：

(cond ((hash-ref hash test) #f)
      ((> test 10) (hash-set! hash test #t) #t)    ; two expressions consequent
      (else        (hash-set! hash test #t) test)) ; two expressions alternative

cond通常是转换为if的宏。它们之间的区别在于隐含的 begin 并且它支持多个术语。因此，在需要显式开始或代替嵌套 ìf 的地方使用 cond 很不错。结果是更扁平的可读性更强的代码。上面的cond可以这样写 if:

(if (hash-ref hash test) 
    #f
    (if (> test 10)
        (begin  
          (hash-set! hash test #t) ; one expression
          #t)                      ; another expression (tail)
        (begin 
          (hash-set! hash test #t) ; one expression
          test)))                  ; another expression (tail)

如您所见，cond 更紧凑，如果您熟悉 Scheme，它更容易阅读。拥有正确的标识非常重要，因此使用 IDE 可以帮助您编写其他策划者可以阅读的代码。由于您标记了 racket，您可以使用 DrRacket 并经常按 CTRL + i。

Answer 6

我意识到我迟到了 7 年，但是因为我有同样的挣扎才遇到这个问题。我正在使用 Guile，我查看了手册并发现了这个：

When you go to write an ‘if’ without an alternate (a “one-armed ‘if’”), part of what you are expressing is that you don’t care about the return value (or values) of the expression. As such, you are more interested in the effect of evaluating the consequent expression. (By convention, we use the word “statement” to refer to an expression that is evaluated for effect, not for value).

In such a case, it is considered more clear to express these intentions with these special forms, ‘when’ and ‘unless’. As an added bonus, these forms accept multiple statements to evaluate, which are implicitly wrapped in a ‘begin’.

因此，您可以

而不是像其他答案建议的那样使用 if 或 cond

(when (< num x)          ;; if (num < x) {
  (set! num (+ num 1))   ;;   num++;
  (set! x 0)             ;;   x = 0;
  (display "..."))       ;;   print("...");
                         ;; }

方案：如果条件有多个过程

Scheme: if condition with multiple procedures

printing

scheme

if-statement

racket