User Input: Difference between revisions

From Rosetta Code
Content added Content deleted
(→‎{{header|Common Lisp}}: (read-from-string (read-line)) => (read), don't swallow errors, clarify text prompt)
m (fixed redirect since multiple redirects aren't followed)
 
(12 intermediate revisions by 6 users not shown)
Line 1: Line 1:
#REDIRECT [[User input/Text]]
{{task|Text processing}}[[Category:Basic language learning]]In this task, the goal is to input a string and the integer 75000, from the normal user interface.

=Text Terminal=

=={{header|Ada}}==
{{works with|GCC|4.1.2}}
<lang ada>
function Get_String return String is
Line : String (1 .. 1_000);
Last : Natural;
begin
Get_Line (Line, Last);
return Line (1 .. Last);
end Get_String;
function Get_Integer return Integer is
S : constant String := Get_String;
begin
return Integer'Value (S);
-- may raise exception Constraint_Error if value entered is not a well-formed integer
end Get_Integer;
</lang>
The functions above may be called as shown below
<lang ada>
My_String : String := Get_String;
My_Integer : Integer := Get_Integer;
</lang>

=={{header|ALGOL 68}}==
print("Enter a string: ");
STRING s := read string;
print("Enter a number: ");
INT i := read int;
~
=={{header|AutoHotkey}}==
There are a few ways to input with AutoHotkey.
===InputBox===
<lang AutoHotkey>InputBox, String, Input, Enter a string:
InputBox, Int, Input, Enter an int:
Msgbox, You entered "%String%" and "%Int%"</lang>
===Gui===
<lang AutoHotkey>Gui, Add, Text,, String:
Gui, Add, Text,, Int:
Gui, Add, Button, gGo, Go!
Gui, Add, Edit, vString ym
Gui, Add, Edit, VInt
Gui, Show, Center, Input
Return

Go:
Gui, Submit, NoHide
Msgbox, You entered "%String%" and "%Int%"
ExitApp
Return</lang>
===Input Command===
<lang AutoHotkey>TrayTip, Input:, Type a string:
Input(String)
TrayTip, Input:, Type an int:
Input(Int)
TrayTip, Done!, Input was recieved.
Msgbox, You entered "%String%" and "%Int%"
ExitApp
Return

Input(ByRef Output)
{
Loop
{
Input, Char, L1, {Enter}{Space}
If ErrorLevel contains Enter
Break
Else If ErrorLevel contains Space
Output .= " "
Else
Output .= Char
TrayTip, Input:, %Output%
}
}</lang>

=={{header|AWK}}==
This demo shows a same-line prompt, and that the integer i becomes 0 if the line did not parse as an integer.
<lang awk>
~/src/opt/run $ awk 'BEGIN{printf "enter a string: "}{s=$0;i=$0+0;print "ok,"s"/"i}'
enter a string: hello world
ok,hello world/0
75000
ok,75000/75000
</lang>

=={{header|BASIC}}==
{{works with|QuickBasic|4.5}}
INPUT "Enter a string: ", s$
INPUT "Enter a number: ", i%

{{works with|FreeBASIC}}
dim s as string
dim i as integer
input "Enter a string: ", s
input "Enter the integer 75000: ", i

=={{header|Befunge}}==
This prompts for a string and pushes it to the stack a character at a time ('''~''') until end of input (-1).
<>:v:"Enter a string: "
^,_ >~:1+v
^ _@

Numeric input is easier, using the '''&''' command.
<>:v:"Enter a number: "
^,_ & @

=={{header|C}}==
{{works with|gcc}}
<lang c> #include <stdio.h>
int main(int argc, char* argv[])
{
int input;
if((scanf("%d", &input))==1)
{
printf("Read in %d\n", input);
return 1;
}
return 0;
}</lang>

=={{header|C++}}==
{{works with|g++}}
<lang cpp> #include <iostream>
#include <istream>
#include <ostream>
#include <string>
using namespace std;
int main()
{
// while probably all current implementations have int wide enough for 75000, the C++ standard
// only guarantees this for long int.
long int integer_input;
string string_input;
cout << "Enter an integer: ";
cin >> integer_input;
cout << "Enter a string: ";
cin >> string_input;
return 0;
}</lang>

Note: The program as written above only reads the string up to the first whitespace character. To get a complete line into the string, replace
<lang cpp> cin >> string_input;</lang>
with
<lang cpp> readline(cin, string_input);</lang>

=={{header|C sharp|C#}}==
<lang csharp> using System;
namespace C_Sharp_Console {
class example {
static void Main() {
string word;
int num;
Console.Write("Enter an integer: ");
num = Console.Read();
Console.Write("Enter a String: ");
word = Console.ReadLine();
}
}
}</lang>

=={{header|Clojure}}==
<lang clojure>(import '(java.util Scanner))
(def scan (Scanner. *in*))
(def s (.nextLine scan))
(def n (.nextInt scan))
</lang>

=={{header|Common Lisp}}==
<lang lisp>(format t "Enter some text: ")
(let ((s (read-line)))
(format t "You entered ~s~%" s))

(format t "Enter a number: ")
(let ((n (read)))
(if (numberp n)
(format t "You entered ~d.~%" n)
(format t "That was not a number.")))</lang>

=={{header|D}}==
<lang D>import tango.io.Console;
import Integer = tango.text.convert.Integer;

void main() {
int num;
char[] word;
Cout("Enter an integer:")();
num = Integer.parse(Cin.get());
Cout("Enter a string:")();
word = Cin.get();
}</lang>


=={{header|Erlang}}==
<lang erlang> {ok, [String]} = io:fread("Enter a string: ","~s").
{ok, [Number]} = io:fread("Enter a number: ","~d").</lang>

Alternatively, you could use io:get_line to get a string:
<lang erlang> String = io:get_line("Enter a string: ").</lang>

=={{header|FALSE}}==
FALSE has neither a string type nor numeric input. Shown instead are routines to parse and echo a word and to parse and interpret a number using the character input command (^).
[[^$' =~][,]#,]w:
[0[^'0-$$9>0@>|~][\10*+]#%]d:
w;! d;!.

=={{header|Forth}}==
===Input a string===

<lang forth> : INPUT$ ( n -- addr n )
PAD SWAP ACCEPT
PAD SWAP ;</lang>

===Input a number===
The only ANS standard number interpretation word is >NUMBER ( ud str len -- ud str len ), which is meant to be the base factor for more convenient (but non-standard) parsing words.
<lang forth> : INPUT# ( -- u true | false )
0. 16 INPUT$ DUP >R
>NUMBER NIP NIP
R> <> DUP 0= IF NIP THEN ;</lang>

{{works with|GNU Forth}}
<lang forth> : INPUT# ( -- n true | d 1 | false )
16 INPUT$ SNUMBER? ;</lang>

{{works with|Win32Forth}}
<lang forth> : INPUT# ( -- n true | false )
16 INPUT$ NUMBER? NIP
DUP 0= IF NIP THEN ;</lang>

Note that NUMBER? always leaves a double result on the stack.
INPUT# returns a single precision number. If you desire a double precision result, remove the NIP.

Here is an example that puts it all together:

<lang forth> : TEST
." Enter your name: " 80 INPUT$ CR
." Hello there, " TYPE CR
." Enter a number: " INPUT# CR
IF ." Your number is " .
ELSE ." That's not a number!" THEN CR ;</lang>

=={{header|Groovy}}==
<lang groovy> word = System.in.readLine()
num = System.in.readLine().toInteger()</lang>

=={{header|Haskell}}==
<lang haskell> main = do
putStr "Enter a string: "
str <- getLine
putStr "Enter an integer: "
num <- readLn :: IO Int
putStrLn $ str ++ (show num)</lang>
Note: <tt>:: IO Int</tt> is only there to disambiguate what type we wanted from <tt>read</tt>. If <tt>num</tt> were used in a numerical context, its type would have been inferred by the interpreter/compiler.

=={{header|Java}}==
<lang java> import java.io.BufferedReader;
import java.io.InputStreamReader;
public class GetInput {
public static void main(String[] args) throws Exception {
BufferedReader sysin = new BufferedReader(new InputStreamReader(System.in));
int number = Integer.parseInt(sysin.readLine());
String string = sysin.readLine();
}
}</lang>

or

{{works with|Java|1.5/5.0+}}
<lang java> import java.util.Scanner;
Scanner stdin = new Scanner(System.in);
String string = stdin.nextLine();
int number = stdin.nextInt();</lang>

=={{header|Logo}}==
Logo literals may be read from a line of input from stdin as either a list or a single word.
<lang logo> make "input readlist ; in: string 75000
show map "number? :input ; [false true]
make "input readword ; in: 75000
show :input + 123 ; 75123
make "input readword ; in: string 75000
show :input ; string 75000</lang>

=={{header|Metafont}}==

<lang metafont>string s;
message "write a string: ";
s := readstring;
message s;
message "write a number now: ";
b := scantokens readstring;
if b = 750:
message "You've got it!"
else:
message "Sorry..."
fi;
end</lang>

If we do not provide a number in the second input, Metafont will complain. (The number 75000 was reduced to 750 since Metafont biggest number is near 4096).

=={{header|mIRC Scripting Language}}==
alias askmesomething {
echo -a You answered: $input(What's your name?, e)
}

=={{header|Modula-3}}==
<lang modula3>MODULE Input EXPORTS Main;

IMPORT IO, Fmt;

VAR string: TEXT;
number: INTEGER;

BEGIN
IO.Put("Enter a string: ");
string := IO.GetLine();
IO.Put("Enter a number: ");
number := IO.GetInt();
IO.Put("You entered: " & string & " and " & Fmt.Int(number) & "\n");
END Input.
</lang>

=={{header|newLISP}}==
{{works with|newLISP|9.0}}
(print "Enter an integer: ")
(set 'x (read-line))
(print "Enter a string: ")
(set 'y (read-line))

=={{header|OCaml}}==
<lang ocaml>print_string "Enter a string: ";
let str = read_line () in
print_string "Enter an integer: ";
let num = read_int () in
Printf.printf "%s%d\n" str num</lang>

=={{header|Octave}}==

<lang octave>% read a string ("s")
s = input("Enter a string: ", "s");

% read a GNU Octave expression, which is evaluated; e.g.
% 5/7 gives 0.71429
i = input("Enter an expression: ");

% parse the input for an integer
printf("Enter an integer: ");
ri = scanf("%d");

% show the values
disp(s);
disp(i);
disp(ri);</lang>


=={{header|Pascal}}==

<lang pascal> program UserInput(input, output);
var i : Integer;
s : String;
begin
write('Enter an integer: ');
readln(i);
write('Enter a string: ');
readln(s)
end.</lang>

=={{header|Perl}}==
{{works with|Perl|5.8.8}}
<lang perl> #!/usr/bin/perl
my $string = <>; # equivalent to readline(*STDIN)
my $integer = <>;</lang>

=={{header|PHP}}==
{{works with|CLI SAPI}}
<lang php> #!/usr/bin/php
<?php
$string = fgets(STDIN);
$integer = (int) fgets(STDIN);</lang>

=={{header|Pop11}}==
<lang pop11> ;;; Setup item reader
lvars itemrep = incharitem(charin);
lvars s, c, j = 0;
;;; read chars up to a newline and put them on the stack
while (charin() ->> c) /= `\n` do j + 1 -> j ; c endwhile;
;;; build the string
consstring(j) -> s;
;;; read the integer
lvars i = itemrep();</lang>

=={{header|PostScript}}==
{{works with|PostScript|level-2}}
<lang postscript> %open stdin for reading (and name the channel "kbd"):
/kbd (%stdin) (r) file def
%make ten-char buffer to read string into:
/buf (..........) def
%read string into buffer:
kbd buf readline</lang>

At this point there will be two items on the stack: a boolean which is "true" if the read was successful and the string that was read from the kbd (input terminates on a <return>). If the length of the string exceeds the buffer length, an error condition occurs (rangecheck). For the second part, the above could be followed by this:

<lang postscript> %if the read was successful, convert the string to integer:
{cvi} if</lang>

which will read the conversion operator 'cvi' (convert to integer) and the boolean and execute the former if the latter is true.

=={{header|PowerShell}}==

$string = Read-Host "Input a string"
$number = Read-Host "Input a number"

=={{header|Python}}==
===Input a string===
<lang python> string = raw_input("Input a string: ")</lang>
In Python 3.0, raw_input will be renamed to input(). The Python 3.0 equivalent would be
<lang python> string = input("Input a string: ")</lang>
===Input a number===
While input() gets a string in Python 3.0, in 2.x it is the equivalent of eval(raw_input(...)). Because this runs arbitrary code, and just isn't nice, it is being removed in Python 3.0. raw_input() is being changed to input() because there will be no other kind of input function in Python 3.0.
<lang python> number = input("Input a number: ") # Deprecated, please don't use.</lang>
Python 3.0 equivalent:
<lang python> number = eval(input("Input a number: ")) # Evil, please don't use.</lang>
The preferred way of getting numbers from the user is to take the input as a string, and pass it to any one of the numeric types to create an instance of the appropriate number.
<lang python> number = float(raw_input("Input a number: "))</lang>
Python 3.0 equivalent:
<lang python> number = float(input("Input a number: "))</lang>
float may be replaced by any numeric type, such as int, complex, or decimal.Decimal. Each one varies in expected input.

=={{header|Raven}}==
<lang raven> 'Input a string: ' print expect as str
'Input an integer: ' print expect 0 prefer as num</lang>

=={{header|Ruby}}==
{{works with|Ruby|1.8.4}}
<lang ruby> print "Enter a string: "
s = gets
print "Enter an integer: "
i = gets.to_i # If string entered, will return zero
puts "String = " + s
puts "Integer = " + i.to_s</lang>

=={{header|Scheme}}==
The <tt>read</tt> procedure is R5RS standard, inputs a scheme representation so, in order to read a string, one must enter <tt>"hello world"</tt>
<lang scheme> (define str (read))
(define num (read))
(display "String = ") (display str)
(display "Integer = ") (display num)</lang>

=={{header|Standard ML}}==
<lang sml>print "Enter a string: ";
let val str = valOf (TextIO.inputLine TextIO.stdIn) in (* note: this keeps the trailing newline *)
print "Enter an integer: ";
let val num = valOf (TextIO.scanStream (Int.scan StringCvt.DEC) TextIO.stdIn) in
print (str ^ Int.toString num ^ "\n")
end
end</lang>

=={{header|Tcl}}==
Like LISP, there is no concept of a "number" in TCL - the only real variable type is a string (whether a string might represent a number is a matter of interpretation of the string in a mathematical expression at some later time). Thus the input is the same for both tasks:

<lang tcl> set str [gets stdin]
set num [gets stdin]</lang>

possibly followed by something like

<lang tcl> if {![string is integer $num]} then { ...do something here...}</lang>

If the requirement is to prompt until the user enters the integer 75000, then:

<lang tcl>set input 0
while {$input != 75000} {
puts -nonewline "enter the number '75000': "
flush stdout
set input [gets stdin]
}</lang>

=={{header|Toka}}==
needs readline
." Enter a string: " readline is-data the-string
." Enter a number: " readline >number [ ." Not a number!" drop 0 ] ifFalse is-data the-number

the-string type cr
the-number . cr

=={{header|UNIX Shell}}==
{{works with|Debian Almquish SHell}}
#!/bin/sh
read STRING
read INTEGER
{{works with|Bourne Again SHell}}
#!/bin/bash
read STRING
read INTEGER

=={{header|Vedit macro language}}==
Get_Input(1, "Enter a string: ")
#2 = Get_Num("Enter a number: ")

=={{header|Visual Basic .NET}}==
'''Platform:''' [[.NET]]

{{works with|Visual Basic .NET|9.0+}}

===Input an Integer===
<lang vbnet>Dim i As Integer
Console.WriteLine("Enter an Integer")
i = Console.ReadLine()</lang>

===Input an Integer With Error Handling===
<lang vbnet>Dim i As Integer
Dim iString As String
Console.WriteLine("Enter an Integer")
iString = Console.ReadLine()
Try
i = Convert.ToInt32(iString)
Catch ex As Exception
Console.WriteLine("This is not an Integer")
End Try</lang>

===Input a String===
<lang vbnet>Dim i As String
Console.WriteLine("Enter a String")
i = Console.ReadLine()</lang>

=GUI=

=={{header|AppleScript}}==
set input to text returned of (display dialog "Enter text:" default answer "")

set input to text returned of (display dialog "Enter a number:" default answer "") as integer

=={{header|Java}}==
{{libheader|Swing}}

<lang java> import javax.swing.*;
public class GetInputSwing {
public static void main(String[] args) throws Exception {
int number = Integer.parseInt(JOptionPane.showInputDialog ("Enter an Integer"));
String string = JOptionPane.showInputDialog ("Enter a String");
}
}</lang>

=={{header|Python}}==
{{works with|Python|2.5}}
{{libheader|Tkinter}}

<lang python> import tkSimpleDialog
number = tkSimpleDialog.askinteger("Integer", "Enter a Number")
string = tkSimpleDialog.askstring("String", "Enter a String")</lang>

=={{header|Tcl}}==
===Getting Input via a GUI===
{{libheader|Tk}}
<lang tcl># create entry widget:
pack [entry .e1]

# read its content:
set input [.e get]</lang>

Alternatively, the content of the widget can be tied to a variable:
<lang tcl>pack [entry .e1 -textvar input]

# show the content at any time by
puts $input</lang>
The <tt>-validate</tt> option can be used to test the contents/edits of the widget at any time against any parameters (including testing <tt>string is integer</tt> when the user hits <Return> or such)

===Getting Input from the Command Line===
You can also just work with sending requests for information to the user's terminal...
<lang tcl>proc question {var message} {
upvar 1 $var v
puts -nonewline "$message: "
flush stdout
gets stdin $v
}
question name "What is your name"
question task "What is your quest"
question doom "What is the air-speed velocity of an unladen swallow"</lang>

=={{header|VBScript}}==
{{works with|Windows Script Host}}
strUserIn = InputBox("Enter Data")
Wscript.Echo strUserIn

=={{header|Vedit macro language}}==
Displays a dialog box with two input fields and default OK button. The values entered are stored in text registers 1 and 2.
The value from 2nd field is then converted into numeric value. (Accepts integers or integer expressions.)

Dialog_Input_1(1, "`User Input example`,
`??Enter a string `,
`??Enter a number `")
#2 = Num_Eval_Reg(2)

Latest revision as of 08:32, 2 July 2010

Redirect to:

Retrieved from "https://rosettacode.org/wiki/User_Input?oldid=1273"