(reading notes on Introducing Deno: A First Look at the Newest JavaScript Runtime)
2. An Introduction to TypeScript
declaring arrays
let variable : number[] = [1,2,34,45]
// another way
let variable : Array<number> = [1,2,3,4]
new types
tuples
tuples allow you to predefine a limited number of elements, but you can pick their type
let myTuple: [string, string] = ["hello", "world!"]
let myTuple2: [string, number] = ["hello", 1]
let myList: [number, string][] = [[1, "Steve"], [2, "Bill"], [3, "Jeff"]]
myList.push([4, "New Name"])
enums
enum Direction {
Up,
Down,
Left,
Right
}
here Direction.Up has the value of 0, Direction.Down a value of 1
literal enum
type validStrings = "hello" | "world" | "it's me"
any type
let myListOfThings: any[] = [1,2, "Three", { four: 4} ]
myListOfThings.forEach( i => console.log(i))
nullable
let myvar:number | null = null // OK
let var2:string = null //invalid
let var3:string | null = null // OK
union
type stringFn = () => string // alias for the type
function print(x: string | stringFn) {
if(typeof x == "string") return console.log(x)
console.log(x())
}
Interfaces
In a similar way to types, interfaces allow us to define what I like to call “types for objects.”
interface IMyProps {
name: string,
age: number,
city: string
}
function sayHello( myProps: IMyProps) {
console.log(`Hello there ${myProps.name}`)
}
optional properties
interface IMyProps {
name: string
age: number
city?: string
findCityCoordinates?(): number
}
mixing with optional chainning:
function sayHello( myProps: IMyProps) {
console.log(`Hello there ${myProps.name}, you're ${myProps.age} years old and live in ${myProps.city?.toUpperCase()}`)
}
Read-only properties
interface IPerson {
readonly name: string,
age: number
}
Interfaces for functions
interface Greeter {
(name: string, age: number, city: string): void
}
const greeterFn: Greeter = function(n: string, a: number, city: string) {
console.log(`Hello there ${n}, you're ${a} years old and live in ${city.toUpperCase()}`)
}
function asyncOp(callback: Greeter) {
///do async stuff here...
callback("Fernando", 37, "Madrid")
}
classes
class Person {
f_name: string
l_name: string
constructor(fn: string, ln: string) {
this.f_name = fn
this.l_name = ln
}
fullName(): string {
return this.f_name + " " + this.l_name
}
}
Private modifier
TypeScript implemented two versions, one following the classic standards using the private keyword and one following the way it’ll be implemented in the next version of ECMAScript, using the # character.
class Square {
side: number
private area: number
#perimeter: number
constructor(s: number) {
this.side = s
this.area = this.side * this.side
this.#perimeter = this.side * 4
}
}
Protected modifier
class Geometry {
protected area: number
protected perimeter: number
constructor() {
this.area = 0
this.perimeter = 0
}
}
accessors
class Geometry {
protected area: number
protected perimeter: number
constructor() {
this.area = 0
this.perimeter = 0
}
}
class Square extends Geometry{
private side: number
constructor(s: number) {
super()
this.side = s
this.area = this.side * this.side
this.perimeter = this.side * 4
}
set Side(value: number) {
this.side = value
this.area = this.side * this.side
}
get Side() {
return this.side
}
get Area() {
return this.area
}
}
Static and abstract classes
type Point = {
x: number,
y: number
}
class Grid {
static origin: Point = {x: 0, y: 0};
calculateDistanceFromOrigin(point: Point) {
let xDist = (point.x - Grid.origin.x);
let yDist = (point.y - Grid.origin.y);
return Math.sqrt(xDist * xDist + yDist * yDist) / this.scale;
}
constructor (public scale: number) { }
}
abstract class Geometry {
protected area: number
protected perimeter: number
constructor() {
this.area = 0
this.perimeter = 0
}
}
mixins
(I don't really like mixins, read later)
3. Living a Secure Life
“Everything’s allowed” flag
$ deno run --allow-all your-script.ts
to enable access to this particular section of our system, we’ll need the --allow-env flag.
$ deno run --allow-env script.ts
Allowing access to the network interface
$ deno run --allow-net=github.com,gitlab.com myscript.ts
Allowing plugins to be used
--allow-plugin
Allowing reading from the disk and writing to it
$ deno run --allow-read=/etc/ yourscript.ts
$ deno run --allow-write=/your-app-folder/logs --allow-read=/your-app-folder/config/default.ini,/your-app-folder/config/credentials.ini yourscript.ts
Allowing your script to spawn new subprocesses
$ deno run --unstable --allow-run reader.ts
Checking for available permissions
const status = await Deno.permissions.query({ name: "read", path: "/etc" });
if (status.state === "granted") {
data = await Deno.readFile("/etc/passwd");
}
const status = await Deno.permissions.request({ name: "env" });
if (status.state === "granted") {
console.log(Deno.env.get("HOME"));
} else {
console.log("'env' permission is denied.");
}
const status = await Deno.permissions.request({ name: "write", path: "/etc/passwd" });
//...
const readingStatus = await Deno.permissions.request({ name: "read", path: "./secret.txt" });
//...
const netStatus = await Deno.permissions.request({ name: "net", url: "http://github.com" });
//...
const envStatus= await Deno.permissions.revoke({ name: "env" });
if (envStatus.state === "granted") {
console.log(Deno.env.get("HOME"));
} else {
console.log("'env' permission is denied.");
}
denied even using the --allow-env flag
4. No More NPM
Dealing with external modules
Deno is dropping the require function and adopting the ES module standard for importing modules
import * as MyModule from './mymodule.ts'
import { get, has} from "https://deno.land/x/deno_lodash/mod.ts"
import { underline } from "https://deno.land/std@v0.39.0/fmt/colors.ts"
Handling packages
you can import everything in a single file; let’s call it deps.ts
//deps.ts
export * as MyModule from './mymodule.ts'
export {underline} from "https://deno.land/std@v0.39.0/fmt/colors.ts"
//script.ts
import {underline} from './deps.ts'
console.log(underline("This is underlined!"))
Locking your dependencies’ version
Deno provides --lock and --lock-write flags
// create the lockfile for the first time
$ deno run --lock=locks.json --lock-write script.ts
// when deploy project:
$ deno cache --reload --lock=locks.json deps.ts
$ deno run --lock=locks.json script.ts
Going experimental: Using import maps
(better check the latest version's documentation)
{
"imports": {
"fmt/": "https://deno.land/std@0.55.0/fmt/"
}
}
import red from "fmt/colors.ts"
import printf from "fmt/printf.ts"
$ deno run --unstable --importmap=import_map.json myscript.ts
5. Existing Modules
sql
import { connect } from "https://deno.land/x/cotton/mod.ts";
const db = await connect({
type: "sqlite", // available type: 'mysql', 'postgres', and 'sqlite'
database: "db.sqlite",
// other...
});
const users = await db.query("SELECT * FROM users;");
for (const user of users) {
console.log(user.email);
}
mongodb
import { Database } from 'https://deno.land/x/denodb/mod.ts';
const db = new Database('mongo', {
uri: 'mongodb://127.0.0.1:27017',
database: 'test',
});
class Flight extends Model {
static fields = {
_id: {
primaryKey: true,
},
};
}
const flight = new Flight();
flight.departure = 'Dublin';
flight.destination = 'Paris';
flight.flightDuration = 3;
await flight.save()
redis
import { connect } from "https://denopkg.com/keroxp/deno-redis/mod.ts";
const redis = await connect({
hostname: "127.0.0.1",
port: 6379
});
const ok = await redis.set("hoge", "fuga");
const fuga = await redis.get("hoge");
await redis.executor.exec("SET", "redis", "nice"); // => ["status", "OK"]
await redis.executor.exec("GET", "redis"); // => ["bulk", "nice"]
In order to make your code work with this module, you’ll need to provide network privileges using the --allow-net flag.
I think deno is very similar as golang, and even dart. lack of frontend support is a problem. It's clean and interesting, but I'll wait and see.