Hello world go: Go by Example: Hello World

01.06.202120.03.2021 No Comments

Содержание

Создание вашей первой программы на Go

Введение

“Hello, World!” — это классическая программа, традиционно используемая в компьютерном программировании. Это простая и полноценная первая программа для начинающих, и с ее помощью легко определить, что среда настроена правильно.

В этом обучающем руководстве мы подробно рассмотрим создание этой программы на языке Go. Чтобы сделать программу поинтереснее, мы изменим традиционную программу “Hello, World!” так, чтобы она запрашивала имя пользователя. Затем это имя можно будет использовать в приветствии. После завершения этого обучающего модуля у вас будет программа, которая будет выглядеть при запуске следующим образом:

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

Предварительные требования

Для начала прохождения этого обучающего модуля на вашем компьютере должна быть настроена локальная среда разработки Go. Вы можете настроить ее, следуя указаниям одного из следующих обучающих руководств:

Шаг 1 — Написание простой программы “Hello, World!”

Чтобы написать программу “Hello, World!”, откройте nano или другой текстовый редактор командной строки и создайте новый файл:

Когда текстовый файл откроется в окне терминала, мы напишем нашу программу:

hello.go

package main

import "fmt"

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

Давайте обсудим отдельные компоненты кода.

package — это ключевое слово Go, определяющее, к какому пакету кода принадлежит данный файл. Для каждой папки может иметься только один покет, и в начале каждого файла .go должно декларироваться имя того же пакета. В этом примере код принадлежит пакету main.

import — это ключевое слово Go, указыващее компилятору Go, какие другие пакеты вы хотите использовать в этом файле. Здесь вы импортируете пакет fmt из стандартной библиотеки. Пакет fmt содержит функции форматирования и вывода, которые могут быть полезны при разработке.

fmt.Println — это функция Go из пакета fmt, которая предписывает компьютеру вывести текст на экран.

После функции fmt.Println идет последовательность символов в кавычках, например "Hello, World!". Любые символы внутри кавычек называются строкой. Функция fmt.Println выведет эту строку на экран при выполнении программы.

Сохраните файл и закройте nano, нажав CTRL + X. Когда вам будет предложено сохранить файл, нажмите Y.

Теперь вы можете проверить программу в действии.

`Шаг 2 — Запуск программы в Go`

После написания программы “Hello, World!” вы можете ее запустить. Для этого используется команда go, после которой идет имя только что созданного файла.

Программа будет исполнена и выведет на экран следующее:

OutputHello, World!

Посмотрим, что фактически произошло.

Перед запуском программы Go требуют компиляции. При вызове go run с именем файла, в данном случае hello.go, команда go компилирует приложение и запускает полученный двоичный файл. Если программа написана на компилируемом языке программирования, компилятор берет исходный код программы и генерирует другой тип кода низкого уровня (например, машинный код) для получения исполняемой программы.

Приложения Go должны иметь пакет main и ровно одну функцию main(), которая будет выступать в качестве точки входа приложения. Функция main не принимает аргументов и не возвращает никаких значений. Вместо этого она сообщает компилятору Go, что пакет должен быть скомпилирован как исполняемый пакет.

После компиляции код запускается посредством входа в функцию main() в пакете main. Программа выполняет строку fmt.Println("Hello, World!") , вызывая функцию fmt.Println. Значение строки Hello, World! передается функции. В этом примере строка Hello, World! также называется аргументом, поскольку это значение, которое передается методу.

Кавычки, в которые заключена фраза Hello, World!, не выводятся на экране, поскольку они показывают Go, где начинается и кончается ваша строка.

На этом шаге вы создали работающую программу “Hello, World!” с помощью Go. На следующем шаге мы покажем, как сделать программу более интерактивной.

`Шаг 3 — Запрос ввода пользователя`

При каждом запуске программа дает один и тот же результат. На этом шаге вы добавите в программу запрос имени пользователя. Затем это имя можно будет использовать в выводимых результатах.

Вместо изменения существующей программы создайте новую программу greeting.go с помощью редактора nano:

Вначале добавьте этот код, который предлагает пользователю ввести имя:

greeting.go

package main

import (
    "fmt"
)

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

Затем используйте функцию fmt.Println для вывода текста на экран.

Затем добавьте выделенную строку для сохранения введенных пользователем данных:

greeting.go

package main

import (
    "fmt"
)

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

Строка var name string создаст новую переменную с помощью ключевого слова var. Мы присваиваем этой переменной имя name, и она имеет тип string.

Затем добавьте выделенную строку для записи вводимых пользователем данных:

greeting.go

package main

import (
    "fmt"
)

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

Метод fmt.Scanln предписывает компьютеру ожидать ввода данных с клавиатуры, заканчивающегося символом новой строки или (\n). Это приостанавливает выполнение программы, позволяя пользователю ввести любой желаемый текст. Программа продолжит выполнение, когда пользователь нажмет клавишу ENTER на клавиатуре. Все нажатия клавиш, включая нажатие клавиши ENTER, регистрируются и конвертируются в строку символов.

Нам нужно использовать эти символы в выводимых программой результатах, и поэтому мы сохраним их, записав их в строковую переменную с именем name. Go хранит эту строку в памяти компьютера до завершения выполнения программы.

В заключение добавьте в программу следующую выделенную строчку для вывода результатов:

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

На этот раз вместо использования метода fmt.Println мы используем fmt.Printf. Функция fmt.Printf берет строку и использует специальные глаголы вывода (%s) для вставки значения name в строку. Мы делаем это так, потому что Go не поддерживает интерполяцию строк, при которой можно брать значение переменной и помещать его внутри строки.

Сохраните файл и закройте nano, нажав CTRL + X. Нажмите Y, когда вам будет предложено сохранить файл.

Запустите программу. Вам будет предложено ввести имя, так что введите его и нажмите ENTER. Результат может немного не соответствовать ожиданиям:

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

Вместо Hi, Sammy! I'm Go! после имени выводится разрыв строки.

Программа зарегистрировала все нажатия клавиш, включая клавишу ENTER, которую мы нажимаем, чтобы программа продолжила выполнение. При нажати клавиши ENTER создается специальный символ, которы создает новую строку. Программа делает именно то, что ей предписывается, то есть отображает введенный текст, включая символ новой строки. Это не то, чего вы ожидаете от вывода, но вы можете исправить проблему с помощью дополнительных функций.

Откройте файл greeting.go в редакторе:

Найдите в программе следующую строчку:

greeting.go

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

Добавьте после нее следующую строчку:

greeting.go

name = strings.TrimSpace(name)

Она использует функцию TrimSpace из стандартной библиотеки Go strings в строке, которую вы записали с помощью fmt.Scanln. Функция strings.TrimSpace удаляет символы пробела, в том числе символы новой строки в начале и конце строки. В данном случае будет удален символ новой строки в конце строки, созданный при нажатии клавиши ENTER.

Чтобы использовать пакет strings, его нужно импортировать в программу.

Найдите в программе следующие строки:

greeting.go

import (
    "fmt"
)

Добавьте следующую строку для импорта пакета strings:

greeting.go

import (
    "fmt"
  "strings"
)

Теперь программа будет содержать следующее:

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

Сохраните и закройте nano. Нажмите CTRL + X, а затем нажмите Y, когда вам будет предложено сохранить файл.

Запустите программу снова:

Теперь после ввода имени и нажатия клавиши ENTER выводится ожидаемый результат:

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

Теперь у вас имеется программа Go, которая принимает данные пользователя и выводит их на экран.

`Заключение`

В этом обучающем руководстве мы написали программу “Hello, World!”, которая принимает вводимые пользователем данные, обрабатывает результаты и выводит их на экран. Теперь у вас имеется базовая программа для работы, и вы можете попробовать дополнить и расширить ее. Например, вы можете спросить любимый цвет пользователя и сделать так, чтобы программа говорила, что его любимый цвет красный. Вы даже можете использовать эту же методику для создания простой программы Mad-Lib.

`Golang: установка и Hello, World`

Очень кратко — установка Golang, языка программирования от Google, и пример «Hello, World«.

Для установки Golang на RHEL-дистрибутивы — требуется репозиторий Epel:

$ sudo yum repolist enabled
...
epel                                 Extra Packages for Enterprise Linux 6 - x86_64                                 11689+165
epel-debuginfo              Extra Packages for Enterprise Linux 6 - x86_64 - Debug                  2167+24
...

Устанавливаем:

$ sudo yum install golang
....
(1/3): golang-1.5.1-0.el6.x86_64.rpm                                                                                                                                                                                  | 1.2 MB     00:00
(2/3): golang-bin-1.5.1-0.el6.x86_64.rpm                                                                                                                                                                              |  41 MB     00:06
(3/3): golang-src-1. 5.1-0.el6.noarch.rpm                                                                                                                                                                              | 3.7 MB     00:01
...

Проверяем:

$ which go
/usr/bin/go

Получение помощи:

 $ go help
Go is a tool for managing Go source code.

