Terminal Input (GNU Octave (version 11.0.90))

#### 14.1.2 Terminal Input ¶

Octave has three functions that make it easy to prompt users for input. The `input` and `menu` functions are normally used for managing an interactive dialog with a user, and the `keyboard` function is normally used for doing simple debugging.

`ans =` input `(prompt)` ¶
`ans =` input `(prompt, "s")` ¶

  Print prompt and wait for user input.

  For example,

      input ("Pick a number, any number! ")

  prints the prompt

      Pick a number, any number!

  and waits for the user to enter a value. The string entered by the user is evaluated as an expression, so it may be a literal constant, a variable name, or any other valid Octave code.

  The number of return arguments, their size, and their class depend on the expression entered.

  If you are only interested in getting a literal string value, you can call `input` with the character string `"s"` as the second argument. This tells Octave to return the string entered by the user directly, without evaluating it first.

  Because there may be output waiting to be displayed by the pager, it is a good idea to always call `fflush (stdout)` before calling `input`. This will ensure that all pending output is written to the screen before your prompt.

  See also: yes_or_no, kbhit, pause, menu, listdlg.

`choice =` menu `(title, opt1, …)` ¶
`choice =` menu `(title, {opt1, …})` ¶

  Display a menu with heading title and options opt1, …, and wait for user input.

  If the GUI is running, the menu is displayed graphically using `listdlg`. Otherwise, the title and menu options are printed on the console.

  title is a string and the options may be input as individual strings or as a cell array of strings.

  The return value choice is the number of the option selected by the user counting from 1. If the user aborts the dialog or makes an invalid selection then 0 is returned.

  This function is useful for interactive programs. There is no limit to the number of options that may be passed in, but it may be confusing to present more than will fit easily on one screen.

  See also: input, listdlg.

`ans =` yes_or_no `("prompt")` ¶

  Ask the user a yes-or-no question.

  Return logical true if the answer is yes or false if the answer is no.

  Takes one argument, prompt, which is the string to display when asking the question. prompt should end in a space; `yes-or-no` adds the string ‘`(yes or no)` ’ to it. The user must confirm the answer with `RET` and can edit it until it has been confirmed.

  See also: input.

For `input`, the normal command line history and editing functions are available at the prompt.

Octave also has a function that makes it possible to get a single character from the keyboard without requiring the user to type a carriage return.

`c =` kbhit `()` ¶
`c =` kbhit `(1)` ¶

  Read a single keystroke from the keyboard.

  If called with an argument (typically 1), don’t wait for a keypress and immediately return the next keystroke in the keyboard input buffer or an empty string ("") if no keystroke is available.

  For example,

      c = kbhit ();

  will set c to the next character typed at the keyboard as soon as it is typed.

      c = kbhit (1);

  is identical to the above example, but doesn’t wait for a keypress, returning the empty string if no key is available.

  See also: input, pause.