ภาพรวมรันไทม์ 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 แล้ว คุณย้ายข้อมูลสคริปต์ที่มีอยู่ไปยัง 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 Logging เดียวกัน

หากต้องการแสดงบันทึก 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 ค้นหารายงานปัญหาที่มีอยู่ รายงานข้อบกพร่องใหม่ และส่งคำขอฟีเจอร์ใหม่