If you're a JavaScript developer looking to learn Rust, here are some key points to keep in mind:

1. Rust is a statically typed language, which means that you have to specify the types of variables and function arguments when you declare them. This can be a bit of a change if you're used to the dynamically typed nature of JavaScript.

2. Rust has a strong focus on safety and performance. It has a number of features, such as ownership and borrowing, that help ensure that your code is correct and efficient.

3. Rust has a very low-level control over system resources, similar to C or C++. This can be both a strength and a weakness, as it allows you to write highly optimized code but also requires a deeper understanding of how the language and the system work.

4. Rust has a growing ecosystem, with a number of useful libraries and tools available. Its package manager, Cargo, makes it easy to manage dependencies and build projects.

5. Rust has a friendly and helpful community, with many resources available for learning the language. The Rust programming language book is a great place to start, as are the Rust by Example and Rustlings exercises.

Overall, Rust is a powerful and expressive language that can be a great addition to a JavaScript developer's toolkit. It takes some time to get used to its unique features, but the investment can pay off in terms of both code quality and performance.

Here are a few examples of Rust code that might be familiar to a JavaScript developer:

// Rust
fn add(x: i32, y: i32) -> i32 {
    x + y
}

let result = add(1, 2);
println!("The result is {}", result);

// JavaScript
function add(x, y) {
  return x + y;
}

const result = add(1, 2);
console.log(`The result is ${result}`);

// Rust
fn say_hello(name: &str) {
    println!("Hello, {}!", name);
}

say_hello("Alice");

// JavaScript
function sayHello(name) {
  console.log(`Hello, ${name}!`);
}

sayHello("Alice");

// Rust
let mut x = 5;
x = 10;

// JavaScript
let x = 5;
x = 10;

// Rust
let y: i32 = "5".parse().unwrap();

// JavaScript
const y = parseInt("5", 10);

I hope these examples give you a sense of how Rust code looks and works.