Usage:

        go command [arguments]

The commands are:

        build       compile packages and dependencies
...
        vet         run go tool vet on packages

Use "go help [command]" for more information about a command.

Additional help topics:

        c           calling between Go and C
...
        testfunc    description of testing functions

Use "go help [topic]" for more information about that topic.

Создаем файл с расширением .go с таким содержимым:

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

Запускаем:

$ go run hw.go
Hello, World.

Готово.

Ссылки по теме

https://tour.golang.org

http://www.tutorialspoint.com/go

Раздел: HOWTO’s Метки: Golang

`Go не работает пример hello world`

Я устанавливаю go в Ubuntu 14.04 и считаю, что мой GOPATH$ установлен правильно и, похоже, не может запустить этот файл go install hello.go. Я избавился от всех ошибок пути, с которыми столкнулся первым, но я все еще не вижу успешного запуска

Go устанавливается в /etc/go

$ go env
GOARCH="amd64"
GOBIN=""
GOCHAR="6"
GOEXE=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOOS="linux"
GOPATH="/etc/go/packages"
GORACE=""
GOROOT="/etc/go"
GOTOOLDIR="/etc/go/pkg/tool/linux_amd64"
CC="gcc"
GOGCCFLAGS="-fPIC -m64 -pthread -fmessage-length=0"
CXX="g++"
CGO_ENABLED="1"

И вот я сделал файл, отредактированный через nano, чтобы скопировать пример hello world, но когда я запускаю его, ничего не происходит. ..

$ mkdir -p $GOPATH/src/github.com/hackg
$ nano $GOPATH/src/github.com/hackg/hello/hello.go
$ go install github.com/hackg/hello
$

QUESTION-он должен отображать hello world там, доказывая, что Go правильно строит файлы, но все, что я получаю, — это свежее приглашение terminal, готовое к новой команде, без HELLO WORLD

Я попытался посмотреть другие сообщения stackoverflow, но безуспешно — ex Go, Golang : не имеет смысла, что у меня должны быть файлы перед импортом

go

ubuntu-14.04

Поделиться

Источник

hackg

19 марта 2016 в 05:42

`4 ответа`

Откуда взялся пример «Hello World!»? Возможный Дубликат : Откуда берется ‘Hello world’? Hello world! -это наиболее часто используемый пример, который я могу придумать, но я действительно не знаю, откуда он взялся. Был ли он использован какой-то конкретной книгой или просто распространился среди разработчиков? Люди писали…
Пример Hello world для инъекции зависимостей Существует много вариативности в том, что вытягивает Google, и ни один из них, похоже, не очень хорошо дистиллирует основы. Может ли кто-нибудь привести пример hello world инъекции зависимостей JavaScript. Я использовал DI в PHP, но без простой парадигмы класса-объекта мне трудно понять, как это…

4

Нет, эта команда не будет запускать вашу программу; go install просто сделал двоичный файл, который вы можете запустить с $GOPATH/bin/hello . Вы можете добавить к своему ~/.bashrc или эквиваленту строку export PATH=$GOPATH/bin:$PATH и открыть новый shell (например, закрыв и снова открыв свою программу terminal), так что вы можете вызвать его только с помощью hello . go run, когда файл будет скомпилирован и запущен, но разумно начать с go install , потому что это то, что вы собираетесь использовать для программ «real», а не для быстрых тестов.

(Похоже, вы находитесь на правильном пути с GOPATH и все такое, но для настройки среды Go в целом этот вопрос может оказаться полезным.)

Поделиться

twotwotwo

19 марта 2016 в 05:50

1

Я сделал следующее, И это прекрасно работает для меня. Вы можете попробовать это:-

Выполните следующую команду в вашем terminal:-

sudo apt-get install golang

Это позволит установить golang в вашей системе

Добавьте следующие строки в файл .bashrc:-

export GOPATH=$HOME/go
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin

Теперь закройте и откройте shell. И выполните следующую команду, чтобы проверить версию go, установленную в вашей системе:-

go version

Предположим, что hello.go — это ваш файл, содержащий программу hello world, а затем выполните следующие действия:-

go run hello.go

Надеюсь, это поможет.

Поделиться

a3.14_Infinity

19 марта 2016 в 06:02

0

Я понял это, я думал, что он будет запускать команду, а не просто устанавливать ее.

все, что мне нужно было сделать после установки, это набрать hello и нажать enter

$ hello
hello, world

Наверное, я плохо читал инструкции. спасибо твотвотво

Поделиться

hackg

19 марта 2016 в 06:03

Пример Hello World для SimplexSolver Я пытаюсь решить задачу оптимизации с помощью Apache Commons. Я нашел здесь пример Hello World для Commons Math 2. Но я хотел бы использовать Commons Math 3.2 и не смог найти ни одного примера того, как использовать эту часть кода: PointValuePair solution = null; SimplexSolver solver = new…
Как работает пример sinatra hello world? Где определяется метод ‘get’? И как это называется ни на каком объекте? require ‘sinatra’ get ‘/hi’ do Hello World! end Пример с домашней страницы http: / / www.sinatrarb.com/ .

0

Это дает инструкции, чтобы заставить ваш пример hello world работать.

Для компиляции и установки пакетов и зависимостей:

go install github.com/user/hello

Он поместит исполняемую команду hello (или hello.exe) в каталог bin вашего рабочего пространства.

Чтобы построить программу go в двоичные файлы:

go build github.com/user/hello

Бежать:

$ $GOPATH/bin/hello
hello, world

Поделиться

Apoorva Manjunath

19 марта 2016 в 06:51

`Похожие вопросы:`

TCPDF hello world пример использования composer

Каков минимальный пример hello world для TCPDF? Я вижу более 60 примеров в https://tcpdf.org/examples/ , и ни один из них не работает с композитором, и все они очень сложны. Я ищу что-то простое,…

Пример Xode 4.5 Hello World не работает

Я в значительной степени новичок XCode, и поэтому я попробовал пример Hello World, приведенный в документации XCode: краткое руководство по началу работы: учебник: использование Xcode для написания…

JSNI Hello World не работает

