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

Rust variables are immutable by default. This is sort of like having all variables be 

 is shallow, but Rust variables cannot be mutated at all unless you declare that variable 

// JavaScript

let value = 10;
let greeting = "Hello!";
let counter = 0;

counter += 1;

// Rust

let value = 10; // Cannot be changed
let greeting = "Hello!"; // Also immutable
let mut counter = 0; // This can be changed

counter += 1;

 takes a string argument, which sort of acts like a JavaScript template string.

// JavaScript

let name = "Austin Tindle";
console.log(`Hello ${name}!`);

// Rust

let name = "Austin Tindle";
println!("Hello {}!", name);

 function in Rust is the entrypoint to the program, and other functions need to be called from 

. In JavaScript there is no special entrypoint function.

// JavaScript

function weather() {
  console.log("Sunny!");
}

weather();

// Rust

fn weather() {
  println!("Sunny!");
}

fn main() {
  weather();
}

// JavaScript

if (true === false) {
  console.log("Never happens.");
} else if (false === true) {
  console.log("Also never happens.");
} else {
  console.log("Perfection.");
}

// Rust

if true == false {
  println!("Impossible!");
} else if false == true {
  println!("Still impossible!");
} else {
  println!("This works.");
}

Unlike in JavaScript, Rust does not have "truthy" values. It's strict static typing means that conditional expressions need to evaluate to a 

---
title: JavaScript to Rust Cheatsheet
slug: rust-cheatsheet
description: Rust for JavaScripters Cheatsheet
role: "RESOURCES"
isPublicLesson: false
---

## Variables (bindings)

Rust variables are immutable by default. This is sort of like having all variables be `const` in JavaScript. JavaScript `const` is shallow, but Rust variables cannot be mutated at all unless you declare that variable `mut`.

```javascript
// JavaScript

let value = 10;
let greeting = "Hello!";
let counter = 0;

counter += 1;
```

```rust
// Rust

let value = 10; // Cannot be changed
let greeting = "Hello!"; // Also immutable
let mut counter = 0; // This can be changed

counter += 1;
```

## Printing Output

Rust's `println!` takes a string argument, which sort of acts like a JavaScript template string.

```javascript
// JavaScript

let name = "Austin Tindle";
console.log(`Hello ${name}!`);
```

```rust
// Rust

let name = "Austin Tindle";
println!("Hello {}!", name);
```

## Functions

The `main` function in Rust is the entrypoint to the program, and other functions need to be called from `main`. In JavaScript there is no special entrypoint function.

```javascript
// JavaScript

function weather() {
  console.log("Sunny!");
}

weather();
```

```rust
// Rust

fn weather() {
  println!("Sunny!");
}

fn main() {
  weather();
}
```

## Conditionals

### If/Else

```javascript
// JavaScript

if (true === false) {
  console.log("Never happens.");
} else if (false === true) {
  console.log("Also never happens.");
} else {
  console.log("Perfection.");
}
```

```rust
// Rust

if true == false {
  println!("Impossible!");
} else if false == true {
  println!("Still impossible!");
} else {
  println!("This works.");
}
```

Unlike in JavaScript, Rust does not have "truthy" values. It's strict static typing means that conditional expressions need to evaluate to a `bool`.

```rust
// Rust