Why Rust?

Goals and Strategy

Choosing Rust

Install and Get Started

Getting to Hello World

Using Cargo

JavaScript to Rust Cheatsheet

Up and Running with Rust

Getting arguments from the command line

Reading from files and counting words

Using struct to structure data

Implementing methods and using Vectors

Using traits

A Tour of Rust: Building Command Line Utilities

rust

In this course, you'll learn **practical, project-based programming with Rust**, specifically tailored for someone who understands JavaScripts. 

Learning Rust can be daunting for a JavaScript developer because of differences like manual memory management, the compilation toolchain, the syntax, strong types and more.

While Rust has many great learn resources, like the staple _The Rust Programming Language_ book,  they often lacks specifics for developers coming from interpreted languages like JavaScript.

In _Rust for JavaScript Developers_ you will learn: 

* the fundamentals of Rust
* practical Rust project knowledge and 
* what the analogues are coming from JavaScript.

You'll get comfortable with developing in a new, challenging language and its environment. 

We'll use the Rust `std` library to make simple but non-trivial command line applications, and be empowered to read and understand the technical Rust documentation on your own. 

You'll understand the fundamentals of Rust syntax and tools like `Iterators`, pattern matching, `struct`s, `impl`s, and return types, and be able to use those in your programs. 

You will also be able to draw on your understanding of JavaScript to augment and better grok these new Rust concepts and ease Rust's notorious learning curve.

In this course, you'll be learning the fundamentals of practical Rust, from the perspective of a JavaScript developer.

Rust For JavaScript Developers

How to build command line utilities in Rust

Value of a modern, compiled, statically typed language

Differences between JavaScript and Rust idioms

What problems Rust is particularly good for

 module to get arguments passed in by the user from the command line. In this lesson we need to use that user input to get a target file, and eventually count the words in that file.

First thing we need to do is bind the first argument passed in by the user to a variable, so we can use it later.

To bind a value to a variable, we can use the 

 keyword in Rust. Unlike JavaScript, Rust variables are immutable by default. Rust does have a 

 keyword, but it means something very specific and we can just use 

 if we want an immutable by default variable. Also note that Rust immutability is stricter than what 

 keyword guarantees shallow immutability, but you can still do things like change the inner properties of a "immutable" object.

If we need to have a mutable variable, we have to tell Rust explicitly by adding the 

. In this case we don't need to change the value of our first argument, so we'll leave it off.

 function returns a value that we can iterate over, and that value also has a few helper methods on it that we can use. To use a method we can use the same 

 syntax as we're used to in JavaScript. We can get a specific item from our Args Iterator with the 

 method. Remember, the first argument, at index 0, is always the name of the program. So we want the value at index 1, which will be the filename argument passed in by the user.

Let's quickly print that out to see what we get.

 doesn't directly return the argument passed in, instead it returns a 

. To understand this, we have to know something particular about Rust: it doesn't have a 

 function might work in JavaScript: it would either return the nth argument, or if the nth argument didn't exist, it would probably return 

. Rust forces you to handle all possible outcomes without using a 

 method returns a value that is either nothing, or a valid value passed in by the user. This is what Rust calls the 

. In order to get our argument value out of the Option, we can 

 the outer Option layer, and we'll be left with the value inside. Note, if we 

. While null and undefined are very general types, 

---
title: Reading from files and counting words
slug: reading-files-counting-words
privateVideoUrl: https://fullstack.wistia.com/medias/ylltql77pu
isPublicLesson: false
role: "LESSON"
---

In the last lesson we used the `std::env` module to get arguments passed in by the user from the command line. In this lesson we need to use that user input to get a target file, and eventually count the words in that file.

## Variables

First thing we need to do is bind the first argument passed in by the user to a variable, so we can use it later.



To bind a value to a variable, we can use the `let` keyword in Rust. Unlike JavaScript, Rust variables are immutable by default. Rust does have a `const` keyword, but it means something very specific and we can just use `let` if we want an immutable by default variable. Also note that Rust immutability is stricter than what `const` does in JavaScript. In JavaScript, the `const` keyword guarantees shallow immutability, but you can still do things like change the inner properties of a "immutable" object.

If we need to have a mutable variable, we have to tell Rust explicitly by adding the `mut` keyword after `let`. In this case we don't need to change the value of our first argument, so we'll leave it off.

`let filename = ???`

## Getting the first argument

Now we need to set `filename` to something. The `args` function returns a value that we can iterate over, and that value also has a few helper methods on it that we can use. To use a method we can use the same `.` syntax as we're used to in JavaScript. We can get a specific item from our Args Iterator with the `nth` method. Remember, the first argument, at index 0, is always the name of the program. So we want the value at index 1, which will be the filename argument passed in by the user.



Let's quickly print that out to see what we get.



`nth` doesn't directly return the argument passed in, instead it returns a `Option`. To understand this, we have to know something particular about Rust: it doesn't have a `null` or `undefined` type. Think about how this `nth` function might work in JavaScript: it would either return the nth argument, or if the nth argument didn't exist, it would probably return `undefined`. Rust forces you to handle all possible outcomes without using a `null` or `undefined` type. In this case the `nth` method returns a value that is either nothing, or a valid value passed in by the user. This is what Rust calls the `Option` type. `Option` is either `None` or it's `Some(value)`. In order to get our argument value out of the Option, we can `unwrap` the outer Option layer, and we'll be left with the value inside. Note, if we `unwrap` a Option that contains `None`, we get `None` instead of something like `null` or `undefined`. While null and undefined are very general types, `None` is very specific to this situation.

Reading from files and counting words

Masterclasses

Tutorials

Fullstack React with TypeScript