ภาพรวมรันไทม์ V8

ใน Apps Script และ JavaScript รันไทม์หรือสภาพแวดล้อมรันไทม์จะมีเครื่องมือ JavaScript ที่แยกวิเคราะห์และเรียกใช้โค้ดสคริปต์ รันไทม์มีกฎสำหรับวิธีเข้าถึงหน่วยความจำ วิธีที่โปรแกรมโต้ตอบกับระบบปฏิบัติการของคอมพิวเตอร์ และไวยากรณ์ของโปรแกรมที่ถูกต้อง เว็บเบราว์เซอร์แต่ละตัวมีสภาพแวดล้อมรันไทม์สําหรับ JavaScript

ที่ผ่านมา Apps Script ทำงานด้วยโปรแกรมตีความ JavaScript ของ Rhino จาก Mozilla แม้ว่า Rhino จะเป็นวิธีที่สะดวกสำหรับ Apps Script ในการดำเนินการสคริปต์ของนักพัฒนาซอฟต์แวร์ แต่ก็ผูก Apps Script ไว้กับ JavaScript เวอร์ชันหนึ่งๆ (ES5) ด้วย นักพัฒนา Apps Script จะใช้ไวยากรณ์และฟีเจอร์ JavaScript ที่ทันสมัยมากขึ้นในสคริปต์ที่ใช้รันไทม์ Rhino ไม่ได้

รันไทม์ V8 ที่ขับเคลื่อน Chrome และ Node.js รองรับ Apps Script แล้วในตอนนี้เพื่อคลายความกังวลนี้ คุณสามารถย้ายข้อมูลสคริปต์ที่มีอยู่ไปยัง V8 เพื่อใช้ประโยชน์จากไวยากรณ์และฟีเจอร์ JavaScript สมัยใหม่

หน้านี้จะอธิบายฟีเจอร์ใหม่ที่ V8 เปิดใช้และวิธีเปิดใช้ V8 เพื่อใช้ในสคริปต์ การย้ายสคริปต์ไปยัง V8อธิบายขั้นตอนในการย้ายสคริปต์ที่มีอยู่ไปใช้รันไทม์ V8

ฟีเจอร์ของรันไทม์ V8

สคริปต์ที่ใช้รันไทม์ V8 สามารถใช้ฟีเจอร์ต่อไปนี้

ไวยากรณ์ ECMAScript สมัยใหม่

คุณสามารถใช้ไวยากรณ์ ECMAScript แบบใหม่ในสคริปต์ที่ขับเคลื่อนโดยรันไทม์ V8 ไวยากรณ์นี้รวมถึง let, const และฟีเจอร์ยอดนิยมอื่นๆ อีกมากมาย

ดูตัวอย่างไวยากรณ์ V8 เพื่อดูรายการสั้นๆ ของการปรับปรุงไวยากรณ์ยอดนิยมที่คุณทำได้โดยใช้รันไทม์ V8

การตรวจหาฟังก์ชันที่ดีขึ้น

การตรวจหาฟังก์ชันของ Apps Script ได้รับการปรับปรุงสำหรับสคริปต์ที่ใช้ V8 รันไทม์ใหม่จะจดจำรูปแบบคําจํากัดความของฟังก์ชันต่อไปนี้

      function normalFunction() {}
      async function asyncFunction() {}
      function* generatorFunction() {}

      var varFunction = function() {}
      let letFunction = function() {}
      const constFunction = function() {}

      var namedVarFunction = function alternateNameVarFunction() {}
      let namedLetFunction = function alternateNameLetFunction() {}
      const namedConstFunction = function alternateNameConstFunction() {}

      var varAsyncFunction = async function() {}
      let letAsyncFunction = async function() {}
      const constAsyncFunction = async function() {}

      var namedVarAsyncFunction = async function alternateNameVarAsyncFunction() {}
      let namedLetAsyncFunction = async function alternateNameLetAsyncFunction() {}
      const namedConstAsyncFunction = async function alternateNameConstAsyncFunction() {}

      var varGeneratorFunction = function*() {}
      let letGeneratorFunction = function*() {}
      const constGeneratorFunction = function*() {}

      var namedVarGeneratorFunction = function* alternateNameVarGeneratorFunction() {}
      let namedLetGeneratorFunction = function* alternateNameLetGeneratorFunction() {}
      const namedConstGeneratorFunction = function* alternateNameConstGeneratorFunction() {}

      var varLambda = () => {}
      let letLambda = () => {}
      const constLambda = () => {}

      var varAsyncLambda = async () => {}
      let letAsyncLambda = async () => {}
      const constAsyncLambda = async () => {}

