Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
Per migliorare le prestazioni degli script e quelle della piattaforma, rivedi e segui le procedure consigliate descritte di seguito.
Uso dei selettori
Usa filtri
Usa i filtri di un selettore invece di filtrare tu stesso le entità. I selettori consentono di filtrare in base a ID e condizioni. Ad esempio, è possibile filtrare in base al rendimento di un'entità (campagne di ritorno con un CPC medio superiore a 10), allo stato (campagne sospese), al nome dell'oggetto padre dell'entità e altro ancora.
Vantaggi dell'uso dei filtri:
Limita il numero di entità restituite dal selettore solo alle entità necessarie.
Consente l'esecuzione dello script più velocemente (meno entità da restituire ed elaborare)
Riduce la possibilità di scontrarsi con i limiti di lettura delle entità (consulta Limiti di esecuzione degli script).
Modo giusto
var adGroups = AdsApp.adGroups()
.withCondition('Status = PAUSED')
.get();
while (adGroups.hasNext()) {
var adGroup = adGroups.next();
// Do something with paused ad group.
}
Modo sbagliato
var adGroups = AdsApp.adGroups().get();
while (adGroups.hasNext()) {
var adGroup = adGroups.next();
if (adGroup.isPaused() == true) {
// Do something with paused ad group.
}
}
Non attraversare la gerarchia di entità
Se vuoi ottenere le entità figlio di un'entità o l'entità padre dell'entità, non attraversare la gerarchia delle entità per ottenerle.
Per ottenere entità figlio, usa la raccolta dell'entità figlio al livello desiderato.
Modo giusto
// Get all ads.
var ads = AdsApp.ads().get();
while (ads.hasNext()) {
var ad = ads.next();
// Do something with ad.
}
In alternativa, se vuoi annunci di una campagna specifica:
// Get all ads in the campaign, 'mycampaign'.
var ads = AdsApp.ads()
.withCondition("CampaignName = 'mycampaign'")
.get();
while (ads.hasNext()) {
var ad = ads.next();
// Do something with ad.
}
In alternativa, ottenere gli annunci di una campagna se si dispone dell'oggetto campagna:
// Get all ads in the campaign.
var ads = campaign.ads().get();
while (ads.hasNext()) {
var ad = ads.next();
// Do something with ad.
}
Modo sbagliato
var campaigns = AdsApp.campaigns().get();
while (campaigns.hasNext()) {
var adGroups = campaigns.next().adGroups().get();
while (adGroups.hasNext()) {
var ads = adGroups.next().ads().get();
while (ads.hasNext()) {
var ad = ads.next();
// Do something with ad.
}
}
}
Lo stesso vale se si desidera ottenere il padre di un'entità. Invece di attraversare la gerarchia per ottenere l'elemento padre, usare il metodo di accesso padre dell'entità figlio.
Modo giusto
// Get all ads.
var ads = AdsApp.ads()
.withCondition('Clicks > 5')
.forDateRange('LAST_7_DAYS')
.get();
while (ads.hasNext()) {
var ad = ads.next();
// Do something with campaign and adGroup.
var adGroup = ad.adGroup();
var campaign = ad.campaign();
}
Modo sbagliato
var campaigns = AdsApp.campaigns().get();
while (campaigns.hasNext()) {
var campaign = campaigns.next();
var adGroups = campaign.adGroups().get();
while (adGroups.hasNext()) {
var adGroup = adGroups.next();
var ads = adGroup.ads().get();
while (ads.hasNext()) {
var ad = ads.next();
if ('<some condition is met>') {
// Do something with campaign and adGroup.
}
}
}
}
Usa gli ID entità quando possibile
L'uso degli ID per filtrare le entità offre le migliori prestazioni.
Questo
var adGroups = AdsApp.adGroups()
.withIds(["123456"])
.get();
while (adGroups.hasNext()) {
var adGroup = adGroups.next();
// Do something with adGroup.
}
Offre prestazioni migliori di questo
var adGroups = AdsApp.adGroups()
.withCondition("Name = 'myadgroup'")
.get();
while (adGroups.hasNext()) {
var adGroup = adGroups.next();
// Do something with adGroup.
}
Evita cicli stretti con selettori e un numero non necessario di ottenere
Evita i cicli con richieste get che ottengono una singola entità. Si supponga ad esempio di eseguire un report sul rendimento delle parole chiave e di voler aggiornare le parole chiave nel report. Invece di ottenere una riga dal report, ottenere la parola chiave e quindi aggiornarla, è consigliabile creare un elenco degli ID parola chiave mentre si scorre ogni riga nel report. Passare quindi l'elenco di ID al selettore per ottenere tutte le parole chiave in una singola richiesta di lettura. È quindi possibile scorrere l'elenco delle parole chiave e aggiornarle.
Modo giusto
var report = AdsApp.report('<report query goes here>');
var rows = report.rows();
var idLists = []; // an array where each element contains an array of IDs.
var idList = []; // array of IDs that's limited to maxCount.
var maxCount = 10000;
while (rows.hasNext()) {
var row = rows.next();
if (idList.length < maxCount) {
idList.push(row['id']);
}
else {
idLists.push(idList);
idList = [];
}
}
for (idList of idLists) {
var keywords = AdsApp.keywords()
.withIds(idList)
.get();
while (keywords.hasNext()) {
var keyword = keywords.next();
// update the keyword
}
}
Modo sbagliato
var report = AdsApp.report('<report query goes here>');
var rows = report.rows();
while (rows.hasNext()) {
var row = rows.next();
var keyword = AdsApp.keywords()
.withIds([row['id']])
.get()
.next();
// update the keyword
}
Includere il metodo forDateRange solo se si prevede di chiamare il metodo getStats dell'entità
La chiamata al metodo di forDateRange un selettore fa sì che il selettore ottenga i dati sulle prestazioni dell'entità. Ottenere i dati sulle prestazioni di un'entità è costoso, quindi ottenerli solo se prevedi di chiamare il metodo dell'entità getStats e utilizzare i dati.
L'intervallo di date specificato per un'entità non si applica alle entità padre o figlio a cui si accede da tale entità. Ad esempio, se si ottiene un gruppo di annunci e quindi si ottiene la relativa campagna padre e si tenta di accedere alle metriche sul rendimento della campagna, la chiamata ha esito negativo.
La campaignStats.getReturnOnAdSpend() chiamata nell'esempio seguente ha esito negativo perché l'intervallo di date si applica al gruppo di annunci e non alla campagna.
var myAdGroups = AdsApp.adGroups().
.withCondition("CampaignName CONTAINS 'gen'")
.forDateRange("LAST_7_DAYS")
.get();
while (myAdGroups.hasNext()) {
var adGroup = myAdGroups.next();
var campaign = adGroup.getCampaign();
var campaignStats = campaign.getStats();
var campaignROAS = campaignStats.getReturnOnAdSpend();
}
Affinché questo funzioni, è necessario creare un selettore per la campagna.
var myAdGroups = AdsApp.adGroups().
.withCondition("CampaignName CONTAINS 'gen'")
.forDateRange("LAST_7_DAYS")
.get();
while (myAdGroups.hasNext()) {
var adGroup = myAdGroups.next();
var campaign = AdsApp.campaigns()
.withIds([adGroup.getCampaign().getId()])
.forDateRange("LAST_7_DAYS")
.get()
.next();
var campaignStats = campaign.getStats();
var campaignROAS = campaignStats.getReturnOnAdSpend();
}
Non modificare la proprietà di un'entità usata come condizione nel selettore
Gli iteratori riducono l'utilizzo della memoria caricando un solo elemento alla volta anziché l'intero set di elementi. Per questo motivo, la modifica di una proprietà usata come condizione nel selettore può causare un comportamento imprevisto.
Modo giusto
var adGroups = [];
var iterator = AdsApp.adGroups()
.withCondition('Status = ENABLED')
.get();
while (iterator.hasNext()) {
adGroups.push(iterator.next());
}
for (var adGroup of adGroups) {
adGroup.pause();
}
Modo sbagliato
var adGroups = AdsApp.adGroups()
.withCondition('Status = ENABLED')
.get();
while (adGroups.hasNext()) {
var adGroup = adGroups.next();
adGroup.pause();
}
Aggiornamenti in batch
Per migliorare le prestazioni, Script elabora le richieste di compilazione in batch. Se chiami il metodo operativo di una richiesta di compilazione, forza gli script a elaborare immediatamente le richieste di compilazione in coda, annullando eventuali miglioramenti delle prestazioni. Se stai creando più di un'entità, non eseguire i metodi operativi nello stesso ciclo che usi per creare l'entità. Ciò comporta prestazioni scadenti perché viene elaborata una sola entità alla volta. Creare invece una matrice di operazioni ed elaborarle dopo il ciclo di compilazione.
Modo giusto
// An array to hold the operations, so you
// can process them after all the entities are queued.
var operations = [];
// Create all the new entities.
for (var i = 0; i < keywords.length; i++) {
var keywordOperation = AdsApp.adGroups().get().next()
.newKeywordBuilder()
.withText(keywords[i])
.build();
operations.push(keywordOperation);
}
// Now call the operation method so the build requests
// get processed in batches.
for (var i = 0; i < operations.length; i++) {
var newKeyword = operations[i].getResult();
}
Modo sbagliato
for (var i = 0; i < keywords.length; i++) {
var keywordOperation = AdsApp.adGroups().get().next() // Get the first ad group
.newKeywordBuilder() // Add the keyword to the ad group
.withText(keywords[i])
.build();
// Don't get results in the same loop that creates
// the entity because Scripts then only processes one
// entity at a time.
var newKeyword = keywordOperation.getResult();
}
Lo stesso avviene se aggiorni un'entità e quindi ottieni la stessa proprietà che hai aggiornato. Cose da evitare:
var bidAmount = 1.2;
while (keywords.hasNext()) {
var keyword = keywords.next();
keyword.bidding().setCpc(bidAmount);
if (keyword.bidding().getCpc() != bidAmount) {
Logger.log(`Failed to update bid amount for keyword, ${keyword.getText()} (${keyword.getId()})`);
}
}
Usare la parola chiave yield quando si ottengono grandi set di entità
Il recupero di un numero elevato di entità e il loro caricamento in un unico elenco che viene elaborato in un ciclo presenta un paio di svantaggi:
A seconda delle dimensioni della richiesta, potrebbe essere necessario un numero n di richieste back-end per recuperare tutte le entità prima dell'avvio del ciclo. Se non li elabori tutti, il tempo e la potenza di calcolo utilizzati per ottenere le entità non elaborate vengono sprecati. Ad esempio, se si recuperano 10.000 parole chiave e il ciclo si interrompe dopo aver elaborato solo 2.000 parole chiave, il tempo e la potenza di calcolo utilizzati per ottenere le restanti 8.000 parole chiave vengono sprecati.
La creazione dell'elenco richiede più memoria per contenere tutte le entità contemporaneamente.
Per risolvere questi problemi, usa la parola chiave yield , che consente allo script di recuperare entità su richiesta o, in un certo senso, di recuperarle "pigramente" solo quando sono necessarie. Ciò significa che lo script non effettua più chiamate del necessario al momento e non passa grandi elenchi di oggetti.
Questo esempio include la registrazione per illustrare il flusso di controllo quando si utilizza la parola chiave yield .
function main() {
const keywords = getKeywords();
//@ts-ignore <-- suppresses iterator error
for (const keyword of keywords) {
Logger.log("in for loop\n\n");
}
}
// Note that you must use the yield keyword in a generator function - see the
// '*' at the end of the function keyword.
function* getKeywords() {
const keywords = AdsApp.keywords()
.withCondition("Status = ENABLED")
.withCondition("CombinedApprovalStatus = APPROVED")
.withLimit(10)
.get();
Logger.log(`total keywords in account: ${keywords.totalNumEntities()} \n\n`);
while (keywords.hasNext()) {
Logger.log("before next()\n\n");
yield keywords.next();
Logger.log("after next\n\n");
}
}
Modello di chiamata per evitare i limiti di entità
Esiste un limite al numero di entità che gli script possono restituire per un account. Se la richiesta restituisce più di questo limite, Scripts genera un errore con il messaggio Ci sono troppe entità. L'esempio seguente mostra il modello di chiamata da usare quando si ottiene un numero elevato di entità. Nell'esempio si tenta di recuperare tutte le parole chiave a livello di account. Se l'operazione non riesce, tenta di effettuare più chiamate per recuperare le parole chiave per campagna, perché in genere sono presenti meno entità a livello di campagna. In genere è possibile continuare questo schema fino al livello del gruppo di annunci, se necessario.
Per informazioni sull'uso della parola chiave yield , vedi Usare la parola chiave yield quando si ottengono grandi set di entità.
function* getEntities() {
const applyConditions = _ => _
.withCondition('CampaignStatus = ENABLED')
.withCondition('AdGroupStatus = ENABLED')
.withCondition('Status = ENABLED')
.withCondition("CombinedApprovalStatus = DISAPPROVED");
try {
// Get the account's keywords.
const keywords = applyConditions(AdsApp.keywords()).get();
while (keywords.hasNext()) {
yield keywords.next();
}
} catch (e) {
if (!e.message.startsWith('There are too many entities')) {
throw e;
}
// If there are too many keywords at the account level,
// get keywords by campaigns under the account.
const campaigns = AdsApp.campaigns().get();
while (campaigns.hasNext()) {
const campaign = campaigns.next();
const keywords = applyConditions(campaign.keywords()).get();
while (keywords.hasNext()) {
yield keywords.next();
}
}
}
}