अगर आपके पास Rhino रनटाइम का इस्तेमाल करने वाली कोई मौजूदा स्क्रिप्ट है और आपको V8 सिंटैक्स और सुविधाओं का इस्तेमाल करना है, तो आपको स्क्रिप्ट को V8 पर माइग्रेट करना होगा.
Rhino रनटाइम का इस्तेमाल करके लिखी गई ज़्यादातर स्क्रिप्ट को बिना बदलाव के V8 रनटाइम का इस्तेमाल करके चलाया जा सकता है. अक्सर स्क्रिप्ट में V8 सिंटैक्स और सुविधाएं जोड़ने के लिए, V8 रनटाइम को चालू करना ज़रूरी होता है.
हालांकि, इसमें काम नहीं करने वाली और कुछ अन्य अंतर होते हैं. इसकी वजह से, V8 रनटाइम को चालू करने के बाद स्क्रिप्ट काम नहीं कर पाती या काम करने में समस्या आ सकती है. V8 का इस्तेमाल करने के लिए स्क्रिप्ट को माइग्रेट करते समय, आपको इन समस्याओं के लिए स्क्रिप्ट प्रोजेक्ट खोजना होगा और मिलने वाली समस्याओं को ठीक करना होगा.
V8 माइग्रेशन प्रोसेस
स्क्रिप्ट को V8 पर माइग्रेट करने के लिए, यह तरीका अपनाएं:
- स्क्रिप्ट के लिए, V8 रनटाइम चालू करें.
- नीचे दी गई अनियमितताओं की ध्यान से समीक्षा करें. अपनी स्क्रिप्ट की जांच करके पता लगाएं कि कोई गड़बड़ी मौजूद है या नहीं. अगर एक या उससे ज़्यादा गड़बड़ियां मौजूद हैं, तो समस्या को हटाने या उससे बचने के लिए, अपने स्क्रिप्ट कोड में बदलाव करें.
- नीचे दिए गए अन्य अंतर ध्यान से पढ़ें. अपनी स्क्रिप्ट की जांच करके पता लगाएं कि क्या सूची में दिए गए किसी भी अंतर का असर आपके कोड के काम करने के तरीके पर पड़ता है. बिहेवियर ठीक करने के लिए, अपनी स्क्रिप्ट में बदलाव करें.
- मिलती-जुलती किसी समस्या या अन्य अंतर को ठीक करने के बाद, अपने कोड को अपडेट करना शुरू किया जा सकता है. ऐसा करके, ज़रूरत के हिसाब से V8 सिंटैक्स और अन्य सुविधाओं का इस्तेमाल किया जा सकता है.
- अपने कोड में बदलाव करने के बाद, अपनी स्क्रिप्ट की अच्छी तरह से जांच करके पक्का करें कि वह उम्मीद के मुताबिक काम कर रही है.
- अगर आपकी स्क्रिप्ट कोई वेब ऐप्लिकेशन है या आपने ऐड-ऑन पब्लिश किया है, तो आपको V8 अडजस्टमेंट की मदद से, स्क्रिप्ट का नया वर्शन बनाना होगा. उपयोगकर्ताओं को V8 वर्शन उपलब्ध कराने के लिए, आपको इस वर्शन की स्क्रिप्ट को दोबारा पब्लिश करना होगा.
साथ काम नहीं करती
दुर्भाग्य से, मूल Rhino आधारित Apps Script रनटाइम ने कई गैर-मानक ECMAScript व्यवहार की अनुमति दी है. V8 स्टैंडर्ड का पालन करता है. इसलिए, माइग्रेशन के बाद ये काम नहीं करते. इन समस्याओं को ठीक न करने पर, V8 रनटाइम चालू होने के बाद गड़बड़ियां हो सकती हैं या स्क्रिप्ट काम करना बंद कर सकती है.
यहां दिए गए सेक्शन में, कन्वर्ज़न के इन सभी तरीकों के बारे में बताया गया है. साथ ही, इसमें यह भी बताया गया है कि V8 पर माइग्रेट करने के दौरान, स्क्रिप्ट कोड को कैसे ठीक किया जा सकता है.
for each(variable in object) से बचें
for each (variable in object) स्टेटमेंट को JavaScript 1.6 में जोड़ा गया और for...of के पक्ष में हटा दिया गया.
स्क्रिप्ट को V8 पर माइग्रेट करते समय, for each (variable in object)
स्टेटमेंट का इस्तेमाल करने से बचें.
इसके बजाय, for (variable in object) का इस्तेमाल करें:
// Rhino runtime
var obj = {a: 1, b: 2, c: 3};
// Don't use 'for each' in V8
for each (var value in obj) {
Logger.log("value = %s", value);
}
|
// V8 runtime
var obj = {a: 1, b: 2, c: 3};
for (var key in obj) { // OK in V8
var value = obj[key];
Logger.log("value = %s", value);
}
|
Date.prototype.getYear() से बचें
ओरिजनल राइनो रनटाइम में, Date.prototype.getYear() 1900 से 1999 तक के सालों के लिए दो अंकों वाला साल दिखाता है. हालांकि, अन्य तारीखों के लिए चार अंकों वाला साल दिखाता है, जैसा कि JavaScript 1.2 और उससे पहले के वर्शन में किया गया था.
V8 रनटाइम में, Date.prototype.getYear() ECMAScript मानकों के मुताबिक, साल 1900 को माइनस 1900 के तौर पर दिखाता है.
अपनी स्क्रिप्ट को V8 पर माइग्रेट करते समय, हमेशा Date.prototype.getFullYear() का इस्तेमाल करें. यह तारीख पर ध्यान दिए बिना, चार अंकों वाला साल दिखाता है.
रिज़र्व किए गए कीवर्ड को नाम के तौर पर इस्तेमाल करने से बचें
ECMAScript कुछ रिज़र्व किए गए कीवर्ड को फ़ंक्शन और वैरिएबल के नामों में इस्तेमाल करने की अनुमति नहीं देती है. Rhino रनटाइम में इनमें से कई शब्दों की अनुमति थी. इसलिए, अगर आपका कोड उनका इस्तेमाल करता है, तो आपको अपने फ़ंक्शन या वैरिएबल के नाम बदलने होंगे.
अपनी स्क्रिप्ट को V8 पर माइग्रेट करते समय, रिज़र्व किए गए कीवर्ड में से किसी एक का इस्तेमाल करके, वैरिएबल या फ़ंक्शन का नाम रखने से बचें.
कीवर्ड के नाम का इस्तेमाल करने से बचने के लिए, किसी भी वैरिएबल या फ़ंक्शन का नाम बदलें. कीवर्ड के सामान्य इस्तेमाल
class, import, और export हैं.
const वैरिएबल को फिर से असाइन करने से बचें
मूल Rhino रनटाइम में, const का इस्तेमाल करके, किसी वैरिएबल का एलान किया जा सकता है. इसका मतलब है कि सिंबल की वैल्यू कभी नहीं बदलती है और न ही सिंबल के लिए असाइन किए जाने वाले आने वाले समय को अनदेखा कर दिया जाता है.
नए V8 रनटाइम में, const कीवर्ड, स्टैंडर्ड का पालन करता है और const के तौर पर बताए गए वैरिएबल को असाइन करता है. इससे, TypeError: Assignment to constant variable रनटाइम की गड़बड़ी मिलती है.
अपनी स्क्रिप्ट को V8 पर माइग्रेट करते समय, const वैरिएबल की वैल्यू फिर से असाइन करने की कोशिश न करें:
// Rhino runtime
const x = 1;
x = 2; // No error
console.log(x); // Outputs 1
|
// V8 runtime
const x = 1;
x = 2; // Throws TypeError
console.log(x); // Never executed
|
एक्सएमएल की लिटरल और एक्सएमएल ऑब्जेक्ट से बचें
ECMAScript के लिए बिना स्टैंडर्ड वाला यह एक्सटेंशन, Apps Script प्रोजेक्ट को सीधे एक्सएमएल सिंटैक्स का इस्तेमाल करने की अनुमति देता है.
अपनी स्क्रिप्ट को V8 पर माइग्रेट करते समय, डायरेक्ट एक्सएमएल लिटरल या एक्सएमएल ऑब्जेक्ट का इस्तेमाल करने से बचें.
इसके बजाय, एक्सएमएल को पार्स करने के लिए, XmlService का इस्तेमाल करें:
// V8 runtime
var incompatibleXml1 = <container><item/></container>; // Don't use
var incompatibleXml2 = new XML('<container><item/></container>'); // Don't use
var xml3 = XmlService.parse('<container><item/></container>'); // OK
|
__iterator__ का इस्तेमाल करके, कस्टम इटरेटर फ़ंक्शन न बनाएं
JavaScript 1.7 में एक ऐसी सुविधा जोड़ी गई है जो उस क्लास के प्रोटोटाइप में __iterator__ फ़ंक्शन का एलान करके, किसी भी क्लास में कस्टम इटरेटर जोड़ने की अनुमति देती है. डेवलपर सुविधा के तौर पर, इसे Apps Script के Rhino रनटाइम में भी जोड़ा गया था. हालांकि, यह सुविधा कभी भी ECMA-262 स्टैंडर्ड का हिस्सा नहीं थी और इसे ECMAScript के JavaScript इंजन से हटा दिया गया था. V8 का इस्तेमाल करने वाली स्क्रिप्ट, इस इटरेटर कंस्ट्रक्शन का इस्तेमाल नहीं कर सकतीं.
अपनी स्क्रिप्ट को V8 पर माइग्रेट करते समय, कस्टम इटरेटर बनाने के लिए, __iterator__ फ़ंक्शन का इस्तेमाल न करें. इसके बजाय, ECMAScript 6 के इटरेटर का इस्तेमाल करें.
नीचे दिए गए कलेक्शन का इस्तेमाल करें:
// Create a sample array
var myArray = ['a', 'b', 'c'];
// Add a property to the array
myArray.foo = 'bar';
// The default behavior for an array is to return keys of all properties,
// including 'foo'.
Logger.log("Normal for...in loop:");
for (var item in myArray) {
Logger.log(item); // Logs 0, 1, 2, foo
}
// To only log the array values with `for..in`, a custom iterator can be used.
|
कोड के इन उदाहरणों में दिखाया गया है कि Rhino रनटाइम में इटरेटर को कैसे बनाया जा सकता है और V8 रनटाइम में रीप्लेसमेंट इटरेटर कैसे बनाया जाता है:
// Rhino runtime custom iterator
function ArrayIterator(array) {
this.array = array;
this.currentIndex = 0;
}
ArrayIterator.prototype.next = function() {
if (this.currentIndex
>= this.array.length) {
throw StopIteration;
}
return "[" + this.currentIndex
+ "]=" + this.array[this.currentIndex++];
};
// Direct myArray to use the custom iterator
myArray.__iterator__ = function() {
return new ArrayIterator(this);
}
Logger.log("With custom Rhino iterator:");
for (var item in myArray) {
// Logs [0]=a, [1]=b, [2]=c
Logger.log(item);
}
|
// V8 runtime (ECMAScript 6) custom iterator
myArray[Symbol.iterator] = function() {
var currentIndex = 0;
var array = this;
return {
next: function() {
if (currentIndex < array.length) {
return {
value: "[${currentIndex}]="
+ array[currentIndex++],
done: false};
} else {
return {done: true};
}
}
};
}
Logger.log("With V8 custom iterator:");
// Must use for...of since
// for...in doesn't expect an iterable.
for (var item of myArray) {
// Logs [0]=a, [1]=b, [2]=c
Logger.log(item);
}
|
कंडिशनल कैच क्लॉज़ से बचना
V8 रनटाइम पर, catch..if कंडिशनल कैच क्लॉज़ काम नहीं करते, क्योंकि वे स्टैंडर्ड का पालन नहीं करते.
अपनी स्क्रिप्ट को V8 पर माइग्रेट करते समय, सभी कैच कंडिशनल को कैच बॉडी में मूव करें:
// Rhino runtime
try {
doSomething();
} catch (e if e instanceof TypeError) { // Don't use
// Handle exception
}
|
// V8 runtime
try {
doSomething();
} catch (e) {
if (e instanceof TypeError) {
// Handle exception
}
}
|
Object.prototype.toSource() का इस्तेमाल करने से बचें
JavaScript 1.3 में एक Object.prototype.toSource() तरीका था, जो कभी भी किसी ECMAScript स्टैंडर्ड का हिस्सा नहीं था. यह सुविधा, V8 रनटाइम में काम नहीं करती.
अपनी स्क्रिप्ट को V8 पर माइग्रेट करते समय, अपने कोड से Object.prototype.toSource() का इस्तेमाल हटा दें.
अन्य अंतर
ऊपर दी गई कुछ गड़बड़ियों के अलावा, कुछ अन्य गड़बड़ियां भी हो सकती हैं. इन गड़बड़ियों को ठीक न करने पर, V8 रनटाइम स्क्रिप्ट का अनचाहा व्यवहार देखने को मिल सकता है.
नीचे दिए सेक्शन में बताया गया है कि अचानक होने वाली इन गड़बड़ियों से बचने के लिए, स्क्रिप्ट कोड को कैसे अपडेट करें.
स्थान-भाषा के हिसाब से, तारीख और समय की फ़ॉर्मैटिंग में बदलाव करना
Date
तरीके toLocaleString(),
toLocaleDateString(), और toLocaleTimeString(), राइनो की तुलना में V8 रनटाइम में अलग तरह से काम करते हैं.
Rhino में डिफ़ॉल्ट फ़ॉर्मैट लंबा फ़ॉर्मैट होता है. इसमें पास किए गए सभी पैरामीटर को अनदेखा किया जाता है.
V8 रनटाइम में, डिफ़ॉल्ट फ़ॉर्मैट छोटा फ़ॉर्मैट होता है. इसमें पास किए गए पैरामीटर, ECMA स्टैंडर्ड के हिसाब से मैनेज किए जाते हैं. ज़्यादा जानकारी के लिए, toLocaleDateString() दस्तावेज़ देखें.
अपनी स्क्रिप्ट को V8 पर माइग्रेट करते समय, स्थान-भाषा के हिसाब से तारीख और समय के तरीकों के आउटपुट के बारे में जांच करें और कोड के हिसाब से अपने कोड में बदलाव करें:
// Rhino runtime
var event = new Date(
Date.UTC(2012, 11, 21, 12));
// Outputs "December 21, 2012" in Rhino
console.log(event.toLocaleDateString());
// Also outputs "December 21, 2012",
// ignoring the parameters passed in.
console.log(event.toLocaleDateString(
'de-DE',
{ year: 'numeric',
month: 'long',
day: 'numeric' }));
|
// V8 runtime
var event = new Date(
Date.UTC(2012, 11, 21, 12));
// Outputs "12/21/2012" in V8
console.log(event.toLocaleDateString());
// Outputs "21. Dezember 2012"
console.log(event.toLocaleDateString(
'de-DE',
{ year: 'numeric',
month: 'long',
day: 'numeric' }));
|
Error.fileName और Error.lineNumber का इस्तेमाल करने से बचें
V8 अनटाइम में, स्टैंडर्ड JavaScript Error ऑब्जेक्ट, fileName या lineNumber को कंस्ट्रक्टर पैरामीटर या ऑब्जेक्ट प्रॉपर्टी के तौर पर काम नहीं करता.
अपनी स्क्रिप्ट को V8 पर माइग्रेट करते समय,
Error.fileName और Error.lineNumber की डिपेंडेंसी हटाएं.
इसका दूसरा विकल्प Error.prototype.stack का इस्तेमाल करना है.
यह स्टैक स्टैंडर्ड के मुताबिक नहीं है. हालांकि, यह Rhino और V8, दोनों पर काम करता है. दोनों प्लैटफ़ॉर्म के बनाए गए स्टैक ट्रेस का फ़ॉर्मैट थोड़ा अलग है:
// Rhino runtime Error.prototype.stack // stack trace format at filename:92 (innerFunction) at filename:97 (outerFunction) |
// V8 runtime Error.prototype.stack
// stack trace format
Error: error message
at innerFunction (filename:92:11)
at outerFunction (filename:97:5)
|
स्ट्रिंगिफ़ाइड ईनम ऑब्जेक्ट की हैंडलिंग को अडजस्ट करें
ओरिजनल Rhino रनटाइम में, ईनम ऑब्जेक्ट पर JavaScript JSON.stringify() वाले तरीके का इस्तेमाल करने से सिर्फ़ {} दिखता है.
V8 में, ईनम ऑब्जेक्ट पर एक ही तरीके का इस्तेमाल करने से, ईनम का नाम फिर से बदल जाता है.
अपनी स्क्रिप्ट को V8 पर माइग्रेट करते समय,
enum ऑब्जेक्ट पर
JSON.stringify() के आउटपुट को लेकर अपने कोड की उम्मीदों की जांच करें और उसमें बदलाव करें:
// Rhino runtime
var enumName =
JSON.stringify(Charts.ChartType.BUBBLE);
// enumName evaluates to {}
|
// V8 runtime var enumName = JSON.stringify(Charts.ChartType.BUBBLE); // enumName evaluates to "BUBBLE" |
तय नहीं किए गए पैरामीटर की हैंडलिंग में बदलाव करना
ओरिजनल Rhino रनटाइम में, undefined को किसी पैरामीटर के तौर पर किसी मेथड से पास करने की वजह से, उस तरीके में "undefined" स्ट्रिंग पास होती है.
V8 में, undefined को तरीकों में पास करना, null को पास करने के बराबर है.
अपनी स्क्रिप्ट को V8 पर माइग्रेट करते समय,
undefined पैरामीटर को लेकर अपने कोड की जांच करें और ज़रूरत के हिसाब से उसमें बदलाव करें:
// Rhino runtime
SpreadsheetApp.getActiveRange()
.setValue(undefined);
// The active range now has the string
// "undefined" as its value.
|
// V8 runtime
SpreadsheetApp.getActiveRange()
.setValue(undefined);
// The active range now has no content, as
// setValue(null) removes content from
// ranges.
|
ग्लोबल this की हैंडलिंग में बदलाव करें
Rhino रनटाइम, इसका इस्तेमाल करने वाली स्क्रिप्ट के लिए एक खास कॉन्टेक्स्ट के बारे में बताता है.
स्क्रिप्ट कोड, इंप्लिसिट कॉन्टेक्स्ट में चलता है और यह असल ग्लोबल this से अलग होता है. इसका मतलब है कि कोड में "ग्लोबल this" के रेफ़रंस से असल में खास कॉन्टेक्स्ट का आकलन किया जाता है, जिसमें सिर्फ़ स्क्रिप्ट में तय किए गए कोड और वैरिएबल शामिल होते हैं. पहले से मौजूद Apps Script सेवाओं और ECMAScript ऑब्जेक्ट को this के इस इस्तेमाल में शामिल नहीं किया जाता. यह स्थिति JavaScript के इस स्ट्रक्चर से मिलती-जुलती थी:
// Rhino runtime
// Apps Script built-in services defined here, in the actual global context.
var SpreadsheetApp = {
openById: function() { ... }
getActive: function() { ... }
// etc.
};
function() {
// Implicit special context; all your code goes here. If the global this
// is referenced in your code, it only contains elements from this context.
// Any global variables you defined.
var x = 42;
// Your script functions.
function myFunction() {
...
}
// End of your code.
}();
|
वर्शन 8 में, इंप्लिसिट खास कॉन्टेक्स्ट हटा दिया जाता है. स्क्रिप्ट में तय किए गए ग्लोबल वैरिएबल और फ़ंक्शन को ग्लोबल कॉन्टेक्स्ट में, पहले से मौजूद Apps Script सेवाओं और Math और Date जैसे ECMAScript बिल्ट-इन के बगल में रखा जाता है.
अपनी स्क्रिप्ट को V8 पर माइग्रेट करते समय, ग्लोबल कॉन्टेक्स्ट में this के इस्तेमाल को लेकर, अपने कोड की जांच करें और उसके हिसाब से काम करें. ज़्यादातर मामलों में, अंतर सिर्फ़ तब दिखते हैं, जब आपका कोड, ग्लोबल this ऑब्जेक्ट की कुंजियों या प्रॉपर्टी के नामों की जांच करता है:
// Rhino runtime
var myGlobal = 5;
function myFunction() {
// Only logs [myFunction, myGlobal];
console.log(Object.keys(this));
// Only logs [myFunction, myGlobal];
console.log(
Object.getOwnPropertyNames(this));
}
|
// V8 runtime
var myGlobal = 5;
function myFunction() {
// Logs an array that includes the names
// of Apps Script services
// (CalendarApp, GmailApp, etc.) in
// addition to myFunction and myGlobal.
console.log(Object.keys(this));
// Logs an array that includes the same
// values as above, and also includes
// ECMAScript built-ins like Math, Date,
// and Object.
console.log(
Object.getOwnPropertyNames(this));
}
|
लाइब्रेरी में instanceof की हैंडलिंग में बदलाव करें
किसी ऐसे ऑब्जेक्ट पर लाइब्रेरी में instanceof का इस्तेमाल करने से, जिसे किसी दूसरे प्रोजेक्ट के फ़ंक्शन में पैरामीटर के तौर पर पास किया जाता है, फ़ॉल्स नेगेटिव हो सकते हैं. V8 रनटाइम में, कोई प्रोजेक्ट और उसकी लाइब्रेरी अलग-अलग कॉन्टेक्स्ट में चलती हैं. इसलिए, ग्लोबल और प्रोटोटाइप की अलग-अलग चेन होती हैं.
ध्यान दें कि ऐसा सिर्फ़ तब होता है, जब आपकी लाइब्रेरी किसी ऐसे ऑब्जेक्ट पर instanceof का इस्तेमाल करती है जो आपके प्रोजेक्ट में नहीं बनाया गया है. इसे आपके प्रोजेक्ट में बनाए गए किसी ऑब्जेक्ट पर इस्तेमाल करने से, यह उम्मीद के मुताबिक काम करेगा. भले ही, यह आपके प्रोजेक्ट के अंदर उसी या किसी दूसरी स्क्रिप्ट में हो.
अगर V8 पर चल रहे कोई प्रोजेक्ट, आपकी स्क्रिप्ट को लाइब्रेरी के तौर पर इस्तेमाल करता है, तो देखें कि क्या आपकी स्क्रिप्ट किसी ऐसे पैरामीटर पर instanceof का इस्तेमाल कर रही है जो किसी दूसरे प्रोजेक्ट से पास किया जाएगा. instanceof के इस्तेमाल में बदलाव करें और इस्तेमाल के उदाहरण के हिसाब से, अन्य विकल्प इस्तेमाल करें.
अगर आपको पूरी प्रोटोटाइप चेन खोजने और सिर्फ़ कंस्ट्रक्टर की जांच करने की ज़रूरत नहीं है, तो a instanceof b का एक विकल्प a के कंस्ट्रक्टर का इस्तेमाल करना हो सकता है.
इस्तेमाल: a.constructor.name == "b"
प्रोजेक्ट A और प्रोजेक्ट B का इस्तेमाल करें, जहां प्रोजेक्ट A का इस्तेमाल लाइब्रेरी के तौर पर किया जाता है.
//Rhino runtime
//Project A
function caller() {
var date = new Date();
// Returns true
return B.callee(date);
}
//Project B
function callee(date) {
// Returns true
return(date instanceof Date);
}
|
//V8 runtime
//Project A
function caller() {
var date = new Date();
// Returns false
return B.callee(date);
}
//Project B
function callee(date) {
// Incorrectly returns false
return(date instanceof Date);
// Consider using return (date.constructor.name ==
// “Date”) instead.
// return (date.constructor.name == “Date”) -> Returns
// true
}
|
दूसरा विकल्प एक ऐसा फ़ंक्शन हो सकता है जो मुख्य प्रोजेक्ट में instanceof की जांच करता हो. साथ ही, लाइब्रेरी फ़ंक्शन को कॉल करते समय, अन्य पैरामीटर के अलावा फ़ंक्शन को पास करता हो. इसके बाद, पास किए गए फ़ंक्शन का इस्तेमाल करके, लाइब्रेरी के अंदर instanceof की जांच की जा सकती है.
//V8 runtime
//Project A
function caller() {
var date = new Date();
// Returns True
return B.callee(date, date => date instanceof Date);
}
//Project B
function callee(date, checkInstanceOf) {
// Returns True
return checkInstanceOf(date);
}
|
शेयर नहीं किए गए संसाधनों को लाइब्रेरी में भेजना सही करें
शेयर नहीं किए गए संसाधन को मुख्य स्क्रिप्ट से लाइब्रेरी में पास करने का तरीका V8 रनटाइम में अलग तरह से काम करता है.
Rhino रनटाइम में, शेयर न किए गए संसाधन से काम नहीं बनता. इसके बजाय, लाइब्रेरी अपने संसाधन का इस्तेमाल करती है.
V8 रनटाइम में, शेयर नहीं किए गए संसाधन को लाइब्रेरी में पास किया जाता है. लाइब्रेरी, पास किए गए ऐसे संसाधन का इस्तेमाल करती है जो शेयर नहीं किया गया है.
शेयर नहीं किए गए संसाधनों को फ़ंक्शन पैरामीटर के तौर पर पास न करें. शेयर नहीं किए गए संसाधनों को हमेशा उसी स्क्रिप्ट में बताएं जो उनका इस्तेमाल करती है.
प्रोजेक्ट A और प्रोजेक्ट B का इस्तेमाल करें, जहां प्रोजेक्ट A का इस्तेमाल लाइब्रेरी के तौर पर किया जाता है. इस उदाहरण में, PropertiesService एक शेयर नहीं किया गया संसाधन है.
// Rhino runtime
// Project A
function testPassingNonSharedProperties() {
PropertiesService.getScriptProperties()
.setProperty('project', 'Project-A');
B.setScriptProperties();
// Prints: Project-B
Logger.log(B.getScriptProperties(
PropertiesService, 'project'));
}
|
// V8 runtime
// Project A
function testPassingNonSharedProperties() {
PropertiesService.getScriptProperties()
.setProperty('project', 'Project-A');
B.setScriptProperties();
// Prints: Project-A
Logger.log(B.getScriptProperties(
PropertiesService, 'project'));
}
|
स्टैंडअलोन स्क्रिप्ट का ऐक्सेस अपडेट करें
V8 रनटाइम पर चल रही स्टैंडअलोन स्क्रिप्ट के लिए, आपको उपयोगकर्ताओं को कम से कम स्क्रिप्ट देखने का ऐक्सेस देना होगा, ताकि स्क्रिप्ट के ट्रिगर ठीक से काम कर सकें.