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

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

ก่อนหน้านี้ Apps Script ขับเคลื่อนโดย Rhino JavaScript ของ 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 () => {}

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

สคริปต์ที่ใช้ 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. เลือกช่องทำเครื่องหมายแสดง "appsscript.json" Manifest ในตัวแก้ไข
  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. เลือกช่องทำเครื่องหมายแสดง "appsscript.json" Manifest ในตัวแก้ไข
  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, ค้นหารายงานปัญหาที่มีอยู่, รายงานข้อบกพร่องใหม่ และ ส่งคำขอฟีเจอร์ใหม่