User Input: Difference between revisions

=={{header|C sharp|C#}}==

namespace C_Sharp_Console {

}

}

=={{header|Erlang}}==

Alternatively, you could use io:get_line to get a string:

=={{header|Forth}}==

===Input a string===

PAD SWAP ACCEPT

===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.

0. 16 INPUT$ DUP >R

>NUMBER NIP NIP

{{works with|GNU Forth}}

{{works with|Win32Forth}}

16 INPUT$ NUMBER? NIP

Note that NUMBER? always leaves a double result on the stack.

Here is an example that puts it all together:

." Enter your name: " 80 INPUT$ CR

." Hello there, " TYPE CR

." Enter a number: " INPUT# CR

IF ." Your number is " .

=={{header|Groovy}}==

=={{header|Haskell}}==

putStr "Enter a string: "

str <- getLine

putStr "Enter an integer: "

num <- readLn :: IO Int

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}}==

import java.io.InputStreamReader;

String string = sysin.readLine();

}

or

{{works with|Java|1.5/5.0+}}

Scanner stdin = new Scanner(System.in);

String string = stdin.nextLine();

=={{header|Logo}}==

Logo literals may be read from a line of input from stdin as either a list or a single word.

show map "number? :input ; [false true]

show :input + 123 ; 75123

make "input readword ; in: string 75000

=={{header|mIRC Scripting Language}}==

=={{header|Modula-3}}==

MODULE Input EXPORTS Main;

IO.Put("You entered: " & string & " and " & Fmt.Int(number) & "\n");

END Input.

=={{header|newLISP}}==

=={{header|Pascal}}==

var i : Integer;

s : String;

write('Enter a string: ');

readln(s)

=={{header|Perl}}==

{{works with|Perl|5.8.8}}

my $string = <>; # equivalent to readline(*STDIN)

=={{header|PHP}}==

{{works with|CLI SAPI}}

<?php

$string = fgets(STDIN);

=={{header|Pop11}}==

lvars itemrep = incharitem(charin);

lvars s, c, j = 0;

consstring(j) -> s;

;;; read the integer

=={{header|PostScript}}==

{{works with|PostScript|level-2}}

/kbd (%stdin) (r) file def

%make ten-char buffer to read string into:

/buf (..........) def

%read string into buffer:

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:

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

=={{header|Python}}==

===Input a string===

In Python 3.0, raw_input will be renamed to input(). The Python 3.0 equivalent would be

===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.

Python 3.0 equivalent:

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.

Python 3.0 equivalent:

float may be replaced by any numeric type, such as int, complex, or decimal.Decimal. Each one varies in expected input.

=={{header|Raven}}==

=={{header|Ruby}}==

{{works with|Ruby|1.8.4}}

s = gets

print "Enter an integer: "

i = gets.to_i # If string entered, will return zero

puts "String = " + s

=={{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>

(define num (read))

(display "String = ") (display str)

=={{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:

possibly followed by something like

=={{header|Toka}}==

{{libheader|Tkinter}}

number = tkSimpleDialog.askinteger("Integer", "Enter a Number")

=={{header|Tcl}}==

{{libheader|Tk}}

pack [entry .e1]

# read its content:

Alternatively, the content of the widget can be tied to a variable:

# show the content at any time by

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)