User input/Text: Difference between revisions

 

See also: [[User input/Graphical]]

=={{header|Ada}}==

{{works with|GCC|4.1.2}}

Line : String (1 .. 1_000);

Last : Natural;

-- may raise exception Constraint_Error if value entered is not a well-formed integer

end Get_Integer;

 

The functions above may be called as shown below

 

=={{header|ALGOL 68}}==

STRING s := read string;

print("Enter a number: ");

INT i := read int;

=={{header|AutoHotkey}}==

===Windows console===

FileAppend, please type something`n, CONOUT$

FileReadLine, line, CONIN$, 1

FileAppend, please type '75000'`n, CONOUT$

FileReadLine, line, CONIN$, 1

 

===Input Command===

this one takes input regardless of which application has focus.

Input(String)

TrayTip, Input:, Type an int:

TrayTip, Input:, %Output%

}

 

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

enter a string: hello world

ok,hello world/0

75000

 

=={{header|BASIC}}==

 

 

This isn't a hard-and-fast rule -- for example, [[Chipmunk Basic]] ''never'' appends a question mark.

 

 

Output ([[QBasic]]):

Enter a string? foo

Enter a number: 1

 

=={{header|BBC BASIC}}==

INPUT "Enter a number: " number

PRINT "String = """ string$ """"

 

=={{header|Befunge}}==

This prompts for a string and pushes it to the stack a character at a time ('''~''') until end of input (-1).

^,_ >~:1+v

 

Numeric input is easier, using the '''&''' command.

 

=={{header|C}}==

{

}

 

=={{header|C++}}==

{{works with|g++}}

#include <string>

using namespace std;

cin >> string_input;

return 0;

 

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

with

 

Note: if a numeric input operation fails, the value is not stored for that operation, plus the ''fail bit'' is set, which causes all future stream operations to be ignored (e.g. if a non-integer is entered for the first input above, then nothing will be stored in either the integer and the string). A more complete program would test for an error in the input (with <code>if (!cin) // handle error</code>) after the first input, and then clear the error (with <code>cin.clear()</code>) if we want to get further input.

Alternatively, we could read the input into a string first, and then parse that into an int later.

 

 

=={{header|Clojure}}==

(def scan (Scanner. *in*))

(def s (.nextLine scan))

 

=={{header|Common Lisp}}==

(let ((s (read-line)))

(format t "You entered ~s~%" s))

(if (numberp n)

(format t "You entered ~d.~%" n)

 

=={{header|D}}==

void main() {

writeln("Read in '", number, "' and '", str, "'");

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

Writeln('Invalid entry: ' + s);

until lIntegerValue = 75000;

 

=={{header|Erlang}}==

 

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

 

=={{header|Euphoria}}==

 

sequence s

puts(1, s & '\n')

n = prompt_number("Enter a number:",{})

 

=={{header|Factor}}==

readln

"Enter a number: " write

 

=={{header|Falcon}}==

str = input()

printl("Enter a number:")

 

=={{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 (^).

[0[^'0-$$9>0@>|~][\10*+]#%]d:

 

=={{header|Fantom}}==

The 'toInt' method on an input string will throw an exception if the input is not a number.

 

class Main

{

}

}

 

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

 

{{works with|4tH}}

begin

refill drop bl parse-word ( a n)

drop ( --)

repeat ( n)

 

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

{{works with|Fortran|90 and later}}

integer :: i

 

read*, s

print*, "Enter the integer 75000"

=={{header|Go}}==

Go has C-like Scan and Scanf functions for quick and dirty input:

 

import "fmt"

fmt.Println("wrong")

}

Code below allows much more control over interaction and error checking.

package main

 

fmt.Println("Good")

}

 

=={{header|Groovy}}==

 

=={{header|Haskell}}==

main = do

putStr "Enter a string: "

hFlush stdout

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.

Note also: Haskell doesn't automatically flush stdout when doing input, so explicit flushes are necessary.

 

=={{header|Icon}} and {{header|Unicon}}==

The following works in both Icon and Unicon:

 

procedure main ()

writes ("Enter something: ")

else write ("you must enter a number")

end

 

=={{header|Io}}==

 

=={{header|J}}==

'''Solution'''

prompt 'Enter string: '

'''Example Usage'''

Enter string: Hello World

Hello World

│Hello Rosetta Code│75000│

└──────────────────┴─────┘

 

=={{header|Java}}==

 

public class GetInput {

public static void main(String[] args) throws Exception {

}

 

or

 

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

 

public class GetInput {

int number = stdin.nextInt();

}

 

=={{header|JavaScript}}==

{{works with|JScript}} and only with <code>cscript.exe</code>

var str = WScript.StdIn.ReadLine();

 

WScript.Echo("Enter the integer 75000");

val = parseInt( WScript.StdIn.ReadLine() );

 

{{works with|SpiderMonkey}}

var str = readline();

 

print("Enter the integer 75000");

val = parseInt( readline() );

 

=={{header|Joy}}==

"Enter a string: " putchars

stdin fgets

"Enter a number: " putchars

stdin fgets 10 strtol.

 

=={{header|Kite}}==

System.file.stdout|write("Enter a String ");

string = System.file.stdin|readline();

 

=={{header|Liberty BASIC}}==

 

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

s = io.stdin:read()

print('Enter a number: ')

i = tonumber(io.stdin:read())

 

 

=={{header|MATLAB}}==

 

Sample usage:

Input string: 'Hello'

 

ans =

 

 

 

=={{header|Metafont}}==

 

message "write a string: ";

s := readstring;

message "Sorry..."

fi;

 

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

 

 

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

echo -a You answered: $input(What's your name?, e)

 

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

 

IMPORT IO, Fmt;

number := IO.GetInt();

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

=={{header|MUMPS}}==

NEW S,N

WRITE "Enter a string: "

READ N,!

KILL S,N

 

=={{header|Nemerle}}==

using System.Console;

 

} while ((!numeric) || (entry != 75000))

}

 

=={{header|newLISP}}==

{{works with|newLISP|9.0}}

(set 'x (read-line))

(print "Enter a string: ")

 

=={{header|Objeck}}==

use IO;

 

}

}

 

=={{header|OCaml}}==

let str = read_line () in

print_string "Enter an integer: ";

let num = read_int () in

 

=={{header|Octave}}==

 

s = input("Enter a string: ", "s");

 

disp(s);

disp(i);

 

=={{header|Oz}}==

StdIn = {New class $ from Open.file Open.text end init(name:stdin)}

StringInput

in

Num := try {String.toInt Line} catch _ then 0 end

 

=={{header|PARI/GP}}==

 

=={{header|Pascal}}==

 

var i : Integer;

s : String;

write('Enter a string: ');

readln(s)

 

=={{header|Perl}}==

 

 

 

=={{header|PHP}}==

{{works with|CLI SAPI}}

<?php

$string = fgets(STDIN);

 

=={{header|PicoLisp}}==

(let (Str (read) Num (read))

(prinl "The string is: \"" Str "\"")

 

=={{header|Pike}}==

write("Enter a String: ");

string str = Stdio.stdin->gets();

write("Enter 75000: ");

int num = Stdio.stdin->gets();

 

=={{header|PL/I}}==

declare k fixed decimal (15);

 

get list (k);

put skip list (k);

 

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

 

 

=={{header|PureBasic}}==

 

; Declare a string and a integer to be used

Define txt.s, num.i

Print("You made it!")

Delay(3000): CloseConsole()

 

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

{{works with|R|2.81}}

 

 

=={{header|Raven}}==

 

=={{header|REBOL}}==

Title: "Textual User Input"

URL: http://rosettacode.org/wiki/User_Input_-_text

]

; It always pays to be polite...

 

 

Output:

Thank you. Your string was 'Slert...'.</pre>

 

 

=={{header|Retro}}==

 

=={{header|Ruby}}==

{{works with|Ruby|1.8.4}}

s = gets

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

puts "String = #{s}"

 

=={{header|Scala}}==

print("Enter a string: ")

 

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

 

const proc: main is func

write("Enter a string: ");

readln(string_input);

 

=={{header|Slate}}==

[| n |

n: (Integer readFrom: (query: 'Enter an Integer: ')).

ifTrue: [print: n]

ifFalse: [inform: 'Not an integer: ' ; n printString]

 

=={{header|Smalltalk}}==

a := stdin nextLine asInteger.

 

'Enter a string: ' display.

 

=={{header|SNOBOL4}}==

str = trim(input)

output = "Enter an integer:"

int = trim(input)

output = "String: " str " Integer: " int

 

 

=={{header|Standard ML}}==

let val str = valOf (TextIO.inputLine TextIO.stdIn) in (* note: this keeps the trailing newline *)

print "Enter an integer: ";

print (str ^ Int.toString num ^ "\n")

end

 

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

 

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

while {$input != 75000} {

puts -nonewline "enter the number '75000': "

flush stdout

set input [gets stdin]

 

Of course, it's nicer to wrap the primitives in a procedure:

upvar 1 $var v

puts -nonewline "$message: "

question name "What is your name"

question task "What is your quest"

 

=={{header|TI-83 BASIC}}==

This program leaves the string in String1, and the integer in variable "i".

 

:Input "Enter a string:",Str1

:Prompt i

:Else

:Stop

 

=={{header|TI-89 BASIC}}==

This program leaves the requested values in the global variables ''s'' and ''integer''.

 

InputStr "Enter a string", s

Loop

EndIf

EndLoop

 

=={{header|Toka}}==

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

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

LOOP

ENDIF

ENDLOOP

Output:

<pre>

=={{header|UNIX Shell}}==

{{works with|Bourne Shell}}

 

 

=={{header|Vedit macro language}}==

 

=={{header|Visual Basic .NET}}==

 

===Input an Integer===

Console.WriteLine("Enter an Integer")

 

===Input an Integer With Error Handling===

Dim iString As String

Console.WriteLine("Enter an Integer")

Catch ex As Exception

Console.WriteLine("This is not an Integer")

 

===Input a String===

Console.WriteLine("Enter a String")

 

=={{header|XPL0}}==

place of the Enter key to mark the end of the string.

 

include c:\cxpl\codes;

int I;

Text(0, "Howdy "); Text(0, Name); Text(0, "! Now please enter ^"75000^": ");

IntOut(0, IntIn(0)); CrLf(0); \echo the number

 

Example output:

75000

</pre>

 

=={{header|ZX Spectrum Basic}}==

 

 

{{omit from|GUISS|We need an application that asks for these}}