Я сделал простой пример Hello World GWT, используя JSNI. Он не делает ничего, кроме отображения сообщения. Это код в классе EntryPoint: public void onModuleLoad() { // TODO Auto-generated method. ..

Откуда взялся пример «Hello World!»?

Возможный Дубликат : Откуда берется ‘Hello world’? Hello world! -это наиболее часто используемый пример, который я могу придумать, но я действительно не знаю, откуда он взялся. Был ли он…

Пример Hello world для инъекции зависимостей

Существует много вариативности в том, что вытягивает Google, и ни один из них, похоже, не очень хорошо дистиллирует основы. Может ли кто-нибудь привести пример hello world инъекции зависимостей…

Пример Hello World для SimplexSolver

Я пытаюсь решить задачу оптимизации с помощью Apache Commons. Я нашел здесь пример Hello World для Commons Math 2. Но я хотел бы использовать Commons Math 3.2 и не смог найти ни одного примера того,…

Как работает пример sinatra hello world?

Где определяется метод ‘get’? И как это называется ни на каком объекте? require ‘sinatra’ get ‘/hi’ do Hello World! end Пример с домашней страницы http: / / www.sinatrarb.com/ .

Простой пример TCPClient/Listener («hello world»)

Все, что я ищу, — это простой пример TCPClient/Listener (hello world). Я новичок, и примеры классов Microsoft TCPClient/Listener-это не то, что я ищу. Все, что я ищу, — это TCPClient, чтобы…

мифрил hello world MVC пример не работает

У меня возникли проблемы с работой примера Mithril hello world MVC. Вот мой код, скопированный с домашней страницы Mitrhil . Обратите внимание, что единственное изменение, которое я сделал, состояло…

Пример Hello world не работает

Я следую учебнику для начинающих с Android Studio, и есть пример Hello World, подобный этому: package com.example.moi.scaleguess; import android.support.v7.app.AppCompatActivity; import…

`Руководство по выполнению скрипта «Hello world!» Скрипт Python — Azure Machine Learning`

000Z» data-article-date-source=»ms.date»>02/11/2021

Чтение занимает 4 мин

`В этой статье`

В рамках этого учебника вы узнаете, как использовать пакет SDK Машинного обучения Azure для Python, чтобы отправить и запустить скрипт Python «Hello world!»In this tutorial, you learn how to use the Azure Machine Learning SDK for Python to submit and run a Python «Hello world!» .script.

Этот учебник является второй частью серии учебников из четырех частей, в рамках которой вы ознакомитесь с основами Машинного обучения Azure и выполните задачи машинного обучения на основе заданий в Azure.This tutorial is part 2 of a four-part tutorial series in which you learn the fundamentals of Azure Machine Learning and complete jobs-based machine learning tasks in Azure. Этот учебник создан на основе работы, выполненной в рамках статьи Часть 1. Настройка локального компьютера для службы «Машинное обучение Azure».This tutorial builds on the work you completed in Part 1: Set up your local machine for Azure Machine Learning.

Выполняя данное руководство, вы сделаете следующее:In this tutorial, you will:

Создадите и запустите сценарий Python «Hello world!»Create and run a «Hello world!» локально.Python script locally.
Создадите сценарий элемента управления Python для отправки сценария «Hello world!»Create a Python control script to submit «Hello world!» в службу «Машинное обучение Azure».to Azure Machine Learning.
Примените концепции Машинного обучения Azure в сценарии элемента управления.Understand the Azure Machine Learning concepts in the control script.
Отправите и запустите сценарий «Hello World!»Submit and run the «Hello world!» .script.
просмотрите выходные данные кода в облаке;View your code output in the cloud.

`Предварительные требованияPrerequisites`

Выполнение инструкций части 1, если у вас еще нет рабочей области Машинного обучения Azure. Completion of part 1 if you don’t already have an Azure Machine Learning workspace.

`Создание и запуск скрипта Python в локальной средеCreate and run a Python script locally`

Создайте новый подкаталог с именем src в каталоге tutorial для хранения кода, который необходимо запустить в вычислительном кластере Машинного обучения Azure.Create a new subdirectory called src under the tutorial directory to store code that you want to run on an Azure Machine Learning compute cluster. В подкаталоге src создайте сценарий Python hello.py:In the src subdirectory, create the hello.py Python script:

# src/hello.py
print("Hello world!")

Теперь структура каталогов проекта будет выглядеть следующим образом:Your project directory structure will now look like:

`Тестирование скрипта в локальной средеTest your script locally`

Вы можете запустить свой код в локальной среде, используя избранную интегрированную среду разработки или терминал.You can run your code locally, by using your favorite IDE or a terminal. Выполнение кода в локальной среде предоставляет преимущество в виде интерактивной отладки кода.Running code locally has the benefit of interactive debugging of code. В окне с активированной средой Conda tutorial1 выполните файл Python:In the window that has the activated tutorial1 conda environment, run the Python file:

cd <path/to/tutorial>
python ./src/hello.py

`Создание скрипта элемента управленияCreate a control script`

Скрипт элемента управления позволяет выполнять скрипт hello.py в облаке.A control script allows you to run your hello.py script in the cloud. Сценарий элемента управления используется, чтобы контролировать, как и где выполняется код машинного обучения.You use the control script to control how and where your machine learning code is run.

В каталоге учебника создайте новый файл Python с именем 03-run-hello.py. Затем скопируйте и вставьте приведенный ниже код в этот файл:In your tutorial directory, create a new Python file called 03-run-hello.py and copy/paste the following code into that file:

# tutorial/03-run-hello.py
from azureml.core import Workspace, Experiment, Environment, ScriptRunConfig

ws = Workspace.from_config()
experiment = Experiment(workspace=ws, name='day1-experiment-hello')

config = ScriptRunConfig(source_directory='./src', script='hello.py', compute_target='cpu-cluster')

run = experiment.submit(config)
aml_url = run.get_portal_url()
print(aml_url)

`Изучение кодаUnderstand the code`

Ниже приведено описание функционирования скрипта элемента управления.Here’s a description of how the control script works:

ws = Workspace.from_config()

Workspace подключается к рабочей области Машинного обучения Azure, чтобы можно было взаимодействовать с ресурсами Машинного обучения Azure.Workspace connects to your Azure Machine Learning workspace, so that you can communicate with your Azure Machine Learning resources.

experiment = Experiment( ... )

Experiment предоставляет простой способ организации нескольких запусков с одним именем.Experiment provides a simple way to organize multiple runs under a single name. В дальнейшем можно увидеть, как эксперименты упрощают сравнение метрик множества запусков.Later you can see how experiments make it easy to compare metrics between dozens of runs.

config = ScriptRunConfig( ... )

ScriptRunConfig создает оболочку для кода hello.py и передает его в рабочую область.ScriptRunConfig wraps your hello.py code and passes it to your workspace. Как следует из названия, этот класс можно использовать для настройки запуска скрипта в Машинном обучении Azure.As the name suggests, you can use this class to configure how you want your script to run in Azure Machine Learning. Кроме того, он указывает, на каком целевом объекте вычислений будет выполняться скрипт.It also specifies what compute target the script will run on. В этом коде целевым объектом является вычислительный кластер, созданный в рамках учебника по настройке.In this code, the target is the compute cluster that you created in the setup tutorial.

run = experiment.submit(config)

Отправляет скрипт.Submits your script. Эта отправка называется запуском.This submission is called a run. Запуск инкапсулирует одно выполнение кода.A run encapsulates a single execution of your code. Используйте запуск, чтобы отслеживать ход выполнения скрипта, записывать выходные данные, анализировать результаты, визуализировать метрики и многое другое.Use a run to monitor the script progress, capture the output, analyze the results, visualize metrics, and more.

aml_url = run.get_portal_url()

Объект run предоставляет дескриптор для выполнения кода.The run object provides a handle on the execution of your code. Отслеживайте ход выполнения в Студии машинного обучения Azure, используя URL-адрес из скрипта Python.Monitor its progress from the Azure Machine Learning studio with the URL that’s printed from the Python script.

`Отправка и выполнение кода в облакеSubmit and run your code in the cloud`

Запустите скрипт элемента управления, который затем выполняет hello.py в вычислительном кластере, созданном во время работы с учебником по установке.Run your control script, which in turn runs hello.py on the compute cluster that you created in the setup tutorial.

python 03-run-hello.py

Совет

Если выполнение этого кода приводит к ошибке с сообщением о том, что у вас нет доступа к подписке, см. раздел Подключение к рабочей области, чтобы получить сведения о параметрах проверки подлинности.If running this code gives you an error that you do not have access to the subscription, see Connect to a workspace for information on authentication options.

`Мониторинг кода в облаке с помощью студииMonitor your code in the cloud by using the studio`

Выходные данные вашего скрипта будут содержать ссылку на студию, которая выглядит примерно так: https://ml.azure.com/experiments/hello-world/runs/<run-id>?wsid=/subscriptions/<subscription-id>/resourcegroups/<resource-group>/workspaces/<workspace-name>.The output from your script will contain a link to the studio that looks something like this: https://ml.azure.com/experiments/hello-world/runs/<run-id>?wsid=/subscriptions/<subscription-id>/resourcegroups/<resource-group>/workspaces/<workspace-name>.

Перейдите по ссылке.Follow the link. Сначала вы увидите состояние Подготовка.At first, you’ll see a status of Preparing. Первое выполнение займет 5–10 минут.The very first run will take 5-10 minutes to complete. Это происходит по следующей причине:This is because the following occurs:

в облаке создается образ Docker;A docker image is built in the cloud
размер вычислительного кластера изменяется с 0 на 1 узел;The compute cluster is resized from 0 to 1 node
Образ Docker загружается в вычислительный кластер.The docker image is downloaded to the compute.

Последующие запуски выполняются гораздо быстрее (в течение 15 секунд), так как образ Docker кэшируется в процессе вычислений.Subsequent runs are much quicker (~15 seconds) as the docker image is cached on the compute. Это можно проверить, повторно отправив приведенный ниже код после завершения первого запуска.You can test this by resubmitting the code below after the first run has completed.

После завершения задания перейдите на вкладку Выходные данные и журналы. Перейдя, можно увидеть файл 70_driver_log.txt, который выглядит следующим образом:Once the job completes, go to the Outputs + logs tab. There you can see a 70_driver_log. txt file that looks like this:

 1: [2020-08-04T22:15:44.407305] Entering context manager injector.
 2: [context_manager_injector.py] Command line Options: Namespace(inject=['ProjectPythonPath:context_managers.ProjectPythonPath', 'RunHistory:context_managers.RunHistory', 'TrackUserError:context_managers.TrackUserError', 'UserExceptions:context_managers.UserExceptions'], invocation=['hello.py'])
 3: Starting the daemon thread to refresh tokens in background for process with pid = 31263
 4: Entering Run History Context Manager.
 5: Preparing to call script [ hello.py ] with arguments: []
 6: After variable expansion, calling script [ hello.py ] with arguments: []
 7:
 8: Hello world!
 9: Starting the daemon thread to refresh tokens in background for process with pid = 31263
10:
11:
12: The experiment completed successfully. Finalizing run...
13: Logging experiment finalizing status in history service.
14: [2020-08-04T22:15:46.541334] TimeoutHandler __init__
15: [2020-08-04T22:15:46.541396] TimeoutHandler __enter__
16: Cleaning up all outstanding Run operations, waiting 300.0 seconds
17: 1 items cleaning up...
18: Cleanup took 0.1812913417816162 seconds
19: [2020-08-04T22:15:47.040203] TimeoutHandler __exit__

В строке 8 отображается сообщениеOn line 8, you see the «Hello world!» Hello World!output.

Файл 70_driver_log.txt содержит стандартные выходные данные выполнения.The 70_driver_log.txt file contains the standard output from a run. Этот файл может быть полезен при отладке удаленных запусков в облаке.This file can be useful when you’re debugging remote runs in the cloud.

`Дальнейшие действияNext steps`

В рамках этого учебника вы создали простой скрипт «Hello world!»In this tutorial, you took a simple «Hello world!» и выполнили его в Azure.script and ran it on Azure. Вы узнали, как подключиться к рабочей области Машинного обучения Azure, создать эксперимент и отправить свой код hello. py в облако.You saw how to connect to your Azure Machine Learning workspace, create an experiment, and submit your hello.py code to the cloud.

В следующем учебнике, основываясь на этих сведениях, вы запустите скрипт более интересный, чем print("Hello world!").In the next tutorial, you build on these learnings by running something more interesting than print("Hello world!").

Примечание

Если вы хотите на этом завершить серию учебников, не переходя к следующему шагу, очистите ресурсы.If you want to finish the tutorial series here and not progress to the next step, remember to clean up your resources.

`Hello World на Голанге — GeeksforGeeks`

Hello World на Голанге

Привет, мир! это первая базовая программа на любом языке программирования. Давайте напишем первую программу на языке Go, выполнив следующие шаги:

Прежде всего откройте компилятор Go. На языке Go программа сохраняется с расширением .go и представляет собой текстовый файл UTF-8.
Теперь сначала добавьте пакет main в свою программу: пакет основной Каждая программа должна начинаться с объявления пакета.В языке Go пакеты используются для организации и повторного использования кода. В Go доступны два типа программ: одна — исполняемая, а другая — библиотека. Исполняемые программы — это те программы, которые мы можем запускать непосредственно из терминала, а библиотеки — это пакеты программ, которые мы можем повторно использовать в нашей программе. Здесь основная часть пакета сообщает компилятору, что пакет должен компилироваться в исполняемой программе, а не в общей библиотеке. Это отправная точка программы, которая также содержит в себе основную функцию.
После добавления основного пакета импортируйте пакет «fmt» в вашу программу:импорт{ "fmt" } Здесь import ключевое слово используется для импорта пакетов в вашу программу, а fmt package используется для реализации форматированного ввода / вывода с функциями.
Теперь напишите код в функции main для вывода hello world на языке Go:func main () { fmt.Println ("! ... Привет, мир ...!") } В приведенных выше строках кода мы имеем: func: Используется для создания функции на языке Go. main: Это основная функция на языке Go, которая не содержит параметра, ничего не возвращает и вызывается при выполнении программы. Println (): Этот метод присутствует в пакете fmt и используется для отображения «!… Hello World…!» нить. Здесь Println означает строку печати.

Пример:

пакет основной

импорт "фмт"

func main () {

фмт.Println ( "! ... Hello World ...!" )

}

Выход:

! ... Привет, мир ...!

`Как запустить программу Golang?`

Для запуска программы Go вам понадобится компилятор Go. В компиляторе Go сначала вы создаете программу и сохраняете ее с расширением .go , например, first.go . Теперь мы запускаем этот файл first.go в компиляторе go, используя следующую команду: i.e:

 $ вперед беги. Go

`Hello, World — Learn Go с тестами`

Вы можете найти весь код для этой главы здесь

Привет, мир традиционно для вашей первой программы на новом языке.

Создайте папку где угодно
Поместите в него новый файл с именем hello. go и поместите в него следующий код

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

Чтобы запустить, введите и запустите hello.go .

Когда вы пишете программу на Go, у вас будет пакет main , определенный с функцией main внутри него. Пакеты — это способы группировки связанного кода Go вместе.

Ключевое слово func — это то, как вы определяете функцию с именем и телом.

С import "fmt" мы импортируем пакет, который содержит функцию Println , которую мы используем для печати.

Как это проверить? Хорошо отделить свой «доменный» код от внешнего мира (побочные эффекты). fmt.Println — это побочный эффект (печать на стандартный вывод), а строка, которую мы отправляем, является нашим доменом.

Итак, давайте разделим эти проблемы, чтобы было легче протестировать

  основной пакет 
  
  import "fmt" 
  
  func Hello () string {
  return "Hello, world" 
 } 
  
  func main () {
  fmt.Println (Hello ()) 
 }

Мы снова создали новую функцию с func , но на этот раз мы добавили в определение другое ключевое слово string . Это означает, что эта функция возвращает строку .

Теперь создайте новый файл с именем hello_test.go , в котором мы собираемся написать тест для нашей функции Hello

  package main 
  
  import «testing» 
  
  func TestHello (t * тестирование.T) {
  got: = Hello () 
  want: = "Hello, world" 
  
  if got! = Want {
  t.Errorf ("got% q want% q", got, want ) 
 } 
 }

Следующим шагом является запуск тестов. Введите go test в свой терминал. Если тесты пройдены, вероятно, вы используете более раннюю версию Go. Однако, если вы используете Go 1.16 или новее, тесты, скорее всего, вообще не запустятся. Вместо этого вы увидите в терминале такое сообщение об ошибке:

  $ go test 
  go: не удается найти основной модуль; см. «модули помощи go»

В чем проблема? Одним словом, модули.К счастью, проблему легко решить. Введите go mod init hello в свой терминал. Будет создан новый файл со следующим содержимым:

Этот файл сообщает инструментам go важную информацию о вашем коде. Если вы планируете распространять свое приложение, вы должны указать, где код доступен для загрузки, а также информацию о зависимостях. На данный момент ваш файл модуля минимален, и вы можете оставить его таким. Чтобы узнать больше о модулях, вы можете проверить ссылку в документации Golang. Теперь мы можем вернуться к тестированию и изучению Go, поскольку тесты должны выполняться даже на Go 1.16.

В будущих главах вам нужно будет запускать go mod init SOMENAME в каждой новой папке перед запуском таких команд, как go test или go build .

Запустите go test в своем терминале. Это должно было пройти! Просто для проверки попробуйте сознательно нарушить тест, изменив строку want .

Обратите внимание, что вам не пришлось выбирать между несколькими средами тестирования, а затем выяснять, как их установить.Все, что вам нужно, встроено в язык, а синтаксис такой же, как и остальной код, который вы напишете.

Написание теста аналогично написанию функции с несколькими правилами

Он должен быть в файле с именем, например, xxx_test.go
Тестовая функция должна начинаться со слова Тест
Функция тестирования принимает только один аргумент t * testing.T
Чтобы использовать тестирование *.Тип T , вам нужно импортировать "тестирование" , как мы сделали с fmt в другом файле

На данный момент достаточно знать, что ваш t типа * testing. T — это ваш «крючок» в среде тестирования, чтобы вы могли делать такие вещи, как t.Fail () , когда хотите потерпеть неудачу.

Мы рассмотрели несколько новых тем:

Операторы If в Go очень похожи на другие языки программирования.

Мы объявляем некоторые переменные с синтаксисом varName: = value , что позволяет нам повторно использовать некоторые значения в нашем тесте на удобочитаемость.

Мы вызываем метод Errorf на нашем t , который распечатает сообщение и провалит тест. f обозначает формат, который позволяет нам создавать строку со значениями, вставленными в значения-заполнители % q . Когда вы провалили тест, должно быть ясно, как он работает.

Подробнее о строках-заполнителях можно прочитать в документации по fmt go. Для тестов очень полезен % q , поскольку он заключает ваши значения в двойные кавычки.

Позже мы рассмотрим разницу между методами и функциями.

Еще одна особенность Go для улучшения качества жизни — это документация. Вы можете запустить документы локально, запустив godoc -http: 8000 . Если вы перейдете на localhost: 8000 / pkg, вы увидите все пакеты, установленные в вашей системе.

Подавляющее большинство стандартной библиотеки имеет отличную документацию с примерами. Было бы полезно перейти по адресу http: // localhost: 8000 / pkg / testing /, чтобы узнать, что вам доступно.

Если у вас нет команды godoc , возможно, вы используете более новую версию Go (1.14 или новее), которая больше не включает godoc . Вы можете установить его вручную с помощью go get golang.org/x/tools/cmd/godoc .

Теперь, когда у нас есть тест, мы можем безопасно итерировать наше программное обеспечение.

В последнем примере мы написали тест после , код был написан только для того, чтобы вы могли получить пример того, как написать тест и объявить функцию.С этого момента у нас будет , сначала напишем тесты .

Наше следующее требование — указать получателя приветствия.

Начнем с того, что зафиксируем эти требования в тесте. Это базовая разработка, основанная на тестах, которая позволяет нам убедиться, что наш тест на самом деле тестирует то, что мы хотим. Когда вы ретроспективно пишете тесты, существует риск того, что ваш тест может продолжать проходить, даже если код не работает должным образом.

  основной пакет 
  
  импорт "тестирование" 
  
  func TestHello (t * testing. T) {
  got: = Hello ("Chris") 
  want: = "Hello, Chris" 
  
  if got! = Want {
  t.Errorf ("got% q want% q", получил, хочу) 
 } 
 }

Теперь запустите go test , у вас должна быть ошибка компиляции

  ./hello_test.go:6:18: слишком много аргументов в вызове Hello 
  have ( string) 
  want ()

При использовании статически типизированного языка, такого как Go, важно, чтобы слушал компилятор .Компилятор понимает, как ваш код должен соединяться и работать, поэтому вам не нужно.

В этом случае компилятор сообщает вам, что вам нужно сделать, чтобы продолжить. Мы должны изменить нашу функцию Hello , чтобы она принимала аргумент.

Отредактируйте функцию Hello , чтобы принять аргумент строки типа

  func Hello (строка имени) строка {
  return "Hello, world" 
 }

Если вы снова попытаетесь запустить тесты, ваш Привет.go не скомпилируется, потому что вы не передаете аргумент. Отправьте «мир», чтобы он прошел.

  func main () {
  fmt.Println (Hello ("world")) 
 }

Теперь, когда вы запустите свои тесты, вы должны увидеть что-то вроде

  hello_test.go: 10: got 'Hello , world 'want' Hello, Chris ''

Наконец-то у нас есть компилирующая программа, но она не соответствует нашим требованиям согласно тесту.

Давайте пройдем тест, используя аргумент имени и объединим его с Hello,

  func Hello (строка имени) строка {
  return "Hello," + name 
 }

Когда вы запустите тесты, которые они должны теперь пройти.Обычно в рамках цикла TDD мы должны теперь выполнить рефакторинг .

На этом этапе, если вы используете систему контроля версий (а вам следует это сделать!), Я бы зафиксировал кода как есть. У нас есть работающее программное обеспечение, подтвержденное тестированием.

Я, , не стал бы push to master, потому что в следующий раз планирую провести рефакторинг. На этом этапе неплохо совершить коммит, если вы каким-то образом запутаетесь с рефакторингом — вы всегда можете вернуться к рабочей версии.

Рефакторинга здесь не так много, но мы можем ввести другую языковую функцию, константы .

Константы определены так:

  const englishHelloPrefix = "Hello,"

Теперь мы можем реорганизовать наш код

  const englishHelloPrefix = "Hello" 
  
  func Hello (name string) string { 
  return englishHelloPrefix + name 
 }

После рефакторинга перезапустите тесты, чтобы убедиться, что вы ничего не сломали.

Константы

должны повысить производительность вашего приложения, поскольку они избавляют вас от необходимости создавать экземпляр строки «Hello,» каждый раз, когда вызывается Hello .

Для ясности, прирост производительности в этом примере невероятно незначителен! Но стоит подумать о создании констант, чтобы фиксировать значение значений, а иногда и для повышения производительности.

Следующее требование — когда наша функция вызывается с пустой строкой, она по умолчанию выводит «Hello, World», а не «Hello».

Начните с написания нового теста на провал

  func TestHello (t * testing.T) {
  
  t.Run («привет людям», func (t * testing.T) {
  got: = Hello ("Chris") 
  want: = "Hello, Chris" 
  
  if got! = Want {
  t.Errorf ("got% q want% q", got, want) 
 } 
 }) 
  
  t.Run ("сказать 'Hello, World', когда указана пустая строка", func (t * testing.T) {
  got: = Hello ("") 
  want: = "Hello, World" 
  
  if got! = Хочу {
  t.Errorf ("got% q want% q", got, want) 
 } 
 }) 
  
 }

Здесь мы представляем еще один инструмент в нашем арсенале тестирования — подтесты. Иногда полезно сгруппировать тесты вокруг «вещи», а затем иметь подтесты, описывающие различные сценарии.

Преимущество этого подхода в том, что вы можете настроить общий код, который можно использовать в других тестах.

Код повторяется, когда мы проверяем, соответствует ли сообщение ожидаемому.

Рефакторинг — это не , а для производственного кода!

Важно, чтобы ваши тесты были четкими спецификациями того, что должен делать код.

Мы можем и должны провести рефакторинг наших тестов.

  func TestHello (t * testing.T) {
  
  assertCorrectMessage: = func (t testing.TB, got, want string) {
  t.Helper () 
  if got! = Want {
  t.Errorf ("got% q want% q", got, want) 
 } 
 } 
  
  t.Run ("здоровается с людьми", func (t * testing.T) {
  got: = Hello ("Chris") 
  want: = "Hello, Chris" 
  assertCorrectMessage (t, got, want) 
 }) 
  
  t.Run ("по умолчанию пустая строка" World "", func (t * testing.T) {
  got: = Hello ("") 
  want: = "Hello, World" 
  assertCorrectMessage (t, got, want ) 
 }) 
  
 }

Что мы здесь сделали?

Мы преобразовали наше утверждение в функцию. Это уменьшает дублирование и улучшает читаемость наших тестов. В Go вы можете объявлять функции внутри других функций и назначать их переменным.Затем вы можете вызывать их, как обычные функции. Нам нужно пройти t * testing.T , чтобы мы могли сообщить, что тестовый код завершился неудачно, когда нам это нужно.

Для вспомогательных функций рекомендуется принять тест . TB — это интерфейс, который удовлетворяет * testing.T и * testing.B , поэтому вы можете вызывать вспомогательные функции из теста, или эталон.

t.Helper () необходим, чтобы сообщить набору тестов, что этот метод является помощником.Таким образом, в случае сбоя номер строки будет указан в нашем вызове функции , а не внутри нашего помощника по тестированию. Это поможет другим разработчикам легче выявлять проблемы. Если вы все еще не понимаете, закомментируйте это, сделайте тест неудачным и посмотрите на результат теста. Комментарии в Go — отличный способ добавить в код дополнительную информацию или, в данном случае, быстрый способ указать компилятору игнорировать строку. Вы можете закомментировать код t.Helper () , добавив две косые черты // в начале строки.Вы должны увидеть, что эта строка станет серой или изменится на цвет, отличный от цвета остальной части вашего кода, чтобы указать, что теперь она закомментирована.

Теперь, когда у нас есть хорошо написанный тест на сбой, давайте исправим код, используя , если .

  const englishHelloPrefix = "Привет," 
  
  func Hello (строка имени) строка {
  if name == "" {
  name = "World" 
 } 
  return englishHelloPrefix + name 
  }

Если мы запустим наши тесты, мы увидим, что он удовлетворяет новому требованию, и мы случайно не нарушили другие функции.

Теперь мы довольны кодом, который я бы исправил в предыдущем коммите, поэтому мы проверяем только прекрасную версию нашего кода с его тестом.

Давайте снова пройдем цикл

Запустите тест, убедитесь, что он не прошел, и убедитесь, что сообщение об ошибке значимо
Напишите достаточно кода, чтобы пройти тест

На лицевой стороне из-за этого это может показаться утомительным, но важно придерживаться цикла обратной связи.

Он не только гарантирует, что у вас есть релевантных тестов , но и помогает убедиться, что вы разрабатываете хорошее программное обеспечение путем рефакторинга с учетом безопасности тестов.

Наблюдение за неудачей теста — важная проверка, поскольку она также позволяет увидеть, как выглядит сообщение об ошибке. Разработчику может быть очень сложно работать с базой кода, когда неудачные тесты не дают четкого представления о том, в чем проблема.

Убедившись, что ваши тесты быстрые и настроив ваши инструменты так, чтобы запускать тесты было просто, вы можете войти в состояние потока при написании кода.

Не написав тесты, вы обязуетесь вручную проверять свой код, запустив программное обеспечение, которое нарушает ваше состояние потока, и вы никогда не сэкономите себе время, особенно в долгосрочной перспективе.

Боже мой, у нас еще требования. Теперь нам нужно поддерживать второй параметр, определяющий язык приветствия. Если передается язык, который мы не распознаем, по умолчанию используется английский.

Мы должны быть уверены, что можем использовать TDD, чтобы легко реализовать эту функциональность!

Напишите тест для пользователя, сдающего испанский язык.Добавьте его к существующему набору.

  t.Run ("на испанском", func (t * testing.T) {
  got: = Hello ("Элоди", "испанский") 
  want: = "Hola, Elodie" 
  assertCorrectMessage ( т, достал, хочу) 
 })

Помните, не обманывайте! Первый тест . Когда вы пытаетесь запустить тест, компилятор должен пожаловаться, потому что вы вызываете Hello с двумя аргументами, а не с одним.

 ./hello_test.go:27:19: слишком много аргументов в вызове Hello 
  have (string, string) 
  want (string)

Исправьте проблемы компиляции, добавив еще один строковый аргумент в Hello

  func Hello (строка имени, строка языка) строка {
  if name == "" {
  name = "World" 
 } 
  return englishHelloPrefix + name 
 }

При повторной попытке запустить тест будет жаловаться на отсутствие достаточного количества аргументов в Hello, в других ваших тестах и в hello.go

  ./hello.go:15:19: недостаточно аргументов в вызове Hello 
  have (string) 
  want (string, string)

Исправьте их, пропустив пустые строки. Теперь все ваши тесты должны скомпилировать и , кроме нашего нового сценария

  hello_test.go: 29: got 'Hello, Elodie' want 'Hola, Elodie'

Мы можем использовать if здесь, чтобы проверить язык равен «Испанский», и если да, измените сообщение

  func Hello (строка имени, строка языка) строка {
  if name == "" {
  name = "World" 
 } 
  
  if language == "Spanish" {
  return "Hola" + name 
 } 
  
  return englishHelloPrefix + name 
 }

Теперь тесты должны пройти.

Теперь пора рефакторинг . Вы должны увидеть некоторые проблемы в коде, «волшебные» строки, некоторые из которых повторяются. Попробуйте провести рефакторинг самостоятельно, при каждом изменении убедитесь, что вы повторно запускаете тесты, чтобы убедиться, что ваш рефакторинг ничего не сломает.

  const spanish = "Spanish" 
  const englishHelloPrefix = "Hello," 
  const spanishHelloPrefix = "Hola," 
  
  func Hello (строка имени, языковая строка) строка {
  if name == " "{
  name =" World "
 } 
  
  если язык == испанский {
  return spanishHelloPrefix + name 
 } 
  
  return englishHelloPrefix + name 
 }  Напишите тест, утверждающий, что если вы пройдете  «французский» , вы получите  «Bonjour»,  
    Посмотрите, не получилось, проверьте, легко ли прочитать сообщение об ошибке 
 
   Внесите минимальное разумное изменение в код 
 
   Возможно, вы написали что-то похожее на эту 
   func Hello (строка имени, языковая строка) строка {
  if name == "" {
  name = "World" 
 } 
  
  если язык == испанский {
  вернуть испанскийHelloPrefix + name 
 } 
  
  если язык == французский {
  вернуть французский name +HelloPrefix 
 } 
  
  return englishHelloPrefix + name 
 } 
 
 Когда у вас много , если операторы  проверяют конкретное значение, вместо этого обычно используется оператор  switch .Мы можем использовать переключатель   для рефакторинга кода, чтобы его было легче читать и расширять, если мы хотим добавить дополнительную языковую поддержку позже
  func Hello (строка имени, строка языка) строка {
  if name == "" {
  name = "World" 
 } 
  
  префикс: = englishHelloPrefix 
  
  переключить язык {
  французский регистр: 
  префикс = французский } 
  
  возврат префикса + имя 
 } 
 
 Напишите тест, чтобы теперь включить приветствие на выбранном вами языке, и вы увидите, насколько просто расширить нашу удивительную функцию  .
 Вы можете возразить, что, возможно, наша функция становится немного крупнее. Самым простым рефакторингом для этого было бы извлечение некоторой функциональности в другую функцию.
  func Hello (строка имени, языковая строка) строка {
  if name == "" {
  name = "World" 
 } 
  
  возврат welcomePrefix (язык) + имя 
 } 
  
  func welcomePrefix (языковая строка) (префиксная строка) {
  переключить язык {
  case french: 
  prefix = french HelloPrefix 
  case spanish: 
  prefix = spanishHelloPrefix 
 english prefix 0003 по умолчанию: 
 } 
  return 
 } 
 
 Несколько новых концепций:
 В нашей сигнатуре функции мы сделали именованное возвращаемое значение    (строка префикса) .
 Это создаст в вашей функции переменную с именем  prefix .
 Ему будет присвоено «нулевое» значение. Это зависит от типа, например  int  s равны 0, а для  string  s это  "" .
 Вы можете вернуть все, что установлено, просто вызвав  return , а не  return prefix .
 Это будет отображаться в Go Doc для вашей функции, чтобы он мог прояснить цель вашего кода.
  default  в случае коммутатора будет разветвлен, если ни один из других операторов  case  не совпадет.
 Имя функции начинается со строчной буквы. В Go публичные функции начинаются с заглавной буквы, а частные - с строчной. Мы не хотим, чтобы внутренняя часть нашего алгоритма была открыта миру, поэтому мы сделали эту функцию частной.
 Кто знал, что можно получить столько от  Привет, мир ?
 К настоящему моменту вы должны иметь некоторое представление о:
 Некоторые синтаксисы Go около 
 Объявление функций с аргументами и типами возврата
 Объявление переменных и констант
 Процесс TDD и 
 почему  шаги важны
  Напишите неудачный тест и увидите, что он не пройден , чтобы мы знали, что написали  соответствующий тест  для наших требований и увидели, что он дает  простое для понимания описание отказа 
 Написание наименьшего количества кода, чтобы он прошел, чтобы мы знали, что у нас есть работающее программное обеспечение
  Затем рефакторинг , подкрепленный безопасностью наших тестов, чтобы гарантировать, что у нас есть хорошо продуманный код, который легко работает с
 В нашем случае мы перешли с  Hello ()  на  Hello ("name")  на  Hello ("name", "French")  небольшими, легкими для понимания шагами.
 Это, конечно, тривиально по сравнению с программным обеспечением "реального мира", но принципы все же остаются в силе. TDD - это навык, который требует практики для развития, но если вы сможете разбить проблемы на более мелкие компоненты, которые вы сможете протестировать, вам будет намного легче писать программное обеспечение.
 Go Hello World - golangbot.com 
  Это руководство устарело. Пожалуйста, посетите https://golangbot.com/hello-world-gomod/ для получения обновленной версии. 
 Это второй учебник в нашей серии руководств по Голангу.Пожалуйста, прочтите руководство по Golang, часть 1: Введение и установка, чтобы узнать, что такое golang и как установить golang.
 Нет лучшего способа выучить язык программирования, чем запачкать руки кодом. Давайте продолжим и напишем нашу первую программу.
 Я лично рекомендовал бы использовать Visual Studio Code с расширением go в качестве IDE. Он имеет автозаполнение, стили кода и множество других функций.
 Настройка рабочего пространства Go 
 Перед тем, как начать писать код, мы должны настроить рабочее пространство go.
 В случае  Mac или Linux  рабочее пространство go должно находиться в $ HOME / go. Итак, давайте продолжим и создадим каталог  go  внутри  $ HOME .
 В случае  Windows  рабочее пространство должно располагаться в  C: \ Users \ YourName \ go . Итак, давайте создадим каталог  go  внутри  C: \ Users \ YourName .
 Можно использовать другой каталог в качестве рабочего пространства, установив переменную среды GOPATH.Но пока для простоты воспользуемся указанным выше расположением.
 Все исходные файлы для go должны находиться в каталоге с именем  src  внутри рабочей области. Итак, давайте создадим каталог  src  внутри каталога  go , который мы создали выше.
 Каждый проект go должен, в свою очередь, иметь собственный подкаталог внутри src. Давайте создадим каталог  hello  внутри src для хранения проекта hello world.
 После создания указанных выше каталогов структура каталогов должна выглядеть так, как показано ниже.
  перейти
          src
            Привет
  
 Сохраните следующую программу как  helloworld.go  в только что созданном каталоге hello.
  пакет основной

импорт "FMT"

func main () {
    fmt.Println ("Привет, мир")
}
  
 Вот как будет выглядеть структура каталогов после создания указанной выше программы
  перейти
          src
            Привет
                helloworld.go
  
 Запуск программы на ходу 
 Есть несколько разных способов запустить программу го.Давайте посмотрим на них по очереди.
 1) С помощью команды  go run  введите  go run workspacepath / src / hello / helloworld.go  в командной строке.
  workspacepath  в приведенной выше команде следует заменить на путь к вашему рабочему пространству ( C: / Users / YourName / go  в Windows и  $ HOME / go  в Linux или Mac)
 Вы должны увидеть вывод  Hello World  в консоли.
 2) Использование команды  go install  - запустите команду  go install hello , а затем  workspacepath / bin / hello , чтобы запустить программу.
  workspacepath  в приведенной выше команде следует заменить на путь к вашему рабочему пространству ( C: / Users / YourName / go  в Windows и  $ HOME / go  в Linux или Mac). Вы должны увидеть тот же вывод  Hello World  в командной строке.
 Когда вы набираете  go install hello , инструмент go ищет пакет hello (hello называется пакетом, мы рассмотрим пакеты более подробно позже) внутри рабочей области. Затем он создает двоичный файл с именем  hello  ( hello.exe  в случае Windows) внутри каталога bin рабочей области. После запуска go install hello
 структура каталогов должна выглядеть, как показано ниже.
  перейти
         мусорное ведро
           Привет
         src
           Привет
               helloworld.go
  
 3) Третий классный способ запуска программы - это игровая площадка для игры в го. Хотя у этого есть ограничения, этот метод пригодится, когда мы хотим запускать простые программы. Я создал площадку для программы hello world.Щелкните здесь, чтобы запустить программу онлайн.
 Вы можете использовать игровую площадку go, чтобы поделиться своим исходным кодом с другими.
 Краткое объяснение программы hello world 
 Вот программа hello world, которую мы только что написали
  пакет основной // 1

