deno.tar.gz

deno_code

deno_unit_test_author

deno_spa

deno_spa_5200

deno_spa_server

deno_compile

deno_install

deno_spa_copy1

deno_spa_copy2

deno_spa_copy3

Deno is a runtime environment for JavaScript and TypeScript. Since it’s built to improve upon the earlier version of Node.js, Deno offers significant upgrades to improve security and real-world performance while offering developers modern instrumentation.

In this course, you’ll discover Deno’s main features and explore its similarities and differences in relation with Node.js. You’ll then be led through a series of detailed project examples and practical code exercises to master its runtime.

By the end of the course, you’ll be ready to create professional, highly performant JavaScript or TypeScript applications with Deno.

Master the Deno JavaScript Runtime

This lesson takes inspiration from an article written by Luca Casonato on Deno’s blog (see the [Appendix: Further Resources](https://www.educative.io/courses/master-deno-javascript-runtime/appendix-further-resources) for the link). Here we’ll learn some useful Deno APIs (only a small subset). Each of them, provide us a code widget to experiment with these APIs directly.

# Encoding/Decoding (base64)
We can encode/decode base64 strings with the `atob` and `btoa` functions.

const encoded = btoa("Learnind Deno is really fun!");
console.log("encoded: ", encoded );

const decoded = atob(encoded);
console.log("decoded: ", decoded );

# Encoding/Decoding (binary)
Similar to the previous two functions, we can also decode/encode strings from and into a binary representation (`Uint8Array`). This is possible with the `TextEncoder` and `TextDecoder` APIs.

const stringToEncode = "Let's encode something with Deno!";

const textEncoder = new TextEncoder();
const encodedBytes = textEncoder.encode(stringToEncode);
console.log("Encoded bytes: ", encodedBytes);

const textDecoder = new TextDecoder();
const plainText = textDecoder.decode(encodedBytes);
console.log("Decoded bytes into string: ", plainText);

import React from 'react';
import { shallow, configure } from 'enzyme';
import Adapter from 'enzyme-adapter-react-16';

configure({ adapter: new Adapter() });

import HelloWorld from './app';

var TestResult = function() {
 this.succeeded = false;
 this.reason = "";
 this.input = "";
 this.expected_output = "";
 this.actual_output = "";
}

export const executeTests = function() {

 var results = [];

 result = new TestResult();
 result.input = 'HelloWorld Component';
 result.expected_output = "span containing text 'Hello World'"

 let wrapper = shallow(<HelloWorld />);

 // Call your Challenge function here.

 let type = wrapper.type();
 let testSuccessful = true;
 let failureReason;

 if (type !== 'span') {
 testSuccessful = false;
 failureReason = "You need to render exactly one span HTML element";
 } else if (wrapper.props().children != "Hello World") {
 testSuccessful = false;
 failureReason = "You have rendered wrong message in your span element";
 }

 result.actual_output = wrapper.html();

 if (testSuccessful) {
 result.succeeded = true;
 result.reason = "Succeeded"
 } else {
 result.succeeded = false;
 result.reason = failureReason;
 }

 results.push(result);

 return results;
}

React

Dart

GoJS React

Typescript React

Vue.js

# Cryptography functions
With version 1.18, Deno completely implements the Web Cryptography API. It is a standard JS API for performing cryptographic tasks like hashing, encryption, and decryption.

const uuid = crypto.randomUUID();
console.log('Generated new UUID: ', uuid);
console.log('\n---------------------------------------------------------------')


const bytes = await crypto.getRandomValues(new Uint8Array(16));
console.log('Array with random integers: ', bytes);
console.log('\n---------------------------------------------------------------');

const privateKey = await crypto.subtle.generateKey(
    { name: "HMAC", "hash": "SHA-256" }, // Target algorithm
    true,                                // Is Extractable 
    ["sign", "verify"]                   // Allowed usages
);
console.log('Our secret key: ', privateKey);


const exportedKey = await crypto.subtle.exportKey(
    "raw",
    privateKey
);

// Export the generated key as `ArrayBuffer`
const exportedKeyBuffer = new Uint8Array(exportedKey);

const keyAsString = String.fromCharCode.apply(null, exportedKeyBuffer as any);
// You can use the 'btoa' function explained before
const exportedBase64 = btoa(keyAsString);
const pem = `
-----BEGIN PRIVATE KEY-----
${exportedBase64}
-----END PRIVATE KEY-----`;

console.log('Exported PEM Key: ', pem);

- **Line 1**: The method `crypto.randomUUID()` allows us to generate a random UUID. This can be a convenient way to generate unique IDs for our objects.

- **Line 6**: The method `crypto.randomUUID()` generates a `Uint8Array` filled with random bytes.

- **Lines 10--32**: In this block we use different methods to create a private key using the `HMAC` algorithm. Let's break the different parts into blocks and describe them individually.

- **Line 10--14**: The method `generateKey()` allows us to generate a new key for symmetric algorithms. According to the parameters passed, we can specify which algorithm must be used, whether the generated key can be extractable, and which usage scope will be allowed, respectively. In this example, we use the `HMAC` algorithm and `SHA-256`, but other signatures and algorithms combinations are available:

#concept=algorithms_combinations#algorithms_combinations#concept#


We can specify the usage scope for our key using a string array as a third parameter. Available values are:

`encrypt`: The key may be used to encrypt messages. 
`decrypt`: The key may be used to decrypt messages. 
`sign`: The key may be used to sign messages. 
`verify`: The key may be used to verify signatures. 
`deriveKey`: The key may be used to derive a new key. 
`deriveBits`: The key may be used to derive bits. 
`wrapKey`: The key may be used to wrap a key. 
`unwrapKey`: The key may be used to unwrap a key.

- **Lines 18--21**: The method `exportKey()` allow us to export the generated key in a portable format.


- **Lines 24--32**: We pack the exported key into an array buffer that we decode (base64) with the `btoa()` method previously described.

Explore and test some Web APIs supported by Deno to achieve some common tasks.

__default

Deno Web APIs

Encoding/Decoding (base64)

Encoding/Decoding (binary)

Cryptography functions