User input/Text: Difference between revisions

Content added Content deleted

Inline

Revision as of 06:18, 23 August 2021

In this task, the goal is to input a string and the integer 75000, from the text console.

11l

<lang 11l>V string = input(‘Input a string: ’) V number = Float(input(‘Input a number: ’))</lang>

ALGOL 68

<lang algol68>print("Enter a string: "); STRING s := read string; print("Enter a number: "); INT i := read int; ~</lang>

ARM Assembly

Works with: as version Raspberry Pi

/* ARM assembly Raspberry PI */ /* program inputText.s */

/* Constantes */ .equ BUFFERSIZE, 100 .equ STDIN, 0 @ Linux input console .equ STDOUT, 1 @ Linux output console .equ EXIT, 1 @ Linux syscall .equ READ, 3 @ Linux syscall .equ WRITE, 4 @ Linux syscall /* Initialized data */ .data szMessDeb: .asciz "Enter text : \n" szMessNum: .asciz "Enter number : \n" szCarriageReturn: .asciz "\n"

/* UnInitialized data */ .bss sBuffer: .skip BUFFERSIZE

/* code section */ .text .global main main: /* entry of program */

   push {fp,lr}    /* saves 2 registers */
   ldr r0,iAdrszMessDeb
   bl affichageMess
   mov r0,#STDIN         @ Linux input console
   ldr r1,iAdrsBuffer   @ buffer address 
   mov r2,#BUFFERSIZE   @ buffer size 
   mov r7, #READ         @ request to read datas
   swi 0                  @ call system
   ldr r1,iAdrsBuffer    @ buffer address 
   mov r2,#0                @ end of string
   strb r2,[r1,r0]         @ store byte at the end of input string (r0 contains number of characters)

   ldr r0,iAdrsBuffer    @ buffer address 
   bl affichageMess
   ldr r0,iAdrszCarriageReturn   
   bl affichageMess

   ldr r0,iAdrszMessNum
   bl affichageMess
   mov r0,#STDIN         @ Linux input console
   ldr r1,iAdrsBuffer   @ buffer address 
   mov r2,#BUFFERSIZE   @ buffer size 
   mov r7, #READ         @ request to read datas
   swi 0                  @ call system
   ldr r1,iAdrsBuffer    @ buffer address 
   mov r2,#0                @ end of string
   strb r2,[r1,r0]         @ store byte at the end of input string (r0
   @ 
   ldr r0,iAdrsBuffer    @ buffer address
   bl conversionAtoD    @ conversion string in number in r0

100: /* standard end of the program */

   mov r0, #0                  @ return code
   pop {fp,lr}                 @restaur 2 registers
   mov r7, #EXIT              @ request to exit program
   swi 0                       @ perform the system call

iAdrszMessDeb: .int szMessDeb iAdrszMessNum: .int szMessNum iAdrsBuffer: .int sBuffer iAdrszCarriageReturn: .int szCarriageReturn /******************************************************************/ /* display text with size calculation */ /******************************************************************/ /* r0 contains the address of the message */ affichageMess:

   push {fp,lr}    			/* save  registres */ 
   push {r0,r1,r2,r7}    		/* save others registers */
   mov r2,#0   				/* counter length */

1: /* loop length calculation */

   ldrb r1,[r0,r2]  			/* read octet start position + index */
   cmp r1,#0       			/* if 0 its over */
   addne r2,r2,#1   			/* else add 1 in the length */
   bne 1b          			/* and loop */
                               /* so here r2 contains the length of the message */
   mov r1,r0        			/* address message in r1 */
   mov r0,#STDOUT      		/* code to write to the standard output Linux */
   mov r7, #WRITE             /* code call system "write" */
   swi #0                      /* call systeme */
   pop {r0,r1,r2,r7}     		/* restaur others registers */
   pop {fp,lr}    				/* restaur des  2 registres */ 
   bx lr	        			/* return  */

/******************************************************************/ /* Convert a string to a number stored in a registry */ /******************************************************************/ /* r0 contains the address of the area terminated by 0 or 0A */ /* r0 returns a number */ conversionAtoD:

   push {fp,lr}         @ save 2 registers 
   push {r1-r7}         @ save others registers 
   mov r1,#0
   mov r2,#10           @ factor 
   mov r3,#0            @ counter 
   mov r4,r0            @ save address string -> r4 
   mov r6,#0            @ positive sign by default 
   mov r0,#0            @ initialization to 0

1: /* early space elimination loop */

   ldrb r5,[r4,r3]     @ loading in r5 of the byte located at the beginning + the position 
   cmp r5,#0            @ end of string -> end routine
   beq 100f
   cmp r5,#0x0A        @ end of string -> end routine
   beq 100f
   cmp r5,#' '          @ space ? 
   addeq r3,r3,#1      @ yes we loop by moving one byte 
   beq 1b
   cmp r5,#'-'          @ first character is -    
   moveq r6,#1         @  1 -> r6
   beq 3f              @ then move on to the next position

2: /* beginning of digit processing loop */

   cmp r5,#'0'          @ character is not a number 
   blt 3f
   cmp r5,#'9'          @ character is not a number
   bgt 3f
   /* character is a number */
   sub r5,#48
   ldr r1,iMaxi       @ check the overflow of the register    
   cmp r0,r1
   bgt 99f            @ overflow error
   mul r0,r2,r0         @ multiply par factor 10 
   add r0,r5            @ add to  r0

3:

   add r3,r3,#1         @ advance to the next position 
   ldrb r5,[r4,r3]     @ load byte 
   cmp r5,#0            @ end of string -> end routine
   beq 4f
   cmp r5,#0x0A            @ end of string -> end routine
   beq 4f
   b 2b                 @ loop

4:

   cmp r6,#1            @ test r6 for sign 
   moveq r1,#-1
   muleq r0,r1,r0       @ if negatif, multiply par -1 
   b 100f

99: /* overflow error */

   ldr r0,=szMessErrDep
   bl   affichageMess
   mov r0,#0      @ return  zero  if error

100:

   pop {r1-r7}          @ restaur other registers 
   pop {fp,lr}          @ restaur   2 registers 
   bx lr                 @return procedure

/* constante program */ iMaxi: .int 1073741824 szMessErrDep: .asciz "Too large: overflow 32 bits.\n"

</lang>

Arturo

<lang rebol>str: input "Enter a string: " num: to :integer input "Enter an integer: "

print ["Got:" str "," num]</lang>

Output:

Enter a string: hello world
Enter an integer: 1986
Got: hello world , 1986

AutoHotkey

Windows console

<lang AutoHotkey>DllCall("AllocConsole") FileAppend, please type something`n, CONOUT$ FileReadLine, line, CONIN$, 1 msgbox % line FileAppend, please type '75000'`n, CONOUT$ FileReadLine, line, CONIN$, 1 msgbox % line</lang>

Input Command

this one takes input regardless of which application has focus. <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>

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>

Axe

Since integers in Axe are two bytes, 75000 exceeds the maximum integer limit (65535). The task has been adjusted accordingly so the integer must be 7500 instead.

In this implementation, the number displayed is effectively the number entered modulo 65536.

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 this table of tokens and their codes for reference.

<lang axe>Disp "String:" input→A length(A)→L

.Copy the string to a safe location Copy(A,L₁,L)

.Display the string Disp "You entered:",i For(I,0,L-1)

Disp {L₁+I}►Char

End Disp i

Disp "Integer:",i input→B length(B)→L

.Parse the string and convert to an integer 0→C For(I,0,L-1)

{B+I}-'0'→N
If N>10
 .Error checking
 Disp "Not a number",i
 Return
End
C*10+N→C

End

.Display and check the integer Disp "You entered:",i,C►Dec,i If C≠7500 Disp "That isn't 7500" End</lang>

BASIC

Many BASICs will automatically append a question mark (?) to the end of the prompt if the prompt is followed by a semicolon (;). (Some of those will skip the question mark if the prompt is followed by a comma (,) instead of a semicolon.)

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

<lang qbasic>INPUT "Enter a string"; s$ INPUT "Enter a number: ", i%</lang>

Output (QBasic):

Enter a string? foo
Enter a number: 1

Applesoft BASIC

<lang basic>10 INPUT "ENTER A STRING: "; S$ 20 INPUT "ENTER A NUMBER: "; I : I = INT(I)</lang>

Commodore BASIC

When using the prompt feature of the INPUT command, the string literal must be followed by a semicolon and then the string variable, or else a ?SYNTAX ERROR will occur. The question mark prompt is always presented with the INPUT command. Any other behavior would have to come from a user-built routine using the GET command.

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.

<lang gwbasic> 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 50 print "thank you.":print "you provided the following values:" 60 print a$ 70 print nn 80 end </lang>

Output

READY.
RUN
WHAT IS A WORD I SHOULD REMEMBER? PANCAKE
THANK YOU.
WILL YOU PLEASE TYPE THE NUMBER 75000? NO.
?REDO FROM START
WILL YOU PLEASE TYPE THE NUMBER 75000? 848
I'M SORRY, THAT'S NOT RIGHT.
WILL YOU PLEASE TYPE THE NUMBER 75000? 75000
THANK YOU.
YOU PROVIDED THE FOLLOWING VALUES:
PANCAKE
 75000

READY.
█

IS-BASIC

<lang IS-BASIC>100 INPUT PROMPT "Enter a number: ":NUM 110 INPUT PROMPT "Enter a string: ":ST$</lang>

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. <lang QB64>Input "Enter text and a number", s$, l& Print s$ Print l& </lang>

Sinclair ZX81 BASIC

<lang basic>10 PRINT "ENTER A STRING" 20 INPUT S$ 30 PRINT "YOU ENTERED: ";S$ 40 PRINT "NOW ENTER THE NUMBER 75000" 50 INPUT N 60 IF N=75000 THEN STOP 70 PRINT "NO, "; 80 GOTO 40</lang>

Batch File

BBC BASIC

<lang bbcbasic> INPUT LINE "Enter a string: " string$

     INPUT "Enter a number: " number
     
     PRINT "String = """ string$ """"
     PRINT "Number = " ; number</lang>

Befunge

This prompts for a string and pushes it to the stack a character at a time (~) until end of input (-1). <lang befunge><>:v:"Enter a string: "

^,_ >~:1+v
    ^    _@</lang>

Numeric input is easier, using the & command. <lang befunge><>:v:"Enter a number: "

^,_ & @</lang>

Bracmat

<lang bracmat>( doit = out'"Enter a string"

 & get':?mystring
 &   whl
   ' ( out'"Enter a number"
     & get':?mynumber
     & !mynumber:~#
     & out'"I said:\"a number\"!"
     )
 & out$(mystring is !mystring \nmynumber is !mynumber \n)

);</lang>

{?} !doit
Enter a string
abacus
Enter a number
75000h
I said:"a number"!
Enter a number
75000
mystring is abacus
mynumber is 75000

C

<lang c>#include <stdio.h>

include <stdlib.h>

int main(void) {

   // Get a string from stdin
   char str[BUFSIZ];
   puts("Enter a string: ");
   fgets(str, sizeof(str), stdin);

   // Get 75000 from stdin
   long num;
   char buf[BUFSIZ];
   do
   {
       puts("Enter 75000: ");
       fgets(buf, sizeof(buf), stdin);
       num = strtol(buf, NULL, 10);
   } while (num != 75000);

   return EXIT_SUCCESS;

}</lang>

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>

C++

Works with: g++

<lang cpp>#include <iostream>

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> getline(cin, string_input);</lang>

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 if (!cin) // handle error) after the first input, and then clear the error (with cin.clear()) 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.

Ceylon

<lang ceylon>shared void run() { print("enter any text here"); value text = process.readLine(); print(text); print("enter the number 75000 here"); if (is Integer number = Integer.parse(process.readLine() else "")) { print("``number == 75k then number else "close enough"``"); } else { print("That was not a number per se."); } }</lang>

Clojure

<lang lisp>(import '(java.util Scanner)) (def scan (Scanner. *in*)) (def s (.nextLine scan)) (def n (.nextInt scan))</lang>

COBOL

Works with: OpenCOBOL

<lang cobol> IDENTIFICATION DIVISION.

      PROGRAM-ID. Get-Input.

      DATA DIVISION.
      WORKING-STORAGE SECTION.
      01  Input-String PIC X(30).
      01  Input-Int    PIC 9(5).

      PROCEDURE DIVISION.
      DISPLAY "Enter a string:"
      ACCEPT Input-String

      DISPLAY "Enter a number:"
      ACCEPT Input-Int

      GOBACK
      .</lang>

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>

Crystal

<lang ruby>puts "You entered: #{gets}"

begin

 puts "You entered: #{gets.not_nil!.chomp.to_i}"

rescue ex

 puts ex

end</lang>

Example with valid input:

Hello
You entered: Hello
75000
You entered: 75000

Example with invalid input:

Hello
You entered: Hello
Goodbye
Invalid Int32: Goodbye

D

<lang D>import std.stdio;

void main() {

   long number;
   write("Enter an integer: ");
   readf("%d", &number);
   
   char[] str;
   write("Enter a string: ");
   readf(" %s\n", &str);

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

}</lang>

Dart

<lang javascript>import 'dart:io' show stdout, stdin;

main() { stdout.write('Enter a string: '); final string_input = stdin.readLineSync();

int number_input;

do { stdout.write('Enter the number 75000: '); var number_input_string = stdin.readLineSync();

try { number_input = int.parse(number_input_string); if (number_input != 75000) stdout.writeln('$number_input is not 75000!'); } on FormatException { stdout.writeln('$number_input_string is not a valid number!'); } catch ( e ) { stdout.writeln(e); }

} while ( number_input != 75000 );

stdout.writeln('input: $string_input\nnumber: $number_input'); }

</lang>

Delphi

<lang Delphi>program UserInputText;

{$APPTYPE CONSOLE}

uses SysUtils;

var

 s: string;
 lStringValue: string;
 lIntegerValue: Integer;

begin

 WriteLn('Enter a string:');
 Readln(lStringValue);

 repeat
   WriteLn('Enter the number 75000');
   Readln(s);
   lIntegerValue := StrToIntDef(s, 0);
   if lIntegerValue <> 75000 then
     Writeln('Invalid entry: ' + s);
 until lIntegerValue = 75000;

end.</lang>

Déjà Vu

<lang dejavu>input s:

   !print\ s
   !decode!utf-8 !read-line!stdin

local :astring input "Enter a string: " true while:

   try:
       to-num input "Enter the number 75000: "
       /= 75000
   catch value-error:
       true</lang>

EasyLang

<lang>write "Enter a string: " a$ = input print "" repeat

 write "Enter the number 75000: "
 h = number input
 print ""
 until h = 75000

. print a$ & " " & h</lang>

Elena

ELENA 4.x : <lang elena>import extensions;

public program() {

   var num := new Integer();
   console.write:"Enter an integer: ".loadLineTo:num;

   var word := console.write:"Enter a String: ".readLine()

}</lang>

Elixir

<lang Elixir> a = IO.gets("Enter a string: ") |> String.strip b = IO.gets("Enter an integer: ") |> String.strip |> String.to_integer f = IO.gets("Enter a real number: ") |> String.strip |> String.to_float IO.puts "String = #{a}" IO.puts "Integer = #{b}" IO.puts "Float = #{f}" </lang>

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>

Euphoria

<lang Euphoria>include get.e

sequence s atom n

s = prompt_string("Enter a string:") puts(1, s & '\n') n = prompt_number("Enter a number:",{}) printf(1, "%d", n)</lang>

F#

<lang fsharp>open System

let ask_for_input s =

   printf "%s (End with Return): " s
   Console.ReadLine()

[<EntryPoint>] let main argv =

   ask_for_input "Input a string" |> ignore
   ask_for_input "Enter the number 75000" |> ignore
   0</lang>

Factor

<lang factor>"Enter a string: " write readln "Enter a number: " write readln string>number</lang>

Falcon

<lang falcon>printl("Enter a string:") str = input() printl("Enter a number:") n = int(input())</lang>

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 (^). <lang false>[[^$' =~][,]#,]w: [0[^'0-$$9>0@>|~][\10*+]#%]d: w;! d;!.</lang>

Fantom

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

<lang fantom> class Main {

 public static Void main ()
 {
   Env.cur.out.print ("Enter a string: ").flush
   str := Env.cur.in.readLine
   echo ("Entered :$str:")
   Env.cur.out.print ("Enter 75000: ").flush
   Int n
   try n = Env.cur.in.readLine.toInt
   catch (Err e) 
   {
     echo ("You had to enter a number")
     return
   }
   echo ("Entered :$n: which is " + ((n == 75000) ? "correct" : "wrong"))
 }

} </lang>

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.

Works with: 4tH

<lang forth>: input#

 begin
   refill drop bl parse-word          ( a n)
   number error?                      ( n f)
 while                                ( n)
   drop                               ( --)
 repeat                               ( n)

</lang>

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>

Fortran

Works with: Fortran version 90 and later

<lang fortran>character(20) :: s integer :: i

print*, "Enter a string (max 20 characters)" read*, s print*, "Enter the integer 75000" read*, i</lang>

FreeBASIC

<lang freebasic>' FB 1.05.0 Win64

Dim s As String Dim i AS Integer Input "Please enter a string : "; s Do

 Input "Please enter 75000    : "; i

Loop Until i = 75000 Print Print s, i Sleep</lang> Sample input/output

Output:

Please enter a string : ? Rosetta
Please enter 75000    : ? 70000
Please enter 75000    : ? 75000

Rosetta        75000

Frink

<lang frink> s = input["Enter a string: "] i = parseInt[input["Enter an integer: "]] </lang>

Go

Go has C-like Scan and Scanf functions for quick and dirty input: <lang go>package main

import "fmt"

func main() {

   var s string
   var i int
   if _, err := fmt.Scan(&s, &i); err == nil && i == 75000 {
       fmt.Println("good")
   } else {
       fmt.Println("wrong")
   }

}</lang> Code below allows much more control over interaction and error checking. <lang go> package main

import (

   "bufio"
   "fmt"
   "os"
   "strconv"
   "strings"

)

func main() {

   in := bufio.NewReader(os.Stdin)

   fmt.Print("Enter string: ")
   s, err := in.ReadString('\n')
   if err != nil {
       fmt.Println(err)
       return
   }
   s = strings.TrimSpace(s)

   fmt.Print("Enter 75000: ")
   s, err = in.ReadString('\n')
   if err != nil {
       fmt.Println(err)
       return
   }
   n, err := strconv.Atoi(strings.TrimSpace(s))
   if err != nil {
       fmt.Println(err)
       return
   }
   if n != 75000 {
       fmt.Println("fail:  not 75000")
       return
   }
   fmt.Println("Good")

} </lang>

Groovy

<lang groovy>word = System.in.readLine() num = System.in.readLine().toInteger()</lang>

Haskell

<lang haskell>import System.IO (hFlush, stdout) main = do

   putStr "Enter a string: "
   hFlush stdout
   str <- getLine
   putStr "Enter an integer: "
   hFlush stdout
   num <- readLn :: IO Int 
   putStrLn $ str ++ (show num)</lang>

Note: :: IO Int is only there to disambiguate what type we wanted from read. If num 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.

hexiscript

<lang hexiscript>print "Enter a string: " let s scan str print "Enter a number: " let n scan int</lang>

HolyC

<lang holyc>U8 *s; s = GetStr("Enter a string: ");

U32 *n; do {

 n = GetStr("Enter 75000: ");

} while(Str2I64(n) != 75000);

Print("Your string: %s\n", s); Print("75000: %d\n", Str2I64(n));</lang>

Icon and Unicon

The following works in both Icon and Unicon:

<lang icon> procedure main ()

 writes ("Enter something: ")
 s := read ()
 write ("You entered: " || s)

 writes ("Enter 75000: ")
 if (i := integer (read ())) then 
   write (if (i = 75000) then "correct" else "incorrect")
 else write ("you must enter a number")

end </lang>

Io

<lang io>string := File clone standardInput readLine("Enter a string: ") integer := File clone standardInput readLine("Enter 75000: ") asNumber</lang>

J

Solution <lang j> require 'misc' NB. load system script

  prompt 'Enter string: '
  0".prompt 'Enter an integer: '</lang>

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

Example Usage <lang j> prompt 'Enter string: ' NB. output string to session Enter string: Hello World Hello World

  0".prompt 'Enter an integer: '             NB. output integer to session

Enter an integer: 75000 75000

  mystring=: prompt 'Enter string: '         NB. store string as noun

Enter string: Hello Rosetta Code

  myinteger=: 0".prompt 'Enter an integer: ' NB. store integer as noun

Enter an integer: 75000

  mystring;myinteger                         NB. show contents of nouns

┌──────────────────┬─────┐ │Hello Rosetta Code│75000│ └──────────────────┴─────┘ </lang>

Java

<lang java> import java.util.Scanner;

public class GetInput {

   public static void main(String[] args) throws Exception {
       Scanner s = new Scanner(System.in);
       System.out.print("Enter a string: ");
       String str = s.nextLine();
       System.out.print("Enter an integer: ");
       int i = Integer.parseInt(s.next());
   }

}</lang>

or

Works with: Java version 1.5/5.0+

<lang java>import java.util.Scanner;

public class GetInput {

   public static void main(String[] args) {
       Scanner stdin = new Scanner(System.in);
       String string = stdin.nextLine();
       int number = stdin.nextInt();
   }

}</lang>

JavaScript

Works with: JScript

and only with cscript.exe

<lang javascript>WScript.Echo("Enter a string"); var str = WScript.StdIn.ReadLine();

var val = 0; while (val != 75000) {

   WScript.Echo("Enter the integer 75000");
   val = parseInt( WScript.StdIn.ReadLine() );

}</lang>

Works with: SpiderMonkey

<lang javascript>print("Enter a string"); var str = readline();

var val = 0; while (val != 75000) {

   print("Enter the integer 75000");
   val = parseInt( readline() );

}</lang>

Joy

<lang Joy> "Enter a string: " putchars stdin fgets "Enter a number: " putchars stdin fgets 10 strtol. </lang>

jq

Works with: jq version 1.4

If the input consists of a JSON string followed by a JSON number, then the jq program consisting of . will read and echo the two values.

Works with: jq version 1.5

If the goal is to continue reading the input until a JSON string is found, and then continue reading the input until the integer value 75000 is encountered, then the following program could be used on the assumption that the inputs are all valid JSON. <lang jq>def read(int):

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

def read_string:

 null | until( type == "string";  "Please enter a string" | stderr | input);

(read_string | "I see the string: \(.)"), (read(75000) | "I see the expected integer: \(.)")</lang>

Output:

The following is a transcript showing the prompts (on stderr), responses (on stdin) and output (on stdout): <lang sh>$ jq -n -r -f User_input.jq "Please enter a string" 1 "Please enter a string" "ok" I see the string: ok "Expecting 75000" 1 "Expecting 75000" "ok" "Expecting 75000" 75000 I see the expected integer: 75000</lang>

Julia

Works with: Julia version 0.6

<lang Julia> print("String? ") y = readline() println("Your input was \"", y, "\".\n") print("Integer? ") y = readline() try

   y = parse(Int, y)
   println("Your input was \"", y, "\".\n")

catch

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

end </lang>

Output:

String? cheese
Your input was "cheese".

Integer? 75000
Your input was "75000".

mike@harlan:~/rosetta/julia$ julia user_input_text.jl
String? theory
Your input was "theory".

Integer? 75,000
Sorry, but "75,000" does not compute as an integer.

Kite

<lang Kite> System.file.stdout|write("Enter a String "); string = System.file.stdin|readline(); </lang>

Kotlin

<lang scala>// version 1.1

fun main(args: Array<String>) {

   print("Enter a string : ")
   val s = readLine()!!
   println(s)
   do {
       print("Enter 75000 : ")
       val number = readLine()!!.toInt()
   } while (number != 75000)

}</lang>

Lasso

<lang Lasso>#!/usr/bin/lasso9

define read_input(prompt::string) => {

local(string)

// display prompt stdout(#prompt) // the following bits wait until the terminal gives you back a line of input while(not #string or #string -> size == 0) => { #string = file_stdin -> readsomebytes(1024, 1000) } #string -> replace(bytes('\n'), bytes())

return #string -> asstring

}

local( string, number )

// get string

string = read_input('Enter the string: ')

// get number

number = integer(read_input('Enter the number: '))

// deliver the result stdoutnl(#string + ' (' + #string -> type + ') | ' + #number + ' (' + #number -> type + ')')</lang>

Output:

Enter the string: Hello
Enter the number: 1234
Hello (string) | 1234 (integer)

Liberty BASIC

<lang lb>Input "Enter a string. ";string$ Input "Enter the value 75000.";num</lang>

LIL

<lang tcl># User input/text, in LIL write "Enter a string: " set text [readline]

set num 0 while {[canread] && $num != 75000} {

   write "Enter the number 75000: "
   set num [readline]

}

print $text print $num</lang>

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>

Logtalk

Using an atom representation for strings and type-check failure-driven loops: <lang logtalk>

- object(user_input).

   :- public(test/0).
   test :-
       repeat,
           write('Enter an integer: '),
           read(Integer),
       integer(Integer),
       !,
       repeat,
           write('Enter an atom: '),
           read(Atom),
       atom(Atom),
       !.

- end_object.

</lang> Output: <lang text> | ?- user_input::test. Enter an integer: 75000. Enter an atom: 'Hello world!'. yes </lang>

LOLCODE

<lang LOLCODE>HAI 1.4 I HAS A string GIMMEH string I HAS A number GIMMEH number BTW converts number input to an integer MAEK number A NUMBR KTHXBYE </lang>

Lua

<lang Lua>print('Enter a string: ') s = io.stdin:read() print('Enter a number: ') i = tonumber(io.stdin:read()) </lang>

M2000 Interpreter

<lang M2000 Interpreter> Module CheckIt {

     Keyboard "75000"+chr$(13)
     Input "Integer:", A%
     \\ Input erase keyboard buffer, we can't place in first Keyboard keys for second input
     Keyboard  "Hello World"+Chr$(13)
     Input "String:", A$
     Print A%, A$

} CheckIt </lang>

Maple

<lang maple>printf("String:"); string_value := readline(); printf("Integer: "); int_value := parse(readline());</lang>

Mathematica / Wolfram Language

<lang Mathematica>mystring = InputString["give me a string please"]; myinteger = Input["give me an integer please"];</lang>

MATLAB

The input() function automatically converts the user input to the correct data type (i.e. string or double). We can force the input to be interpreted as a string by using an optional parameter 's'.

Sample usage: <lang MATLAB>>> input('Input string: ') Input string: 'Hello'

ans =

Hello

>> input('Input number: ') Input number: 75000

ans =

>> input('Input number, the number will be stored as a string: ','s') Input number, the number will be stored as a string: 75000

ans =

75000</lang>

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

min

Works with: min version 0.19.3

<lang min>"Enter a string" ask "Enter an integer" ask int</lang>

Mirah

<lang mirah>s = System.console.readLine()

puts s</lang>

mIRC Scripting Language

<lang mirc>alias askmesomething {

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

}</lang>

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>

MUMPS

<lang MUMPS>TXTINP

NEW S,N
WRITE "Enter a string: "
READ S,!
WRITE "Enter the number 75000: "
READ N,!
KILL S,N
QUIT</lang>

Nanoquery

<lang Nanoquery>string = str(input("Enter a string: ")) integer = int(input("Enter an integer: "))</lang>

Neko

<lang ActionScript>/**

User input/Text, in Neko
Tectonics:
  nekoc userinput.neko
  neko userinput

/

var stdin = $loader.loadprim("std@file_stdin", 0)() var file_read_char = $loader.loadprim("std@file_read_char", 1)

/* Read a line from file f into string s returning length without any newline */ var NEWLINE = 10 var readline = function(f, s) {

   var len = 0
   var ch
   while true {
       try ch = file_read_char(f) catch a break;
       if ch == NEWLINE break;
       if $sset(s, len, ch) == null break; else len += 1
   }
   return $ssub(s, 0, len)

}

$print("Enter a line of text, then the number 75000\n")

try {

   var RECL = 132
   var str = $smake(RECL)
   var userstring = readline(stdin, str)
   $print(":", userstring, ":\n")

   var num = $int(readline(stdin, str))
   if num == 75000 $print("Rosetta Code 75000, for the win!\n")
   else $print("Sorry, need 75000\n")

} catch problem $print("Exception: ", problem, "\n")</lang>

Output:

prompt$ nekoc userinput.neko
prompt$ neko userinput.n
Enter a line of text, then the number 75000
this is a line of text
:this is a line of text:
75000
Rosetta Code 75000, for the win!

Nemerle

<lang Nemerle>using System; using System.Console;

module Input {

   Main() : void
   {
       Write("Enter a string:");
       _ = ReadLine()

       mutable entry = 0;
       mutable numeric = false;
       
       do
       {
           Write("Enter 75000:");
           numeric = int.TryParse(ReadLine(), out entry);
       } while ((!numeric) || (entry != 75000)) 
   }

}</lang>

NetRexx

<lang NetRexx>/* NetRexx */ options replace format comments java crossref symbols nobinary

checkVal = 75000 say 'Input a string then the number' checkVal parse ask inString parse ask inNumber .

say 'Input string:' inString say 'Input number:' inNumber if inNumber == checkVal then do

 say 'Success!  Input number is as requested'
 end

else do

 say 'Failure!  Number' inNumber 'is not' checkVal
 end

return </lang>

newLISP

Works with: newLISP version 9.0

<lang lisp>(print "Enter an integer: ") (set 'x (read-line)) (print "Enter a string: ") (set 'y (read-line))</lang>

Nim

<lang nim>import rdstdin, strutils

let str = readLineFromStdin "Input a string: " let num = parseInt(readLineFromStdin "Input an integer: ")</lang>

NS-HUBASIC

<lang NS-HUBASIC>10 INPUT "ENTER A STRING: ",STRING$ 20 PRINT "YOU ENTERED ";STRING$;"." 30 INPUT "ENTER AN INTEGER: ",INTEGER 40 PRINT "YOU ENTERED";INTEGER;"."</lang>

Oberon-2

Works with: oo2c

<lang oberon2> MODULE InputText; IMPORT

 In,
 Out;

VAR

 i: INTEGER;
 str: ARRAY 512 OF CHAR;

BEGIN

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

END InputText. </lang>

Objeck

<lang objeck> use IO;

bundle Default {

 class Hello {
   function : Main(args : String[]) ~ Nil {
     string := Console->GetInstance()->ReadString();
     string->PrintLine();

     number := Console->GetInstance()->ReadString()->ToInt();
     number->PrintLine();
   }
 }

} </lang>

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>

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>

Oforth

<lang Oforth>import: console

testInput{

| s n |

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

  System.Out "Received : " << s << " and " << n << cr ;</lang>

Oz

<lang oz>declare

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

in

 {System.printInfo "Enter a string: "}
 StringInput = {StdIn getS($)}

 for until:@Num == 75000 do
    {System.printInfo "Enter 75000: "}
    Line = {StdIn getS($)}
 in
    Num := try {String.toInt Line} catch _ then 0 end
 end</lang>

PARI/GP

<lang parigp>s=input(); n=eval(input());</lang>

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>

Perl

<lang perl>print "Enter a string: "; my $string = <>; print "Enter an integer: "; my $integer = <>;</lang>

Phix

?prompt_string("Enter any string:")
?prompt_number("Enter the number 75000:",{75000,75000})

Output:

Enter any string:abc
"abc"
Enter the number 75000:123
A number from 75000 to 75000 is expected here - try again
Enter the number 75000:75000
75000

PHP

Works with: CLI SAPI

PicoLisp

<lang PicoLisp>(in NIL # Guarantee reading from standard input

  (let (Str (read)  Num (read))
     (prinl "The string is: \"" Str "\"")
     (prinl "The number is: " Num) ) )</lang>

Pike

<lang pike>int main(){

  write("Enter a String: ");
  string str = Stdio.stdin->gets();
  write("Enter 75000: ");
  int num = Stdio.stdin->gets();

}</lang>

PL/I

<lang PL/I>declare s character (100) varying; declare k fixed decimal (15);

put ('please type a string:'); get edit (s) (L); put skip list (s);

put skip list ('please type the integer 75000'); get list (k); put skip list (k); put skip list ('Thanks');</lang>

Plain English

<lang plainenglish>To run: Start up. Demonstrate input. Wait for the escape key. Shut down.

To demonstrate input: Write "Enter a string: " to the console without advancing. Read a string from the console. Write "Enter a number: " to the console without advancing. Read a number from the console. \Now show the input values Write "The string: " then the string to the console. Write "The number: " then the number to the console.</lang> A sample run of the program:

Output:

Enter a string: abc
Enter a number: 123
The string: abc
The number: 123

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>

PostScript

Works with: PostScript version 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.

PowerShell

<lang powershell>$string = Read-Host "Input a string" [int]$number = Read-Host "Input a number"</lang>

PureBasic

<lang PureBasic>If OpenConsole()

 ; Declare a string and a integer to be used
 Define txt.s, num.i

 Print("Enter a string: ")
 txt=Input()

 Repeat
   Print("Enter the number 75000: ")
   num=Val(Input()) ; Converts the Input to a Value with Val()
 Until num=75000
 ; Check that the user really gives us 75000!
 
 Print("You made it!")
 Delay(3000): CloseConsole()

EndIf</lang>

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.

Quackery

The word $->n 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.

<lang Quackery>$ "Please enter a string: " input say 'You entered: "' echo$ say '"' cr cr

$ "Please enter an integer: " input trim reverse trim reverse $->n iff

 [ say "You entered: " echo cr ]

else

 [ say "That was not an integer." cr 
   drop ]</lang>

Output:

Please enter a string: 3-ply sisal twine
You entered: "3-ply sisal twine"

Please enter an integer: 75000
You entered: 75000

R

Works with: R version 2.81

<lang R>stringval <- readline("String: ") intval <- as.integer(readline("Integer: "))</lang>

Racket

lang racket

(printf "Input a string: ") (define s (read-line)) (printf "You entered: ~a\n" s)

(printf "Input a number: ") (define m (or (string->number (read-line))

             (error "I said a number!")))

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

alternatively, use the generic `read'

(printf "Input a number: ") (define n (read)) (unless (number? n) (error "I said a number!")) (printf "You entered: ~a\n" n) </lang>

Raku

(formerly Perl 6) <lang perl6>my $str = prompt("Enter a string: "); my $int = prompt("Enter a integer: ");</lang>

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: <lang rascal>import util::IDE; public void InputConsole(){

   x = "";                                   
   createConsole("Input Console",                             
                 "Welcome to the Input Console\nInput\> ", 
                 str (str inp) {x = "<inp == "75000" ? "You entered 75000" : "You entered a string">";
                		 return "<x>\n<inp>\nInput\>";});

}</lang> Which has as output:

This makes it relatively easy to create Domain Specific Languages (or any programming language) and to create a rascal console for this. For examples with Exp, Func and Lisp, see the online Language Examples.

Raven

<lang raven>'Input a string: ' print expect as str 'Input an integer: ' print expect 0 prefer as num</lang>

REBOL

<lang REBOL>REBOL [ Title: "Textual User Input" URL: http://rosettacode.org/wiki/User_Input_-_text ]

s: n: ""

Because I have several things to check for, I've made a function to
handle it. Note the question mark in the function name, this convention
is often used in Forth to indicate test of some sort.

valid?: func [s n][ error? try [n: to-integer n] ; Ignore error if conversion fails. all [0 < length? s 75000 = n]]

I don't want to give up until I've gotten something useful, so I
loop until the user enters valid data.

while [not valid? s n][ print "Please enter a string, and the number 75000:" s: ask "string: " n: ask "number: " ]

It always pays to be polite...

print rejoin [ "Thank you. Your string was '" s "'."]</lang>

Output:

Please enter a string, and the number 75000:
string: This is a test.
number: ksldf
Please enter a string, and the number 75000:
string:
number: 75000
Please enter a string, and the number 75000:
string: Slert...
number: 75000
Thank you. Your string was 'Slert...'.

Red

<lang Red>n: ask "Please enter # 75000: " str: ask "Please enter any string: "</lang>

Retro

<lang Retro>:example ("-)

 'Enter_a_string:_ s:put s:get s:keep
 [ 'Enter_75000:_ s:put s:get-word s:to-number nl #75000 eq? ] until
 'Your_string_was:_'%s'\n s:format s:put ;</lang>

REXX

Note: all of the following would be accepted as being numerically equal to 75000:

7.5E+0004
75000.
750000e-01
000075000.0000
75000 (with leading and/or trailing blanks)
and others

If the intent was to have the user enter the string exactly as 75000,
then the REXX do statement should be replaced with:

 do  until userNumber==75000

<lang rexx>/*REXX program prompts & reads/obtains a string, and also the number 75000 from terminal*/ say 'Please enter a string:' /*issue a prompt message to the term. */ parse pull userString /*the (char) string can be any length. */

                                                /* [↑]  the string could be null/empty.*/
 do  until userNumber=75000                     /*repeat this loop until satisfied.    */
 say                                            /*display a blank line to the terminal.*/
 say 'Please enter the number 75000'            /*display a nice prompt message to term*/
 parse pull userNumber                          /*obtain the user text from terminal.  */
 end   /*until*/                                /*check if the response is legitimate. */
                                                /*stick a fork in it,  we're all done. */</lang>

Ring

<lang ring> see "Enter a string : " give s see "Enter an integer : " give i see "String = " + s + nl see "Integer = " + i + nl </lang>

Robotic

<lang robotic> input string "Enter string:" set "$str" to "input" input string "Enter number:" set "number" to "input" [ "You entered:" [ "&$str&" [ "&number&" end </lang>

To ensure that a specific number must be entered, just create a loop around the second input function: <lang robotic> input string "Enter string:" set "$str" to "input"

"incorrect"

input string "Enter number:" set "number" to "input" if "number" != "(75000)" then "incorrect" [ "You entered:" [ "&$str&" [ "&number&" end </lang>

Ruby

Works with: Ruby version 1.8.4

<lang ruby>print "Enter a string: " s = gets printf "Enter an integer: " i = gets.to_i # If string entered, will return zero printf "Enter a real number: " f = Float(gets) rescue nil # converts a floating point number or returns nil puts "String = #{s}" puts "Integer = #{i}" puts "Float = #{f}"</lang>

Rust

This program shows all the proper error handling. <lang rust>use std::io::{self, Write}; use std::fmt::Display; use std::process;

fn main() {

   let s = grab_input("Give me a string")
       .unwrap_or_else(|e| exit_err(&e, e.raw_os_error().unwrap_or(-1)));

   println!("You entered: {}", s.trim());

   let n: i32 = grab_input("Give me an integer")
       .unwrap_or_else(|e| exit_err(&e, e.raw_os_error().unwrap_or(-1)))
       .trim()
       .parse()
       .unwrap_or_else(|e| exit_err(&e, 2));

   println!("You entered: {}", n);

}

fn grab_input(msg: &str) -> io::Result<String> {

   let mut buf = String::new();
   print!("{}: ", msg);
   try!(io::stdout().flush());

   try!(io::stdin().read_line(&mut buf));
   Ok(buf)

}

fn exit_err<T: Display>(msg: T, code: i32) -> ! {

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

}</lang>

Scala

<lang scala>print("Enter a number: ") val i=Console.readLong // Task says to enter 75000 print("Enter a string: ") val s=Console.readLine</lang>

Scheme

The read procedure is R5RS standard, inputs a scheme representation so, in order to read a string, one must enter "hello world" <lang scheme>(define str (read)) (define num (read)) (display "String = ") (display str) (display "Integer = ") (display num)</lang>

Seed7

<lang seed7>$ include "seed7_05.s7i";

const proc: main is func

 local
   var integer: integer_input is 0;
   var string: string_input is "";
 begin
   write("Enter an integer: ");
   readln(integer_input);
   write("Enter a string: ");
   readln(string_input);
 end func;</lang>

Sidef

Using the read(Type) built-in function: <lang ruby>var s = read(String); var i = read(Number); # auto-conversion to a number</lang>

or using the Sys.readln(msg) method: <lang ruby>var s = Sys.readln("Enter a string: "); var i = Sys.readln("Enter a number: ").to_i;</lang>

Slate

<lang slate>print: (query: 'Enter a String: '). [| n |

 n: (Integer readFrom: (query: 'Enter an Integer: ')).
 (n is: Integer)
   ifTrue: [print: n]
   ifFalse: [inform: 'Not an integer: ' ; n printString]

] do.</lang>

Smalltalk

<lang smalltalk>'Enter a number: ' display. a := stdin nextLine asInteger.

'Enter a string: ' display. b := stdin nextLine.</lang>

smart BASIC

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

<lang qbasic>INPUT "Enter a string.":a$ INPUT "Enter the value 75000.":n</lang>

SNOBOL4

<lang snobol4> output = "Enter a string:"

    str = trim(input)
    output = "Enter an integer:"
    int = trim(input)
    output = "String: " str " Integer: " int

end</lang>

SPL

In SPL all console input is text, so number should be converted from text using #.val function. <lang spl>text = #.input("Input a string") number = #.val(#.input("Input a number"))</lang>

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>

Swift

Works with: Swift version 2.x+

<lang swift>print("Enter a string: ", terminator: "") if let str = readLine() {

 print(str)

}</lang>

Works with: Swift version 5.x+

<lang swift>print("Enter a string: ", terminator: "") guard let str = readLine() else {

   fatalError("Nothing read!")

} print(str) print("Enter a number: ", terminator: "") guard let nstr = readLine(), let num = Int(nstr) else {

   fatalError("Not a number!")

} print(num)</lang>

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 -strict $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>

Of course, it's nicer to wrap the primitives in a procedure: <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>

TI-83 BASIC

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

 :Input "Enter a string:",Str1
 :Prompt i
 :If(i ≠ 75000): Then
 :Disp "That isn't 75000"
 :Else
 :Stop

</lang>

TI-89 BASIC

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

<lang ti89b>Prgm

 InputStr "Enter a string", s
 Loop
   Prompt integer
   If integer ≠ 75000 Then
     Disp "That wasn't 75000."
   Else
     Exit
   EndIf
 EndLoop

EndPrgm</lang>

Toka

<lang 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</lang>

TUSCRIPT

<lang tuscript> $$ MODE TUSCRIPT LOOP ASK "Enter a string": str="" ASK "Enter an integer": int="" IF (int=='digits') THEN PRINT "int=",int," str=",str EXIT ELSE PRINT/ERROR int," is not an integer" CYCLE ENDIF ENDLOOP </lang> Output:

Enter a string >a
Enter an integer >a
@@@@@@@@  a is not an integer                                          @@@@@@@@
Enter a string >a
Enter an integer >1
int=1 str=a

UNIX Shell

Works with: Bourne Shell

<lang bash>#!/bin/sh

read string read integer read -p 'Enter a number: ' number echo "The number is $number"</lang>

Ursa

<lang ursa>#

user input

in ursa, the type of data expected must be specified

decl string str decl int i

out "input a string: " console set str (in string console) out "input an int: " console set i (in int console)

out "you entered " str " and " i endl console</lang>

VBA

<lang vb>Public Sub text()

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

End Sub</lang>

Vedit macro language

<lang vedit>Get_Input(1, "Enter a string: ")

2 = Get_Num("Enter a number: ")</lang>

Visual Basic .NET

Platform: .NET

Works with: Visual Basic .NET version 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>

Wee Basic

<lang>print 1 "Enter a string." input string$ print 1 "Enter an integer." input integer</lang>

Wren

<lang ecmascript>import "io" for Stdin, Stdout

var string while (true) {

   System.write("Enter a string : ")
   Stdout.flush()
   string = Stdin.readLine()
   if (string.count == 0) {
       System.print("String cannot be empty, try again.")
   } else {
       break
   }

}

var number while (true) {

   System.write("Enter a number : ")
   Stdout.flush()
   number = Num.fromString(Stdin.readLine())
   if (!number || !number.isInteger) {
       System.print("Please enter a vaid integer, try again.")
   } else {
       break
   }

}

System.print("\nYou entered:") System.print(" string: %(string)") System.print(" number: %(number)")</lang>

Output:

Enter a string : Rosetta Code
Enter a number : 75000

You entered:
  string: Rosetta Code
  number: 75000

XLISP

READ-LINE reads a line of input as a string; READ reads an expression, of arbitrary complexity. <lang scheme>(display "Enter a string: ") (define s (read-line)) (display "Yes, ") (write s) (display " is a string.") ;; no need to verify, because READ-LINE has to return a string (newline) (display "Now enter the integer 75000: ") (define n (read)) (display

   (cond
       ((not (integerp n))
           "That's not even an integer." )
       ((/= n 75000)
           "That is not the integer 75000." )
       (t
           "Yes, that is the integer 75000." ) ) )</lang>

Output:

Enter a string: Rosetta Code
Yes, "Rosetta Code" is a string.
Now enter the integer 75000: 75000
Yes, that is the integer 75000.

XPL0

When the ChIn(0) intrinsic is first called, it collects characters from the keyboard until the Enter key is struck. It then returns to the XPL0 program where one character is pulled from the buffer each time ChIn(0) is called. When the Enter key (which is the same as a carriage return, $0D) is pulled, the program quits the loop. A zero byte is stored in place of the Enter key to mark the end of the string.

<lang XPL0>string 0; \use zero-terminated strings, instead of MSb terminated include c:\cxpl\codes; int I; char Name(128); \the keyboard buffer limits input to 128 characters

[Text(0, "What's your name? "); I:= 0; loop [Name(I):= ChIn(0); \buffered keyboard input

       if Name(I) = $0D\CR\ then quit;         \Carriage Return = Enter key
       I:= I+1;
       ];

Name(I):= 0; \terminate string Text(0, "Howdy "); Text(0, Name); Text(0, "! Now please enter ^"75000^": "); IntOut(0, IntIn(0)); CrLf(0); \echo the number ]</lang>

Example output:

What's your name? Loren Blaney
Howdy Loren Blaney! Now please enter "75000": 75000
75000

zkl

<lang zkl>str:=ask("Gimmie a string: "); n:=ask("Type 75000: ").toInt();</lang>

ZX Spectrum Basic

<lang basic>10 INPUT "Enter a string:"; s$ 20 INPUT "Enter a number: "; n</lang>