импорт "fmt" // 2

func main () {// 3
    fmt.Println ("Hello World") // 4
}
  
 Здесь мы вкратце увидим, что делает каждая строка программы. Мы подробно рассмотрим каждый раздел в следующих уроках.
  основной пакет  -  Каждый файл go должен начинаться с оператора  имени пакета . Пакеты  используются для разделения кода и возможности повторного использования. Здесь используется имя пакета   main  
  import "fmt"  - Пакет fmt импортируется и будет использоваться внутри основной функции для вывода текста на стандартный вывод.
  func main ()  - Main - это специальная функция. Выполнение программы начинается с основной функции. Основная функция всегда должна находиться в основном пакете .  { и }  обозначают начало и конец основной функции.
  fmt.Println ("Hello World")  - Функция  Println  пакета  fmt  используется для записи текста в стандартный вывод.
 Код доступен для скачивания на github.
 Теперь вы можете перейти к учебной части 3 по Golang: Переменные, чтобы узнать о переменных в golang.
 Пожалуйста, оставляйте свои отзывы и вопросы в разделе комментариев. Спасибо.
  Следующее руководство - переменные 
 Ваша первая программа - введение в программирование на Go 
 Традиционно первая программа, которую вы пишете на любом языке программирования, - это
 называется программой «Hello World» - программа, которая просто выводит
  Hello World  на свой терминал. Напишем на Go.
 Сначала создайте новую папку, в которой мы можем хранить нашу программу.Создать папку
 с именем  ~ / src / golang-book / chapter2 . (Где  ~  означает
 ваш домашний каталог) С терминала вы можете сделать это, введя
 следующие команды:
 mkdir src / golang-book
