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

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

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

ที่ผ่านมา Apps Script ขับเคลื่อนโดย แรด JavaScript ของ Mozilla' แม้ว่า Rhino จะมีทางเลือกที่สะดวกในการให้ Apps Script เรียกใช้สคริปต์ของนักพัฒนาซอฟต์แวร์ แต่ Rhino ยังเชื่อมโยง 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 ทั้งสองบริการจะเขียนบันทึกไปยังบริการบันทึกสแต็กไดรฟ์เดียวกัน

หากต้องการแสดงบันทึก 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. ในไฟล์ appsscript.json ไฟล์ Manifest ให้ตั้งค่าช่อง 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. ในไฟล์ appsscript.json ไฟล์ Manifest ให้ตั้งค่าช่อง runtimeVersion เป็นค่า DEPRECATED_ES5
  6. คลิกบันทึกโครงการ ที่ด้านบน

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

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

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

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

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

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

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