User input/Text: Difference between revisions

 

See also: [[User input/Graphical]]

 

=={{header|11l}}==

 

=={{header|AArch64 Assembly}}==

 

.data

.bss

.text

 

 

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

 

num: to :integer input "Enter an integer: "

 

 

{{out}}

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

Also, when a numeric variable is provided for input, the computer will make repeated attempts to obtain valid input from the user until the input can be clearly interpreted as a numeric value.

 

10 input "what is a word i should remember";a$

20 print "thank you."

30 input "will you please type the number 75000";nn

40 if nn<>75000 then print "i'm sorry, that's not right.":goto 30

60 print a$

70 print nn

80 end

 

'''Output'''

&#9608;

</pre>

 

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

 

==={{header|QB64}}===

The use of a Long int (l&) is required as the Int variable type is only 2 bytes and even if _UNSIGNED can only hold values up to 65535. If no value is entered for either input value, it will continue to hold whatever value it did previously.

Print s$

Print l&

 

==={{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 sharp|C#}}==

 

namespace C_Sharp_Console {

}

}

 

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

 

=={{header|Ceylon}}==

print("enter any text here");

value text = process.readLine();

print("That was not a number per se.");

}

 

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

 

 

begin

rescue ex

puts ex

 

Example with valid input:

 

=={{header|D}}==

void main() {

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

 

=={{header|Dart}}==

 

main() {

}

 

 

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

 

a$ = input

print ""

until h = 75000

.

 

=={{header|Elena}}==

public program()

{

var num := new Integer();

 

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

 

=={{header|Frink}}==

s = input["Enter a string: "]

i = parseInt[input["Enter an integer: "]]

 

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

let s scan str

print "Enter a number: "

 

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

write "Enter a string: "

set text [readline]

 

print $text

 

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

I HAS A string

GIMMEH string

MAEK number A NUMBR

KTHXBYE

 

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

{{works with|min|0.19.3}}

 

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

 

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

20 PRINT "YOU ENTERED ";STRING$;"."

30 INPUT "ENTER AN INTEGER: ",INTEGER

 

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

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">prompt_string</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"Enter any string:"</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">prompt_number</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"Enter the number 75000:"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">75000</span><span style="color: #0000FF;">,</span><span style="color: #000000;">75000</span><span style="color: #0000FF;">})</span>

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

Start up.

Demonstrate input.

\Now show the input values

Write "The string: " then the string to the console.

A sample run of the program:

{{out}}

 

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

 

The word <code>$->n</code> attempts to convert a string to an integer, and returns an integer and a success flag. Validating the input is not part of the task, but since the flag is there we might as well use it. Similarly, might as well trim leading and trailing spaces, because ''users'', eh.

 

say 'You entered: "' echo$ say '"' cr cr

else

[ say "That was not an integer." cr

 

{{out}}

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

(formerly Perl 6)

 

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

'Enter_a_string:_ s:put s:get s:keep

[ 'Enter_75000:_ s:put s:get-word s:to-number nl #75000 eq? ] until

 

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

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

guard let str = readLine() else {

fatalError("Nothing read!")

fatalError("Not a number!")

}

 

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

Debug.Print InputBox("Input a string")

Debug.Print InputBox("Input the integer 75000", "Input an integer", 75000, Context = "Long")

 

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

input string$

print 1 "Enter an integer."

 

=={{header|Wren}}==

 

var string

System.print("\nYou entered:")

System.print(" string: %(string)")

 

{{out}}

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