mkdir SRC / книга-голанг / chapter2 
 Используя текстовый редактор, введите следующее:
 основной пакет

импорт "FMT"

// это комментарий

func main () {
    fmt.Println ("Привет, мир")
} 
 Убедитесь, что ваш файл идентичен тому, что показан здесь, и сохраните его как
  основной.перейдите  в только что созданную папку. Откройте новый терминал
 и введите следующее:
 cd src / golang-book / chapter2
иди беги main.go 
 Вы должны увидеть  Hello World , отображаемый в вашем терминале.
 Команда  go run  принимает последующие файлы (разделенные
 пробелы), компилирует их в исполняемый файл, сохраненный во временном каталоге, и
 затем запускает программу. Если вы не видели  Hello World 
 отображается сообщение о том, что вы, возможно, ошиблись при наборе текста в программе.Go
 компилятор подскажет, в чем заключается ошибка. Как большинство
 компиляторы, компилятор Go чрезвычайно педантичен и не терпит
 ошибки.
 Как читать программу Go 
 Давайте рассмотрим эту программу подробнее. Программы Go читаются сверху вниз
 снизу слева направо. (как в книге) В первой строке написано следующее:
 основной пакет 
 Это известно как «объявление пакета». Каждая программа Go должна начинаться с объявления пакета.Пакеты - это способ организации и повторного использования кода в Go. Есть два типа программ Go: исполняемые файлы и библиотеки. Исполняемые приложения - это программы, которые мы можем запускать прямо из терминала. (в Windows они заканчиваются на  .exe ) Библиотеки - это наборы кода, которые мы упаковываем вместе, чтобы мы могли использовать их в других программах. Позже мы рассмотрим библиотеки более подробно, а пока просто не забудьте включить эту строку в любую программу, которую вы пишете.
 Следующая строка - пустая.Компьютеры представляют символы новой строки специальным символом (или несколькими символами). Новые строки, пробелы и табуляции называются пробелами (потому что вы их не видите). Go в основном не заботится о пробелах, мы используем их, чтобы программы было легче читать. (Вы можете удалить эту строку, и программа будет вести себя точно так же)
 Тогда мы видим это:
 import "fmt" 
 Ключевое слово  import  используется для включения кода из других пакетов в нашу программу. Пакет  fmt  (сокращение от format) реализует форматирование для ввода и вывода.Учитывая то, что мы только что узнали о пакетах, как вы думаете, что файлы пакета  fmt  будут содержать вверху?
 Обратите внимание, что  fmt  выше заключено в двойные кавычки. Подобное использование двойных кавычек известно как «строковый литерал», который является типом «выражения». В Go строки представляют собой последовательность символов (букв, цифр, символов,…) определенной длины. Строки описаны более подробно в следующей главе, но сейчас важно помнить, что за открывающим символом  " в конечном итоге должен следовать другой символ " , и все, что находится между ними, включается в строку. .(Символ  " сам по себе не является частью строки)
 Строка, начинающаяся с  // , называется комментарием. Комментарии игнорируются компилятором Go и предназначены для вас (или того, кто собирает исходный код вашей программы). Go поддерживает два разных стиля комментариев: комментарии  // , в которых весь текст между  //  и концом строки является частью комментария, и комментарии  / * * / , где все между  *  s является частью комментария.(И может включать несколько строк)
 После этого вы увидите объявление функции:
 func main () {
    fmt.Println ("Привет, мир")
} 
 Функции - это строительные блоки программы Go. У них есть входы, выходы и последовательность шагов, называемых операторами, которые выполняются по порядку. Все функции начинаются с ключевого слова  func , за которым следует имя функции ( main  в данном случае), список из нуля или более «параметров», окруженных круглыми скобками, необязательный тип возвращаемого значения и «тело», окруженное фигурными скобками.Эта функция не имеет параметров, ничего не возвращает и имеет только одну инструкцию. Имя  main  является особенным, потому что это функция, которая вызывается при выполнении программы.
 Последняя часть нашей программы - это строка:
 fmt.Println ("Hello World") 
 Это заявление состоит из трех компонентов. Сначала мы обращаемся к другой функции внутри пакета  fmt , называемой  Println  (это часть  fmt.Println ,  Println  означает строку печати).Затем мы создаем новую строку, содержащую  Hello World , и вызываем (также называемую вызовом или выполнением) эту функцию со строкой в качестве первого и единственного аргумента.
 К этому моменту мы уже видели много новой терминологии, и вы можете быть немного ошеломлены. Иногда полезно целенаправленно прочитать вашу программу вслух. Одно чтение только что написанной программы может выглядеть так:
 Создайте новую исполняемую программу, которая ссылается на библиотеку  fmt  и содержит одну функцию с именем  main .Эта функция не принимает аргументов, ничего не возвращает и выполняет следующие действия: обращается к функции  Println , содержащейся внутри пакета  fmt , и вызывает ее, используя один аргумент - строку  Hello World .
 Реальную работу в этой программе выполняет функция  Println . Вы можете узнать об этом больше, набрав в своем терминале следующее:
 godoc fmt Println 
 Среди прочего вы должны увидеть это:
 Println форматирует, используя форматы по умолчанию для своих операндов и записывает в стандартный вывод.Между операндами всегда добавляются пробелы и добавляется новая строка. Он возвращает количество записанных байтов и все обнаруженные ошибки записи. 
 Go - очень хорошо документированный язык программирования, но эту документацию может быть сложно понять, если вы уже не знакомы с языками программирования. Тем не менее, команда  godoc  чрезвычайно полезна и является хорошей отправной точкой, когда у вас есть вопрос.
 Возвращаясь к рассматриваемой функции, эта документация сообщает вам, что функция  Println  отправит все, что вы ей передадите, на стандартный вывод - имя вывода терминала, в котором вы работаете.Эта функция вызывает отображение  Hello World .
 В следующей главе мы рассмотрим, как Go хранит и представляет такие вещи, как  Hello World , узнавая о типах.
 Проблемы 
 Что такое пробелы?
 Что за комментарий? Какими двумя способами можно написать комментарий?
 Наша программа началась с пакета  main . С чего бы начинались файлы в пакете  fmt ?
 Мы использовали функцию  Println , определенную в пакете  fmt .Если бы мы хотели использовать функцию  Exit  из пакета  os , что нам нужно было бы сделать?
 Измените написанную нами программу так, чтобы вместо печати  Hello World  она печатала  Привет, меня зовут , за которым следует ваше имя.
 Golang - Пример «привет, мир» - CodingBee 
 После того, как вы установили Golang и настроили рабочее пространство, вы готовы написать свою программу hello world go. Ваш код Go должен быть записан в папке src, а файл должен иметь расширение «.go 'расширение. Итак, я создал следующий файл:
 Объявление 
Вы можете найти все мои последние сообщения на  medium .

$ cat hello.go
основной пакет

// это комментарий.
импорт "FMT"


func main () {
    fmt.Println ("привет, мир")
}
 
 Есть 2 типа проектов Go, которые вы можете создавать. Один из них - проект общей библиотеки, который представляет собой код, который используется как часть других проектов Golang. Во втором случае конечным продуктом проекта Golang является автономный исполняемый двоичный файл.
 Основной пакет   сообщает Golang, что этот проект будет создавать автономный исполняемый двоичный файл. Затем мы объявили функцию под названием «main». Вы можете выбрать, что вызывать вашу функцию, однако название функции «main» имеет особое значение в Golang, оно сообщает Golang, какой блок кода будет выполнен первым при вызове двоичного файла. Двоичный код завершается после завершения выполнения кода в основной функции.
 Golang имеет встроенный набор пакетов.Эта коллекция известна как стандартная библиотека.
 В нашем примере мы вызвали другую функцию под названием «Println». Println - это в основном функция, которая выводит содержимое на стандартный вывод. Эта функция определена внутри пакета fmt. fmt - один из стандартных пакетов библиотеки. Объявление импорта - это то, как мы загружаем пакет fmt, чтобы мы могли вызывать его функцию в нашем коде.
 Теперь мы можем протестировать наш код, запустив:
$ go, запустите hello.go
Привет, мир
 
 Эта команда «запустить» выполняла ряд задач за кулисами.Сначала он создал двоичный файл из нашего кода, выполнил этот двоичный файл, а затем удалил этот двоичный файл.
 Теперь, когда все заработало, давайте создадим двоичный файл. Сначала нам нужно установить переменную GOBIN, которая сообщает Golang, где хранить двоичный конечный продукт:
$ export GOBIN = "$ GOPATH / bin"
 
 Затем, находясь в папке src, выполните команду установки:
$ go установить hello.go
 
 Это заканчивается компиляцией двоичного файла и его сохранением в папке GOBIN:
$ echo $ ГОБИН
/ корень / go_project / bin
$ ll $ ГОБИН
всего 1968
-rwxr-xr-x.1 root root 2011612 12 августа 01:30 привет
$ файл / корень / go_project / bin / привет
/ root / go_project / bin / hello: 64-разрядный исполняемый файл LSB ELF, x86-64, версия 1 (SYSV), статически связанный, без удаления

 
 Теперь мы можем запустить автономный двоичный файл:
$ / корень / go_project / bin / привет
Привет, мир
 
 Нам нужно было указать полный путь к двоичному файлу, но если вы хотите запустить этот двоичный файл, как любую другую команду, просто переместите его в одну из папок, указанных в переменной среды PATH.
 Язык программирования Hello World Go 
 Мы начнем изучать язык программирования Go с написания простой программы Hello World.
 Написание вашей первой программы Go 
 Сначала выберите локальный рабочий каталог. Я создал на своем компьютере папку с именем  golangexamples .
 Создайте файл с именем  hello_world.go .
  .go  Расширение файла, используемое для представления файлов исходного кода на языке go.
 Скопируйте и вставьте приведенную ниже программу hello world, которая напечатает «Hello! World »в командной строке.
  пакет основной

импорт "FMT"
func main () {
    fmt.Println ("Привет! Мир")
}
  
 Не паникуйте, если вы ничего не понимаете, это нормально. Вы собираетесь учиться.
 Запуск программы Go 
 Теперь запустим нашу программу с помощью команды  go run .
  иди, беги hello_world.go
  
 УДАЛ! Я получил ошибку ниже.
  CreateFile hello_world.go: Система не может найти указанный файл.
  
 Даже если вы получаете указанную выше ошибку, поздравляю, это ваша первая программная ошибка.
 Почему у меня выше  CreateFile go Система не может найти указанный файл. Ошибка  - мой исходный код находится в папке golangexamples.
 И я выполнил команду в какой-то другой папке, поэтому команда  go run  не смогла найти файл  hello_world.go  вернула указанную выше ошибку.
 Перейдите в папку с исходным кодом и снова выполните указанную выше команду.
 > беги, hello_world.go
Привет, мир
  
 Или вы можете передать полный относительный путь к файлу исходного кода команде  go run  для запуска программы.
 > D: \> запустите Blogging \ goposts \ golangExamples \ golangexamples \ hello_world.go
Привет, мир
  
 Скомпилировать программу Go в исполняемый двоичный файл 
 Если вы хотите встроить свою программу Go в исполняемый двоичный файл, используйте команду  go build .
 > иди сборка hello_world.go
  
 Если все в порядке, то вы должны увидеть исполняемый двоичный файл в той же папке, что и исходный код.
 > дерево / ж
Д :.hello_world.exe
    hello_world.go
    README.md

  
 Теперь мы можем напрямую запустить сгенерированный исполняемый двоичный файл.
 > hello_world.exe
Привет, мир
  
 Go lang «Hello, world» в Mac OS X 
Это пример приложения Go для "Hello, world".
 1) получите установочный пакет "Apple OS X" со страницы загрузки. 
 https://golang.org/dl/
 2) Установите gox.x.x.darwin-amd64.pkg на свой Mac.
 3) создать каталог кода и установить $ GOPATH
