Question

我试图找出如何让我的if语句执行多个任务，但只返回一件事，如果这是有道理的。另外，我不知道如何在同一行中打印一个字符串和一个变量。

例如，你如何在方案中做这样的事情（以下是java）

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

否则的System.out.println（ “错误”）;

以下是我的尝试：

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

Answer 1

您可以使用begin来评估一系列效果表达式，并返回最后一个。您也可以使用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!来修改（mutate）变量在Racket中不鼓励。返回新值更好。这很难告诉你如何做到这一点，在这里，没有一个稍大的例子更多背景。无论如何，如果你有兴趣，应该是这里有自己的新问题。

Answer 2

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

我可以说的是，内部定义表达式肯定会让你失望。在球拍中，您通常无法在表达式中定义全局变量，而是使用以下形式创建局部绑定：

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

使用指定的绑定计算正文表达式，最后一个作为整个let表达式的结果返回。这是做多件事并返回一个结果的一种方法。在(if test consequent alternative)

的上下文中

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

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

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

另外，如果你真的想改变num和x的值，你会使用(set! id value) 程序，但这对球拍来说是单一的，因为功能递归形式是首选。

超出这些要求我需要做一些猜测，但看起来你正在一个带有两个参数x和num的函数中工作，并希望增加num直到达到x的值，打印x的值和途中的num，如果给出大于num的x值，你想要返回一个错误

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

(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 3

我没有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 4

如果要合并let和if，可以使用define。这是非常常见的，因此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后代/方言）中，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。这意味着它允许多个表达式。只有尾部表达被认为是“返回”。

许多特殊形式在Scheme中都有明确的begin。你没有在Java中使用它，因为在这种情况下你需要使用curlies。例子是程序的主体：

(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的宏。它们之间的区别在于隐式开头，它支持多个术语。因此，在需要显式开头或代替嵌套cond的地方使用ìf时很高兴。结果是更易读的代码更平坦。上面的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 。

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

5 个答案: