158 lines
5.2 KiB
Plaintext
158 lines
5.2 KiB
Plaintext
{
|
||
"cells": [
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "7cee85dc-0711-48b9-9dd1-8d5a0efa2a68",
|
||
"metadata": {},
|
||
"source": [
|
||
"## Hello, World!\n",
|
||
"Now that you’ve installed Rust, it’s time to write your first Rust program. It’s traditional when learning a new language to write a little program that prints the text Hello, world! to the screen, so we’ll do the same here!\n",
|
||
"\n",
|
||
"### Creating a Project Directory\n",
|
||
"\n",
|
||
"Open a terminal and enter the following commands to make a *projects* directory and a directory for the “Hello, world!” project within the *projects* directory.\n",
|
||
"\n",
|
||
"```sh\n",
|
||
"$ mkdir ~/projects\n",
|
||
"$ cd ~/projects\n",
|
||
"$ mkdir hello_world\n",
|
||
"$ cd hello_world\n",
|
||
"```\n",
|
||
"\n",
|
||
"### Writing and Running a Rust Program\n",
|
||
"\n",
|
||
"Next, make a new source file and call it *main.rs*. Rust files always end with the *.rs* extension. If you’re using more than one word in your filename, the convention is to use an underscore to separate them. For example, use *hello_world.rs* rather than *helloworld.rs*.\n",
|
||
"\n",
|
||
"Now open the main.rs file you just created and enter the code."
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 4,
|
||
"id": "23512a76-d996-4702-9a5d-51a85e478057",
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"fn main() {\n",
|
||
" println!(\"Hello, world!\");\n",
|
||
"}"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "e9934548-d9f5-4c25-b3eb-2d77d476ea78",
|
||
"metadata": {},
|
||
"source": [
|
||
"To see the output in this notebook run the code below."
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 5,
|
||
"id": "8f6c527a-0df4-40fc-afbf-f69ec93c5f69",
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"Hello, world\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"println!(\"Hello, world\");"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "3635726e-d07d-4013-88c0-9eec55a4b5dd",
|
||
"metadata": {},
|
||
"source": [
|
||
"To run in your terminal, just follow the steps below.\n",
|
||
"\n",
|
||
"```rust\n",
|
||
"$ rustc main.rs\n",
|
||
"$ ./main\n",
|
||
"Hello, world!\n",
|
||
"```"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "0a99d564-5228-4814-aa7b-f5b112f5f67c",
|
||
"metadata": {
|
||
"jp-MarkdownHeadingCollapsed": true
|
||
},
|
||
"source": [
|
||
"```rust\n",
|
||
"$ rustc main.rs\n",
|
||
"$ ./main\n",
|
||
"Hello, world!\n",
|
||
"```\n",
|
||
"\n",
|
||
"Regardless of your operating system, the string `Hello, world!` should print to the terminal. If `Hello, world!` did print, congratulations! You’ve officially written a Rust program. That makes you a Rust programmer—welcome!\n",
|
||
"\n",
|
||
"<details>\n",
|
||
" <summary>more details</summary>\n",
|
||
" \n",
|
||
" ### Anatomy of a Rust Program\n",
|
||
" Let’s review this “Hello, world!” program in detail. Here’s the first piece of the puzzle:\n",
|
||
" \n",
|
||
" ```rust\n",
|
||
" fn main() {\n",
|
||
"\n",
|
||
" }\n",
|
||
" ```\n",
|
||
"\n",
|
||
"\n",
|
||
"These lines define a function named main. The `main` function is special: it is always the first code that runs in every executable Rust program. Here, the first line declares a function named `main` that has no parameters and returns nothing. If there were parameters, they would go inside the parentheses `()`.\n",
|
||
"\n",
|
||
"The body of the main function holds the following code:\n",
|
||
"\n",
|
||
"```rust\n",
|
||
" println!(\"Hello, world!\");\n",
|
||
"```\n",
|
||
"\n",
|
||
"This line does all the work in this little program: it prints text to the screen. There are four important details to notice here.\n",
|
||
"\n",
|
||
"First, Rust style is to indent with four spaces, not a tab.\n",
|
||
"\n",
|
||
"Second, `println!` calls a Rust macro. If it had called a function instead, it would be entered as `println` (without the `!`). We’ll discuss Rust macros in more detail in Chapter 19. For now, you just need to know that using a `!` means that you’re calling a macro instead of a normal function and that macros don’t always follow the same rules as functions.\n",
|
||
"\n",
|
||
"Third, you see the `\"Hello, world!\"` string. We pass this string as an argument to `println!`, and the string is printed to the screen.\n",
|
||
"\n",
|
||
"Fourth, we end the line with a semicolon (`;`), which indicates that this expression is over and the next one is ready to begin. Most lines of Rust code end with a semicolon.\n",
|
||
"\n",
|
||
"### Compiling and Running Are Separate Steps\n",
|
||
"\n",
|
||
"You’ve just run a newly created program, so let’s examine each step in the process.\n",
|
||
"\n",
|
||
"Before running a Rust program, you must compile it using the Rust compiler by entering the `rustc` command and passing it the name of your source file, like this:\n",
|
||
"\n",
|
||
"```sh\n",
|
||
"$ rustc main.rs\n",
|
||
"```\n",
|
||
"</details>"
|
||
]
|
||
}
|
||
],
|
||
"metadata": {
|
||
"kernelspec": {
|
||
"display_name": "Rust",
|
||
"language": "rust",
|
||
"name": "rust"
|
||
},
|
||
"language_info": {
|
||
"codemirror_mode": "rust",
|
||
"file_extension": ".rs",
|
||
"mimetype": "text/rust",
|
||
"name": "Rust",
|
||
"pygment_lexer": "rust",
|
||
"version": ""
|
||
}
|
||
},
|
||
"nbformat": 4,
|
||
"nbformat_minor": 5
|
||
}
|