$ mkdir ~ / gocode
$ echo 'export GOPATH = $ HOME / gocode' >> ~ /.bashrc
$ source $ HOME / .bashrc
 
4) сделать «Привет, мир».
 $ mkdir -p ~ / gocode / src / привет
$ cd ~ / gocode / src / привет
$ emacs hello.go
основной пакет

импорт "FMT"

func main () {
 fmt.Printf ("Привет, мир. \ n")
}

$ go install
$ tree ~ / gocode
/ Пользователи / yako / gocode
├── мусорное ведро
│ └── привет
└── src
    └── привет
        └── hello.go

3 каталога, 2 файла

$ $ GOPATH / bin / привет
Привет, мир.
 
5) сделать библиотеку.
 $ mkdir ~ / gocode / src / stringutil
$ cd ~ / gocode / src / stringutil
$ emacs reverse.go
// Пакет stringutil содержит служебные функции для работы со строками.пакет stringutil

// Реверс возвращает строку аргументов, перевернутую по рунам слева направо.
func Reverse (s string) string {
 r: = [] руна (и)
 для i, j: = 0, len (r) -1; я 6) сделайте обратный тест.
  $ cd ~ / gocode / src / stringutil
 $ emacs reverse_test.go
 пакет stringutil
импортное "тестирование"
func TestReverse (t * testing.T) {
 case: = [] struct {
 в, хочу строку
 } {
 {"Привет, мир", "dlrow, olleH"},
 {"Привет,", "界 世, olleH"},
 {"", ""},
 }
 for _, c: = range case {
 получил: = Обратный (c.in)
 if got! = c.want {
 т.Errorf ("Обратный (% q) ==% q, хочу% q", c.
No related posts.

 Share :

Декабрь 2024
Пн	Вт	Ср	Чт	Пт	Сб	Вс
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28	29
30	31

Hello world go: Go by Example: Hello World

Создание вашей первой программы на Go

Введение

Предварительные требования

Шаг 1 — Написание простой программы “Hello, World!”

Шаг 2 — Запуск программы в Go

Шаг 3 — Запрос ввода пользователя

Заключение

Golang: установка и Hello, World

Go не работает пример hello world

4 ответа

Похожие вопросы:

Руководство по выполнению скрипта «Hello world!» Скрипт Python — Azure Machine Learning

В этой статье

Предварительные требованияPrerequisites

Создание и запуск скрипта Python в локальной средеCreate and run a Python script locally

Тестирование скрипта в локальной средеTest your script locally

Создание скрипта элемента управленияCreate a control script

Изучение кодаUnderstand the code

Отправка и выполнение кода в облакеSubmit and run your code in the cloud

Мониторинг кода в облаке с помощью студииMonitor your code in the cloud by using the studio

Дальнейшие действияNext steps

Hello World на Голанге — GeeksforGeeks

Как запустить программу Golang?

Hello, World — Learn Go с тестами

Некоторые синтаксисы Go около

Процесс TDD и

Go Hello World - golangbot.com

Настройка рабочего пространства Go

Запуск программы на ходу

Краткое объяснение программы hello world

Ваша первая программа - введение в программирование на Go

Как читать программу Go

Проблемы

Golang - Пример «привет, мир» - CodingBee

Язык программирования Hello World Go

Написание вашей первой программы Go

Запуск программы Go

Скомпилировать программу Go в исполняемый двоичный файл

Go lang «Hello, world» в Mac OS X

Добавить комментарий Отменить ответ

`Шаг 2 — Запуск программы в Go`

`Шаг 3 — Запрос ввода пользователя`

`Заключение`

`Golang: установка и Hello, World`

`Go не работает пример hello world`

`4 ответа`

`Похожие вопросы:`

`Руководство по выполнению скрипта «Hello world!» Скрипт Python — Azure Machine Learning`

`В этой статье`

`Предварительные требованияPrerequisites`

`Создание и запуск скрипта Python в локальной средеCreate and run a Python script locally`

`Тестирование скрипта в локальной средеTest your script locally`

`Создание скрипта элемента управленияCreate a control script`

`Изучение кодаUnderstand the code`

`Отправка и выполнение кода в облакеSubmit and run your code in the cloud`

`Мониторинг кода в облаке с помощью студииMonitor your code in the cloud by using the studio`

`Дальнейшие действияNext steps`

`Hello World на Голанге — GeeksforGeeks`

`Как запустить программу Golang?`

`Hello, World — Learn Go с тестами`

`Добавить комментарий Отменить ответ`