เรียกเมธอดของออบเจ็กต์จากทริกเกอร์และการเรียกกลับ

สคริปต์ที่ใช้ V8 สามารถเรียกเมธอดของออบเจ็กต์และเมธอดแบบคงที่ของคลาสจากตำแหน่งที่คุณเรียกเมธอดของไลบรารีได้อยู่แล้ว สถานที่เหล่านี้มีดังต่อไปนี้

ตัวอย่าง V8 ต่อไปนี้แสดงการใช้เมธอดออบเจ็กต์เมื่อสร้างรายการเมนูใน Google ชีต

function onOpen() {
  var ui = SpreadsheetApp.getUi(); // Or DocumentApp, SlidesApp, or FormApp.
  ui.createMenu('Custom Menu')
      .addItem('First item', 'menu.item1')
      .addSeparator()
      .addSubMenu(ui.createMenu('Sub-menu')
          .addItem('Second item', 'menu.item2'))
      .addToUi();
}

var menu = {
  item1: function() {
    SpreadsheetApp.getUi().alert('You clicked: First item');
  },
  item2: function() {
    SpreadsheetApp.getUi().alert('You clicked: Second item');
  }
}

ดูบันทึก

Apps Script มีบริการบันทึก 2 รายการ ได้แก่ บริการ Logger และคลาส console บริการทั้ง 2 อย่างนี้จะเขียนบันทึกลงในบริการบันทึกของ Stackdriver เดียวกัน

หากต้องการแสดงบันทึก Logger และ console ให้คลิกบันทึกการดำเนินการที่ด้านบนของเครื่องมือแก้ไขสคริปต์

ดูการดำเนินการ

หากต้องการดูประวัติการดำเนินการของสคริปต์ ให้เปิดโปรเจ็กต์ Apps Script แล้วคลิกการดำเนินการ ทางด้านซ้าย

ตัวอย่างไวยากรณ์ V8

ต่อไปนี้เป็นรายการสั้นๆ ของฟีเจอร์ทางไวยากรณ์ยอดนิยมที่ใช้ได้กับสคริปต์ที่ใช้รันไทม์ V8

let และ const

คีย์เวิร์ด let และ const ช่วยให้คุณกำหนดตัวแปรภายในขอบเขตบล็อกและค่าคงที่ขอบเขตบล็อกได้

// V8 runtime
let s = "hello";
if (s === "hello") {
  let s = "world";
  console.log(s);  // Prints "world"
}
console.log(s);  // Prints "hello"

const N = 100;
N = 5; // Results in TypeError

ฟังก์ชันลูกศร

ฟังก์ชันลูกศรเป็นวิธีที่กะทัดรัดในการกำหนดฟังก์ชันภายในนิพจน์

// Rhino runtime
function square(x) {
  return x * x;
}

console.log(square(5));  // Outputs 25
      
// V8 runtime
const square = x => x * x;
console.log(square(5));  // Outputs 25

// Outputs [1, 4, 9]
console.log([1, 2, 3].map(x => x * x));

ชั้นเรียน

คลาสเป็นวิธีจัดระเบียบโค้ดตามแนวคิดด้วยการรับช่วง คลาสใน V8 เป็นหลักคือไวยากรณ์ที่ช่วยให้เขียนโค้ดได้ง่ายขึ้นเหนือการสืบทอดที่อิงตามโปรโตไทป์ของ JavaScript

// V8 runtime
class Rectangle {
  constructor(width, height) { // class constructor
    this.width = width;
    this.height = height;
  }

  logToConsole() { // class method
    console.log(`Rectangle(width=${this.width}, height=${this.height})`);
  }
}

const r = new Rectangle(10, 20);
r.logToConsole();  // Outputs Rectangle(width=10, height=20)

การกำหนดโครงสร้างใหม่

นิพจน์การกําหนดค่าแบบแยกโครงสร้างเป็นวิธีที่รวดเร็วในการแยกค่าออกจากอาร์เรย์และออบเจ็กต์ไปยังตัวแปรที่แตกต่างกัน

// Rhino runtime
var data = {a: 12, b: false, c: 'blue'};
var a = data.a;
var c = data.c;
console.log(a, c);  // Outputs 12 "blue"

var array = [1, 2, 3];
var x = a[0];
var y = a[1];
var z = a[2];
console.log(x, y, z);  // Outputs 1 2 3
      
// V8 runtime
var data = {a: 12, b: false, c: 'blue'};
var {a, c} = data;
console.log(a, c);  // Outputs 12 "blue"


var array = [1, 2, 3];
var [x, y, z] = array;
console.log(x, y, z);  // Outputs 1 2 3

นิพจน์เทมเพลต

นิพจน์เทมเพลตคือการนําเข้าสตริงที่อนุญาตให้ฝังนิพจน์ ซึ่งช่วยให้คุณหลีกเลี่ยงการเขียนคำสั่งการต่อสตริงที่ซับซ้อนมากขึ้น

// Rhino runtime
var name =
  'Hi ' + first + ' ' + last + '.';
var url =
  'http://localhost:3000/api/messages/'
  + id;
      
// V8 runtime
var name = `Hi ${first} ${last}.`;
var url =
  `http://localhost:3000/api/messages/${id}`;

พารามิเตอร์เริ่มต้น

พารามิเตอร์เริ่มต้นช่วยให้คุณระบุค่าเริ่มต้นสำหรับพารามิเตอร์ของฟังก์ชันในการประกาศฟังก์ชันได้ วิธีนี้ช่วยให้โค้ดในเนื้อหาของฟังก์ชันง่ายขึ้น เนื่องจากจะช่วยลดความจำเป็นในการกําหนดค่าเริ่มต้นให้กับพารามิเตอร์ที่ขาดหายไปอย่างชัดเจน

// Rhino runtime
function hello(greeting, name) {
    greeting = greeting || "hello";
    name = name || "world";
    console.log(
        greeting + " " + name + "!");
}

hello();  // Outputs "hello world!"
      
// V8 runtime
var hello =
  function(greeting="hello", name="world") {
      console.log(
        greeting + " " + name + "!");
  }

hello();  // Outputs "hello world!"

สตริงหลายบรรทัด

คุณสามารถกําหนดสตริงหลายบรรทัดได้โดยใช้ไวยากรณ์เดียวกับนิพจน์เทมเพลต ไวยากรณ์นี้ช่วยให้คุณหลีกเลี่ยงการต่อสตริงและลดความซับซ้อนของคำจำกัดความสตริงได้เช่นเดียวกับนิพจน์เทมเพลต

// Rhino runtime
var multiline = "This string is sort of\n"
+ "like a multi-line string,\n"
+ "but it's not really one.";
      
// V8 runtime
var multiline = `This on the other hand,
actually is a multi-line string,
thanks to JavaScript ES6`;

การเปิดใช้รันไทม์ V8

หากสคริปต์ใช้รันไทม์ Rhino อยู่ คุณสามารถเปลี่ยนไปใช้ V8 ได้โดยทําดังนี้

  1. เปิดโปรเจ็กต์ Apps Script
  2. คลิกการตั้งค่าโปรเจ็กต์ ทางด้านซ้าย
  3. เลือกช่องทำเครื่องหมายเปิดใช้รันไทม์ Chrome V8

หรือจะระบุรันไทม์ของสคริปต์โดยตรงโดยการแก้ไขไฟล์ Manifest ของสคริปต์ก็ได้ โดยทำดังนี้

  1. เปิดโปรเจ็กต์ Apps Script
  2. คลิกการตั้งค่าโปรเจ็กต์ ทางด้านซ้าย
  3. เลือกช่องทําเครื่องหมายแสดงไฟล์ Manifest "appsscript.json" ในเครื่องมือแก้ไข
  4. ทางด้านซ้าย ให้คลิกเครื่องมือแก้ไข > appsscript.json
  5. ในไฟล์ Manifest appsscript.json ให้ตั้งค่าช่อง runtimeVersion เป็นค่า V8
  6. คลิกบันทึกโปรเจ็กต์ ที่ด้านบน

การย้ายข้อมูลสคริปต์ไปยัง V8 จะอธิบายขั้นตอนอื่นๆ ที่คุณควรทำเพื่อให้สคริปต์ทำงานได้ดีโดยใช้ V8

การเปิดใช้รันไทม์ Rhino

หากสคริปต์ใช้ V8 และคุณต้องเปลี่ยนไปใช้รันไทม์ Rhino เดิม ให้ทําดังนี้

  1. เปิดโปรเจ็กต์ Apps Script
  2. คลิกการตั้งค่าโปรเจ็กต์ ทางด้านซ้าย
  3. ล้างช่องทำเครื่องหมายเปิดใช้รันไทม์ Chrome V8

หรือจะแก้ไขไฟล์ Manifest ของสคริปต์ก็ได้ โดยทำดังนี้

  1. เปิดโปรเจ็กต์ Apps Script
  2. คลิกการตั้งค่าโปรเจ็กต์ ทางด้านซ้าย
  3. เลือกช่องทําเครื่องหมายแสดงไฟล์ Manifest "appsscript.json" ในเครื่องมือแก้ไข
  4. ทางด้านซ้าย ให้คลิกเครื่องมือแก้ไข > appsscript.json
  5. ในไฟล์ Manifest appsscript.json ให้ตั้งค่าช่อง runtimeVersion เป็นค่า DEPRECATED_ES5
  6. คลิกบันทึกโปรเจ็กต์ ที่ด้านบน

ฉันจะย้ายข้อมูลสคริปต์ที่มีอยู่ได้อย่างไร

คู่มือการย้ายข้อมูลสคริปต์ไปยัง V8 อธิบายขั้นตอนที่คุณต้องดำเนินการเพื่อย้ายข้อมูลสคริปต์ที่มีอยู่ไปใช้ V8 ซึ่งเกี่ยวข้องกับการเปิดใช้รันไทม์ V8 และตรวจสอบสคริปต์เพื่อหาความไม่เข้ากันได้ที่ทราบ

การย้ายข้อมูลสคริปต์ไปยัง V8 โดยอัตโนมัติ

ตั้งแต่วันที่ 18 กุมภาพันธ์ 2020 เป็นต้นไป Google จะเริ่มทยอยย้ายข้อมูลสคริปต์ที่มีอยู่ซึ่งผ่านการทดสอบความเข้ากันได้แบบอัตโนมัติไปยัง V8 สคริปต์ที่ได้รับผลกระทบจะยังคงทํางานตามปกติหลังจากการย้ายข้อมูล

หากต้องการเลือกไม่ใช้สคริปต์ในการย้ายข้อมูลอัตโนมัติ ให้ตั้งค่าช่อง runtimeVersion ในไฟล์ Manifest เป็น DEPRECATED_ES5 คุณเลือกย้ายข้อมูลสคริปต์ไปยัง V8 ด้วยตนเองได้ทุกเมื่อหลังจากนั้น

ฉันจะรายงานข้อบกพร่องได้อย่างไร

คู่มือการสนับสนุนอธิบายวิธีรับความช่วยเหลือด้านการเขียนโปรแกรมใน Stack Overflow, ค้นหารายงานปัญหาที่มีอยู่, รายงานข้อบกพร่องใหม่ และส่งคำขอฟีเจอร์ใหม่