One place for hosting & domains

      Program

      How To Write Your First PHP Program


      The author selected Open Sourcing Mental Illness Ltd to receive a donation as part of the Write for DOnations program.

      Introduction

      The “Hello, World!” program is a classic and time-honored tradition in computer programming. Serving as a complete first program for beginners and a good program to test systems and programming environments, “Hello, World!” illustrates the basic syntax of programming languages.

      This tutorial will walk you through writing a “Hello, World!” program in PHP. You’ll also learn about opening and closing PHP code blocks within your code and using different types of comments in your code.

      Prerequisites

      You will need PHP installed as well as a local programming environment set up on your computer.

      To set this up, follow the How to Install PHP 7.4 and Set Up a Local Development Environment for your operating system.

      Writing the “Hello, World!” Program

      To write the “Hello, World!” program, start by opening a command-line text editor, such as nano, and create a new file:

      Once the text file opens up in the terminal window, type out the program:

      hello.php

      <?php
      echo "Hello, World!";
      ?>
      

      Let’s break down the different components of the code.

      All PHP code falls within a PHP Code Block, starting with <?php and ending with ?>.

      echo is a language construct. Its arguments are a list of expressions following the echo keyword, separated by commas and not delimited by parentheses. echo tells PHP to display or output whatever is included between echo and the ending semicolon ;.

      Between the echo and the ; is a sequence of characters — Hello, World! — that is enclosed in quotation marks. Any characters that are inside quotation marks are called a string.

      After writing the program, hold down the CTRL key and press the X key to exit nano. When prompted to save the file, press Y.

      Once you exit nano, you’ll return to your shell.

      With that, you have written your “Hello, World!” program.

      Running the “Hello, World!” Program

      With your “Hello, World!” program written, you’re ready to run the program. Use the php command along with the name of the program file as follows:

      Running the hello.php program that you just created will cause your terminal to produce the following output:

      Output

      Hello, World!

      Let’s go over what the program did in more detail.

      PHP executed the line echo "Hello, World!"; by calling the language construct echo. The string value of Hello, World! was passed to the construct.

      In this example, the string Hello, World! is also called an argument since it is a value that is passed to another part of the code, such as a construct or a function.

      The quotes that are on either side of Hello, World! were not output to the screen because they are used to tell PHP that this section of code contains a string. The quotation marks delineate where the string begins and ends.

      Since the program ran successfully, you can now confirm that PHP is properly installed and that the program is syntactically correct. Before going any further in the code itself, let’s take a closer look at the PHP Code Block.

      Working Outside the PHP Code Block

      Within a .php file, anything outside of the PHP tags is treated as HTML or plain text. The PHP language was originally written as a way to extend the functionality of HTML. With this in mind, you may include multiple PHP code blocks throughout a file. Anything outside the code block will render as HTML or plain text.

      Update your hello.php file:

      hello.php

      Hi Sammy
      <?php echo "Hello, World!"; ?>
      
      How are you doing?
      <?php echo "Swimmingly!";
      

      Save the file and rerun it:

      Output

      Hi Sammy Hello, World! How are you doing? Swimmingly!

      Diving into the code, you’ll notice that Hi Sammy and How are you doing? are both outside the PHP code blocks and therefore render as plain text when running the program.

      This file contains two PHP code blocks. The first code block includes both the starting and ending tags, while the second code block, being at the end of the file, leaves off the final closing tag.

      Including the closing block tag ?> is not required. When ending a file with a PHP code block, it is recommended to leave off the closing tag. Any character, even a blank space, which is rendered after the closing tag will be output to the screen as HTML or plain text. This can cause unexpected consequences with the function of your application because certain functionality, such as a redirect, will not process if anything has been output to the browser. When writing a file that contains only PHP code, never include the closing PHP tag.

      As code gets more complicated, like when splitting concepts over multiple code blocks, it can be beneficial to leave notes for ourselves and others. You can do this through the use of comments.

      A comment in code is a line that will not execute as a part of the program. Its only purpose is to be read by a human who is looking at the code. One thing that comes as a shock to many developers is how much time is spent reading code versus writing code. This means it’s essential to have code that is as easy to read as possible. You can accomplish this in a few ways:

      • Use coding standards. These are a collection of guidelines and best practices for organizing and formatting code clearly and consistently. In PHP, the most common coding standards are those developed by the PHP-FIG (Framework Interop Group).
      • Choose ease of reading over ease of writing. Use descriptive variables over short variables. It’s not about how many lines of code your write, but how long it will take someone to read those lines and understand what’s going on.
      • Comment for clarity. While it isn’t a hard and fast rule, if you’ve followed the previous two bullet points, your code should explain what is happening, while the comments explain why something is happening the way it is.

      When writing comments in PHP, there are two types of comments: single-line comments and multiline comments. Single line comments can start at any point on a line and end at either the end of the line or the end of the code block, whichever comes first.

      The most common way to start a single-line comment is with the double forward slash (//), although PHP also recognizes a hash sign (#) as a valid start to a single-line comment:

      hello.php

      Hi Sammy
      <?php echo "Hello"; //, World!"; ?>
      
      How are you doing?
      <?php echo "Swimmingly!";
      // other options: Floating along
      

      Save the file and run it again:

      Output

      Hi Sammy Hello How are you doing? Swimmingly!

      The first comment starts in the middle of a line. A closing quote and semicolon were added after "Hello" and the rest of the line was commented out. Commenting out one or more lines of code is often used in debugging to test how the code responds if certain elements are removed.

      You use a second comment to give a secondary option for an answer. The next step in your project may be to respond with one of several different options each time you execute the application. The comment is used as a reminder for other options that could be added.

      Multiline comments start with /* and end with */. The PHP interpreter will ignore any text or code within those characters. To provide more options, let’s change the last line to a multi-line comment:

      hello.php

      Hi Sammy
      <?php echo "Hello"; //, World!"; ?>
      
      How are you doing?
      <?php echo "Swimmingly!";
      /* When responding with one of a number of answers, here are some other options:
      * Floating along
      * Fin-tastic
      * Going with the flow
      * Treading water
      * Swamped
      */
      

      Using a multi-line comment gives more room to add detail or formatting to once again make the code, and the intention of the code, easier to understand. This multi-line comment includes line breaks and added * as a delineator for a list. The */ combination signifies the end of our comment block.

      Using DocBlocks for Documentation

      There is a special type of multi-line comment called a DocBlock. This is a unique way of documenting the functionality of a particular file, class, method, or other structural elements. Although a DocBlock starts and ends like any other multi-line comment /* */, they are designed to give specific detail for working with an element. Not only do these details provide an overview of the code for developers, but they may also be used by a code editor (or IDE) to provide suggestions and validation.

      A DocBlock consists of several parts. The first is a brief summary to introduce the element and a longer description if more context is needed.

      The final section that makes a DocBlock unique is for tags and annotations. These provide a way to succinctly and uniformly provide meta-information about the associated element. Tags can, for example, describe the type of information that is accepted or returned by a method or function. It may also provide details about the author or copyright of a file:

      hello.php

      <?php
      /**
       * DocBlock example
       *
       * @author Sammy <sammy@digitalocean.com>
       */
       ...
      

      While you should strive to write code that is clear and easy to follow, adding clarifying comments can add additional context that will increase the understanding of the code and the choices behind the code.

      Conclusion

      In this tutorial, you have written the “Hello, World!” program in PHP. You learned about opening and closing PHP code blocks within your code and using different comments to clarify and add context as your code gets more complicated. From here, you can continue learning by following the How To Work with Strings in PHP tutorial.



      Source link

      How To Write and Run Your First Program in Node.js


      The author selected the Open Internet/Free Speech Fund to receive a donation as part of the Write for DOnations program.

      Introduction

      Node.js is a popular open-source runtime environment that can execute JavaScript outside of the browser using the V8 JavaScript engine, which is the same engine used to power the Google Chrome web browser’s JavaScript execution. The Node runtime is commonly used to create command line tools and web servers.

      Learning Node.js will allow you to write your front-end code and your back-end code in the same language. Using JavaScript throughout your entire stack can help reduce time for context switching, and libraries are more easily shared between your back-end server and front-end projects.

      Also, thanks to its support for asynchronous execution, Node.js excels at I/O-intensive tasks, which is what makes it so suitable for the web. Real-time applications, like video streaming, or applications that continuously send and receive data, can run more efficiently when written in Node.js.

      In this tutorial you’ll create your first program with the Node.js runtime. You’ll be introduced to a few Node-specific concepts and build your way up to create a program that helps users inspect environment variables on their system. To do this, you’ll learn how to output strings to the console, receive input from the user, and access environment variables.

      Prerequisites

      To complete this tutorial, you will need:

      Step 1 — Outputting to the Console

      To write a “Hello, World!” program, open up a command line text editor such as nano and create a new file:

      With the text editor opened, enter the following code:

      hello.js

      console.log("Hello World");
      

      The console object in Node.js provides simple methods to write to stdout, stderr, or to any other Node.js stream, which in most cases is the command line. The log method prints to the stdout stream, so you can see it in your console.

      In the context of Node.js, streams are objects that can either receive data, like the stdout stream, or objects that can output data, like a network socket or a file. In the case of the stdout and stderr streams, any data sent to them will then be shown in the console. One of the great things about streams is that they're easily redirected, in which case you can redirect the output of your program to a file, for example.

      Save and exit nano by pressing CTRL+X, when prompted to save the file, press Y. Now your program is ready to run.

      Step 2 — Running the Program

      To run this program, use the node command as follows:

      The hello.js program will execute and display the following output:

      Output

      Hello World

      The Node.js interpreter read the file and executed console.log("Hello World"); by calling the log method of the global console object. The string "Hello World" was passed as an argument to the log function.

      Although quotation marks are necessary in the code to indicate that the text is a string, they are not printed to the screen.

      Having confirmed that the program works, let's make it more interactive.

      Step 3 — Receiving User Input via Command Line Arguments

      Every time you run the Node.js “Hello, World!” program, it produces the same output. In order to make the program more dynamic, let's get input from the user and display it on the screen.

      Command line tools often accept various arguments that modify their behavior. For example, running node with the --version argument prints the installed version instead of running the interpreter. In this step, you will make your code accept user input via command line arguments.

      Create a new file arguments.js with nano:

      Enter the following code:

      arguments.js

      console.log(process.argv);
      

      The process object is a global Node.js object that contains functions and data all related to the currently running Node.js process. The argv property is an array of strings containing all the command line arguments given to a program.

      Save and exit nano by typing CTRL+X, when prompted to save the file, press Y.

      Now when you run this program, you provide a command line argument like this:

      • node arguments.js hello world

      The output looks like the following:

      Output

      [ '/usr/bin/node', '/home/sammy/first-program/arguments.js', 'hello', 'world' ]

      The first argument in the process.argv array is always the location of the Node.js binary that is running the program. The second argument is always the location of the file being run. The remaining arguments are what the user entered, in this case: hello and world.

      We are mostly interested in the arguments that the user entered, not the default ones that Node.js provides. Open the arguments.js file for editing:

      Change console.log(process.arg); to the following:

      arguments.js

      console.log(process.argv.slice(2));
      

      Because argv is an array, you can use JavaScript's built-in slice method that returns a selection of elements. When you provide the slice function with 2 as its argument, you get all the elements of argv that comes after its second element; that is, the arguments the user entered.

      Re-run the program with the node command and the same arguments as last time:

      • node arguments.js hello world

      Now, the output looks like this:

      Output

      [ 'hello', 'world' ]

      Now that you can collect input from the user, let's collect input from the program's environment.

      Step 4 — Accessing Environment Variables

      Environment variables are key-value data stored outside of a program and provided by the OS. They are typically set by the system or user and are available to all running processes for configuration or state purposes. You can use Node's process object to access them.

      Use nano to create a new file environment.js:

      Add the following code:

      environment.js

      console.log(process.env);
      

      The env object stores all the environment variables that are available when Node.js is running the program.

      Save and exit like before, and run the environment.js file with the node command.

      Upon running the program, you should see output similar to the following:

      Output

      { SHELL: '/bin/bash', SESSION_MANAGER: 'local/digitalocean:@/tmp/.ICE-unix/1003,unix/digitalocean:/tmp/.ICE-unix/1003', COLORTERM: 'truecolor', SSH_AUTH_SOCK: '/run/user/1000/keyring/ssh', XMODIFIERS: '@im=ibus', DESKTOP_SESSION: 'ubuntu', SSH_AGENT_PID: '1150', PWD: '/home/sammy/first-program', LOGNAME: 'sammy', GPG_AGENT_INFO: '/run/user/1000/gnupg/S.gpg-agent:0:1', GJS_DEBUG_TOPICS: 'JS ERROR;JS LOG', WINDOWPATH: '2', HOME: '/home/sammy', USERNAME: 'sammy', IM_CONFIG_PHASE: '2', LANG: 'en_US.UTF-8', VTE_VERSION: '5601', CLUTTER_IM_MODULE: 'xim', GJS_DEBUG_OUTPUT: 'stderr', LESSCLOSE: '/usr/bin/lesspipe %s %s', TERM: 'xterm-256color', LESSOPEN: '| /usr/bin/lesspipe %s', USER: 'sammy', DISPLAY: ':0', SHLVL: '1', PATH: '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin', DBUS_SESSION_BUS_ADDRESS: 'unix:path=/run/user/1000/bus', _: '/usr/bin/node', OLDPWD: '/home/sammy' }

      Keep in mind that many of the environment variables you see are dependent on the configuration and settings of your system, and your output may look substantially different than what you see here. Rather than viewing a long list of environment variables, you might want to retrieve a specific one.

      Step 5 — Accessing a Specified Environment Variable

      In this step you'll view environment variables and their values using the global process.env object and print their values to the console.

      The process.env object is a simple mapping between environment variable names and their values stored as strings. Like all objects in JavaScript, you access an individual property by referencing its name in square brackets.

      Open the environment.js file for editing:

      Change console.log(process.env); to:

      environment.js

      console.log(process.env["HOME"]);
      

      Save the file and exit. Now run the environment.js program:

      The output now looks like this:

      Output

      /home/sammy

      Instead of printing the entire object, you now only print the HOME property of process.env, which stores the value of the $HOME environment variable.

      Again, keep in mind that the output from this code will likely be different than what you see here because it is specific to your system. Now that you can specify the environment variable to retrieve, you can enhance your program by asking the user for the variable they want to see.

      Step 6 — Retrieving An Argument in Response to User Input

      Next, you'll use the ability to read command line arguments and environment variables to create a command line utility that prints the value of an environment variable to the screen.

      Use nano to create a new file echo.js:

      Add the following code:

      echo.js

      const args = process.argv.slice(2);
      console.log(process.env[args[0]]);
      

      The first line of echo.js stores all the command line arguments that the user provided into a constant variable called args. The second line prints the environment variable stored in the first element of args; that is, the first command line argument the user provided.

      Save and exit nano, then run the program as follows:

      Now, the output would be:

      Output

      /home/sammy

      The argument HOME was saved to the args array, which was then used to find its value in the environment via the process.env object.

      At this point you can now access the value of any environment variable on your system. To verify this, try viewing the following variables: PWD, USER, PATH.

      Retrieving single variables is good, but letting the user specify how many variables they want would be better.

      Step 7 — Viewing Multiple Environment Variables

      Currently, the application can only inspect one environment variable at a time. It would be useful if we could accept multiple command line arguments and get their corresponding value in the environment. Use nano to edit echo.js:

      Edit the file so that it has the following code instead:

      echo.js

      const args = process.argv.slice(2);
      
      args.forEach(arg => {
        console.log(process.env[arg]);
      });
      

      The forEach method is a standard JavaScript method on all array objects. It accepts a callback function that is used as it iterates over every element of the array. You use forEach on the args array, providing it a callback function that prints the current argument's value in the environment.

      Save and exit the file. Now re-run the program with two arguments:

      You would see the following output:

      Output

      /home/sammy /home/sammy/first-program

      The forEach function ensures that every command line argument in the args array is printed.

      Now you have a way to retrieve the variables the user asks for, but we still need to handle the case where the user enters bad data.

      Step 8 — Handling Undefined Input

      To see what happens if you give the program an argument that is not a valid environment variable, run the following:

      • node echo.js HOME PWD NOT_DEFINED

      The output will look similar to the following:

      Output

      /home/sammy /home/sammy/first-program undefined

      The first two lines print as expected, and the last line only has undefined. In JavaScript, an undefined value means that a variable or property has not been assigned a value. Because NOT_DEFINED is not a valid environment variable, it is shown as undefined.

      It would be more helpful to a user to see an error message if their command line argument was not found in the environment.

      Open echo.js for editing:

      Edit echo.js so that it has the following code:

      echo.js

      const args = process.argv.slice(2);
      
      args.forEach(arg => {
        let envVar = process.env[arg];
        if (envVar === undefined) {
          console.error(`Could not find "${arg}" in environment`);
        } else {
          console.log(envVar);
        }
      });
      

      Here, you have modified the callback function provided to forEach to do the following things:

      1. Get the command line argument's value in the environment and store it in a variable envVar.
      2. Check if the value of envVar is undefined.
      3. If the envVar is undefined, then we print a helpful message indicating that it could not be found.
      4. If an environment variable was found, we print its value.

      Note: The console.error function prints a message to the screen via the stderr stream, whereas console.log prints to the screen via the stdout stream. When you run this program via the command line, you won't notice the difference between the stdout and stderr streams, but it is good practice to print errors via the stderr stream so that they can be easier identified and processed by other programs, which can tell the difference.

      Now run the following command once more:

      • node echo.js HOME PWD NOT_DEFINED

      This time the output will be:

      Output

      /home/sammy /home/sammy/first-program Could not find "NOT_DEFINED" in environment

      Now when you provide a command line argument that's not an environment variable, you get a clear error message stating so.

      Conclusion

      Your first program displayed "Hello World" to the screen, and now you have written a Node.js command line utility that reads user arguments to display environment variables.

      If you want to take this further, you can change the behavior of this program even more. For example, you may want to validate the command line arguments before you print. If an argument is undefined, you can return an error, and the user will only get output if all arguments are valid environment variables.



      Source link

      How To Write Your First Program in Go


      Introduction

      The “Hello, World!” program is a classic and time-honored tradition in computer programming. It’s a simple and complete first program for beginners, and it’s a good way to make sure your environment is properly configured.

      This tutorial will walk you through creating this program in Go. However, to make the program more interesting, you’ll modify the traditional “Hello, World!” program so that it asks the user for their name. You’ll then use the name in the greeting. When you’re done with the tutorial, you’ll have a program that looks like this when you run it:

      Output

      Please enter your name. Sammy Hello, Sammy! I'm Go!

      Prerequisites

      Before you begin this tutorial, you will need a local Go development environment set up on your computer. You can set this up by following one of these tutorials:

      Step 1 — Writing the Basic “Hello, World!” Program

      To write the “Hello, World!” program, open up a command-line text editor such as nano and create a new file:

      Once the text file opens up in the terminal window, you’ll type out your program:

      hello.go

      package main
      
      import "fmt"
      
      func main() {
        fmt.Println("Hello, World!")
      }
      

      Let’s break down the different components of the code.

      package is a Go keyword that defines which code bundle this file belongs to. There can be only one package per folder, and each .go file has to declare the same package name at the top of its file. In this example, the code belongs to the main package.

      import is a Go keyword that tells the Go compiler which other packages you want to use in this file. Here you import the fmt package that comes with the standard library. The fmt package provides formatting and printing functions that can be useful when developing.

      fmt.Println is a Go function, found in the fmt package, that tells the computer to print some text to the screen.

      You follow the fmt.Println function by a sequence of characters, like "Hello, World!", enclosed in quotation marks. Any characters that are inside of quotation marks are called a string. The fmt.Println function will print this string to the screen when the program runs.

      Save and exit nano by typing CTRL + X, when prompted to save the file, press Y.

      Now you can try your program.

      Step 2 — Running a Go Program

      With your “Hello, World!” program written, you're ready to run the program. You’ll use the go command, followed by the name of the file you just created.

      The program will execute and display this output:

      Output

      Hello, World!

      Let's explore what actually happened.

      Go programs need to compile before they run. When you call go run with the name of a file, in this case hello.go, the go command will compile the application and then run the resulting binary. For programs written in compiled programming languages, a compiler will take the code from a program and generate another type of lower-level code (such as source code or machine code) to produce an executable program.

      Go applications require a main package and exactly one main() function that serves as the entry point for the application. The main function takes no arguments and returns no values. Instead it tells the Go compiler that the package should be compiled as an executable package.

      Once compiled, the code executes by entering the main() function in the main package. It executes the line fmt.Println("Hello, World!") by calling the fmt.Println function. The string value of Hello, World! is then passed to the function. In this example, the string Hello, World! is also called an argument since it is a value that is passed to a method.

      The quotes that are on either side of Hello, World! are not printed to the screen because you use them to tell Go where your string begins and ends.

      In this step, you've created a working "Hello, World!" program with Go. In the next step, you will explore how to make the program more interactive.

      Step 3 — Prompting for User Input

      Every time you run your program, it produces the same output. In this step, you can add to your program to prompt the user for their name. You'll then use their name in the output.

      Instead of modifying your existing program, create a new program called greeting.go with the nano editor:

      First, add this code, which prompts the user to enter their name:

      greeting.go

      package main
      
      import (
          "fmt"
      )
      
      func main() {
        fmt.Println("Please enter your name.")
      }
      

      Once again, you use the fmt.Println function to print some text to the screen.

      Now add the highlighted line to store the user's input:

      greeting.go

      package main
      
      import (
          "fmt"
      )
      
      func main() {
        fmt.Println("Please enter your name.")
        var name string
      }
      

      The var name string line will create a new variable using the var keyword. You name the variable name, and it will be of type string.

      Then, add the highlighted line to capture the user's input:

      greeting.go

      package main
      
      import (
          "fmt"
      )
      
      func main() {
        fmt.Println("Please enter your name.")
        var name string
        fmt.Scanln(&name)
      }
      

      The fmt.Scanln method tells the computer to wait for input from the keyboard ending with a new line or (n), character. This pauses the program, allowing the user to enter any text they want. The program will continue when the user presses the ENTER key on their keyboard. All of the keystrokes, including the ENTER keystroke, are then captured and converted to a string of characters.

      You want to use those characters in your program's output, so you save those characters by writing them into the string variable called name. Go stores that string in your computer's memory until the program finishes running.

      Finally, add the following highlighted line in your program to print the output:

      greeting.go

      package main
      
      import (
          "fmt"
      )
      
      func main() {
        fmt.Println("Please enter your name.")
        var name string
        fmt.Scanln(&name)
        fmt.Printf("Hi, %s! I'm Go!", name)
      }
      

      This time, instead of using the fmt.Println method again, you're using fmt.Printf. The fmt.Printf function takes a string, and using special printing verbs, (%s), it injects the value of name into the string. You do this because Go does not support string interpolation, which would let you take the value assigned to a variable and place it inside of a string.

      Save and exit nano by pressing CTRL + X, and press Y when prompted to save the file.

      Now run the program. You'll be prompted for your name, so enter it and press ENTER. The output might not be exactly what you expect:

      Output

      Please enter your name. Sammy Hi, Sammy ! I'm Go!

      Instead of Hi, Sammy! I'm Go!, there's a line break right after the name.

      The program captured all of our keystrokes, including the ENTER key that we pressed to tell the program to continue. In a string, pressing the ENTER key creates a special character that creates a new line. The program's output is doing exactly what you told it to do; it's displaying the text you entered, including that new line. It's not what you expected the output to be, but you can fix it with additional functions.

      Open the greeting.go file in your editor:

      Locate this line in your program:

      greeting.go

      ...
      fmt.Scanln(&name)
      ...
      

      Add the following line right after it:

      greeting.go

      name = strings.TrimSpace(name)
      

      This uses the TrimSpace function, from Go's standard library strings package, on the string that you captured with fmt.Scanln. The strings.TrimSpace function removes any space characters, including new lines, from the start and end of a string. In this case, it removes the newline character at the end of the string created when you pressed ENTER.

      To use the strings package you need to import it at the top of the program.

      Locate these lines in your program:

      greeting.go

      import (
          "fmt"
      )
      

      Add the following line to import the strings package:

      greeting.go

      import (
          "fmt"
        "strings"
      )
      

      Your program will now contain the following:

      greeting.go

      package main
      
      import (
              "fmt"
              "strings"
      )
      
      func main() {
          fmt.Println("Please enter your name.")
          var name string
          fmt.Scanln(&name)
          fmt.Printf("Hi, %s! I'm Go!", name)
          name = strings.TrimSpace(name)
      }
      

      Save and exit nano. Press CTRL + X, then press Y when prompted to save the file.

      Run the program again:

      This time, after you enter your name and press ENTER, you get the expected output:

      Output

      Please enter your name. Sammy Hi, Sammy! I'm Go!

      You now have a Go program that takes input from a user and prints it back to the screen.

      Conclusion

      In this tutorial, you wrote a "Hello, World!" program that takes input from a user, processes the results, and displays the output. Now that you have a basic program to work with, try to expand your program further. For example, ask for the user's favorite color, and have the program say that its favorite color is red. You might even try to use this same technique to create a simple Mad-Lib program.



      Source link