User Input: Difference between revisions
Content added Content deleted
(Markup fix) |
m (fixed redirect since multiple redirects aren't followed) |
||
(10 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|Slate}}== |
|||
<lang slate> |
|||
print: (query: 'Enter a String: '). |
|||
</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: