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

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

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

เพื่อแก้ไขข้อกังวลนี้ ตอนนี้ Apps Script รองรับรันไทม์ V8 ที่ขับเคลื่อน Chrome และ Node.js แล้ว คุณสามารถย้ายข้อมูลสคริปต์ที่มีอยู่ไปยัง 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() {
  const 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();
}

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

ดูบันทึก

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

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

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

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

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

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

let และ const

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

// V8 runtime
let s = "hello";
if (s === "hello") {
  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 a = [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
const data = {a: 12, b: false, c: 'blue'};
const {a, c} = data;
console.log(a, c);  // Outputs 12 "blue"


const array = [1, 2, 3];
const [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
const name = `Hi ${first} ${last}.`;
const 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
const 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
const 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, ค้นหารายงานปัญหาที่มีอยู่, ยื่นรายงานข้อบกพร่องใหม่ และ ส่งคำขอฟีเจอร์ใหม่