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

 

Another:

 

procedure User_Input is

Ada.Text_IO.Put_Line (Integer'Image(I));

end User_Input;

 

Unbounded IO:

Ada.Text_IO,

Ada.Integer_Text_IO,

Ada.Text_IO.Put_Line(Integer'Image(I));

end User_Input2;

 

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

STRING s := read string;

print("Enter a number: ");

INT i := read int;

 

=={{header|ALGOL W}}==

string(80) s;

integer n;

write( "Enter an integer> " );

read( n )

 

=={{header|APL}}==

 

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

szMessErrDep: .asciz "Too large: overflow 32 bits.\n"

 

 

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

Also, in the string entry, the data is a string of tokens, not a string of characters. Thankfully, the most common ASCII symbols (A-Z, 0-9, and some symbols) have the same values as their token counterparts. This means that this example will work for those symbols, but other tokens (especially multi-byte tokens) will cause problems. See [http://tibasicdev.wikidot.com/one-byte-tokens this table] of tokens and their codes for reference.

 

input→A

length(A)→L

If C≠7500

Disp "That isn't 7500"

 

=={{header|BASIC}}==

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

 

 

Output ([[QBasic]]):

Enter a number: 1

==={{header|Applesoft BASIC}}===

 

==={{header|IS-BASIC}}===

 

==={{header|Sinclair ZX81 BASIC}}===

20 INPUT S$

30 PRINT "YOU ENTERED: ";S$

60 IF N=75000 THEN STOP

70 PRINT "NO, ";

 

=={{header|Batch File}}==

 

set /p var=

 

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

= out'"Enter a string"

& get':?mystring

)

& out$(mystring is !mystring \nmynumber is !mynumber \n)

<pre>{?} !doit

Enter a string

 

=={{header|C}}==

#include <stdlib.h>

 

 

return EXIT_SUCCESS;

 

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

print("enter any text here");

value text = process.readLine();

print(text);

 

=={{header|Clojure}}==

(def scan (Scanner. *in*))

(def s (.nextLine scan))

 

=={{header|COBOL}}==

{{works with|OpenCOBOL}}

PROGRAM-ID. Get-Input.

 

 

GOBACK

 

=={{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|Déjà Vu}}==

!print\ s

!decode!utf-8 !read-line!stdin

/= 75000

catch value-error:

=={{header|Elena}}==

 

=={{header|Elixir}}==

a = IO.gets("Enter a string: ") |> String.strip

b = IO.gets("Enter an integer: ") |> String.strip |> String.to_integer

IO.puts "Integer = #{b}"

IO.puts "Float = #{f}"

 

=={{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|F_Sharp|F#}}==

 

let ask_for_input s =

ask_for_input "Input a string" |> ignore

ask_for_input "Enter the number 75000" |> ignore

 

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

 

Dim s As String

Print

Print s, i

Sample input/output

{{out}}

Rosetta 75000

</pre>

 

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

s = GetStr("Enter a string: ");

 

 

Print("Your string: %s\n", s);

 

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

 

Note that <code>require'misc'</code> is old - efforts to optimize by loading misc utilities in a fine grained fashion mean that currently (J 805) that should be <code>require'general/misc/prompt'</code> and the older form fails with an error to call attention to this issue.

 

'''Example Usage'''

Enter string: Hello World

Hello World

│Hello Rosetta Code│75000│

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

 

=={{header|Java}}==

 

import java.util.Scanner;

 

int i = Integer.parseInt(s.next());

}

 

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

encountered, then the following program could be used on the assumption that

the inputs are all valid JSON.

null | until( . == int; "Expecting \(int)" | stderr | input);

 

(read_string | "I see the string: \(.)"),

{{out}}

The following is a transcript showing the prompts (on stderr), responses (on stdin) and output (on stdout):

"Please enter a string"

1

"Expecting 75000"

75000

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

print("String? ")

y = readline()

println("Sorry, but \"", y, "\" does not compute as an integer.")

end

 

{{out}}

 

=={{header|Kite}}==

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

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

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

val number = readLine()!!.toInt()

} while (number != 75000)

 

=={{header|Lasso}}==

 

define read_input(prompt::string) => {

 

// deliver the result

 

Output:

Hello (string) | 1234 (integer)

</pre>

 

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

Using an atom representation for strings and type-check failure-driven loops:

:- object(user_input).

 

 

:- end_object.

Output:

| ?- user_input::test.

Enter an integer: 75000.

Enter an atom: 'Hello world!'.

yes

 

=={{header|Lua}}==

s = io.stdin:read()

print('Enter a number: ')

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

 

=={{header|M2000 Interpreter}}==

Module CheckIt {

Keyboard "75000"+chr$(13)

}

CheckIt

 

 

=={{header|Maple}}==

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

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

User input/Text, in Neko

Tectonics:

if num == 75000 $print("Rosetta Code 75000, for the win!\n")

else $print("Sorry, need 75000\n")

 

{{out}}

 

=={{header|Nemerle}}==

using System.Console;

 

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

}

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

end

return

 

=={{header|newLISP}}==

{{works with|newLISP|9.0}}

(set 'x (read-line))

(print "Enter a string: ")

 

=={{header|Nim}}==

 

let str = readLineFromStdin "Input a string: "

 

=={{header|Oberon-2}}==

{{works with|oo2c}}

MODULE InputText;

IMPORT

Out.String("Enter a string: ");Out.Flush();In.String(str);

END InputText.

 

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

 

 

: testInput{

while (System.Console askln asInteger dup ->n isNull) [ "Not an integer" println ]

 

 

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

my $string = <>;

print "Enter an integer: ";

 

=={{header|Phix}}==

{{out}}

<pre>

75000

</pre>

 

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

 

#lang racket

(printf "Input a string: ")

(unless (number? n) (error "I said a number!"))

(printf "You entered: ~a\n" n)

 

=={{header|Rascal}}==

It is possible to use the eclipse IDE to create consoles. However, just as with the graphical input, this will always return a string. This string can subsequently be evaluated. A very simple example would be:

public void InputConsole(){

x = "";

str (str inp) {x = "<inp == "75000" ? "You entered 75000" : "You entered a string">";

return "<x>\n<inp>\nInput\>";});

Which has as output:

 

 

=={{header|Raven}}==

 

=={{header|REBOL}}==

Title: "Textual User Input"

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

; It always pays to be polite...

 

 

Output:

 

=={{header|Red}}==

=={{header|Retro}}==

 

=={{header|REXX}}==

do until userNumber==75000

 

say 'Please enter a string:' /*issue a prompt message to the term. */

parse pull userString /*the (char) string can be any length. */

parse pull userNumber /*obtain the user text from terminal. */

end /*until*/ /*check if the response is legitimate. */

 

=={{header|Ring}}==

see "Enter a string : " give s

see "Enter an integer : " give i

see "String = " + s + nl

see "Integer = " + i + nl

 

=={{header|Robotic}}==

input string "Enter string:"

set "$str" to "input"

[ "&number&"

end

 

To ensure that a specific number must be entered, just create a loop around the second input function:

input string "Enter string:"

set "$str" to "input"

[ "&number&"

end

 

=={{header|Ruby}}==

{{works with|Ruby|1.8.4}}

s = gets

printf "Enter an integer: "

puts "String = #{s}"

puts "Integer = #{i}"

 

=={{header|Rust}}==

This program shows all the proper error handling.

use std::fmt::Display;

use std::process;

let _ = writeln!(&mut io::stderr(), "Error: {}", msg);

process::exit(code)

 

=={{header|Scala}}==

val i=Console.readLong // Task says to enter 75000

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

Using the '''read(Type)''' built-in function:

 

or using the '''Sys.readln(msg)''' method:

 

=={{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|smart BASIC}}==

'''NOTE:''' The INPUT command uses a colon (:) as opposed to a comma (,) or semi-conlon (;) like other forms of BASIC.

 

 

=={{header|SNOBOL4}}==

str = trim(input)

output = "Enter an integer:"

int = trim(input)

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

 

=={{header|SPL}}==

In SPL all console input is text, so number should be converted from text using #.val function.

 

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

{{works with|Swift|2.x+}}

if let str = readLine() {

print(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

 

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

 

read string

read integer

read -p 'Enter a number: ' number

 

=={{header|Ursa}}==

# user input

#

set i (in int console)

 

 

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

<tt>READ-LINE</tt> reads a line of input as a string; <tt>READ</tt> reads an expression, of arbitrary complexity.

(define s (read-line))

(display "Yes, ")

"That is not the integer 75000." )

(t

{{out}}

<pre>Enter a string: Rosetta Code

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:

 

=={{header|zkl}}==

 

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

 

 

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

{{omit from|SQL PL|It does not handle user interaction, only the clients to access database done that}}