常规

// 变量篇
var comp = app.project.activeItem; // 当前激活的合成
var items = app.project.selection; // 项目面板的选择项目集合
var selLayers = app.project.activeItem.selectedLayers; // 当前合成的图层选择列表
var layerSelProps = layer.selectedProperties; // 当前图层/合成的属性选择列表。合成要用合成.selectedProperties
var propSelKeys = prop.selectedKeys; //

// 数量
arr.length; // 普通列表 arr[i]
project.numItems; // 项目面板的项目集 project.item(i)
comp.numLayers; // 合成里的图层集 comp.layer(i)
propGroup.numProperties; // 属性组里的属性集 propGroup.property(i)

// 撤销组
app.beginUndoGroup("My Undo Group 01");
app.endUndoGroup();

判断

普通判断

// 常见判断对象
xx instanceof ↓
PropertyGroup 属性组
CompItem  合成
ShapeLayer  形状图层
Folder  文件夹

p.propertyType  = PropertyType.PROPERTY  // 判断是不是一个普通属性

//判断图层类型
var theLayer = 你的图层 // 自己定义下
if (theLayer instanceof AVLayer) {
    if (theLayer.source instanceof CompItem) {
        alert("合成");
    }
    else if (theLayer.source instanceof FootageItem) {
        if (theLayer.nullLayer) {
            alert("空对象");
        }
        else if (theLayer.source.mainSource instanceof SolidSource) {
            if (theLayer.adjustmentLayer == true) {
                alert("调整图层");

            } else if (theLayer.frameBlendingType) {
                alert("纯色图层");
            } else {
                alert("空对象");
            }
        }
        else {
            alert("素材");
        }
    }
} else {
    alert("不是 AV");
}

// 或者使用构造器
layer.constructor.name === "ShapeLayer";

遍历

遍历选择的图层

var comp = app.project.activeItem;  // 活动合成
var slLayers = comp.selectedLayers;  // 选择图层集
var layerNumber = comp.selectedLayers.length;  // 选择图层个数

if(layerNumber >= 1){
    for(var i = 0,l = layerNumber; i < l; i++){
        // 对选择图层逐个操作
        slLayers[i].XXX
    }
}

遍历合成里的图层(不检测子合成）

var comp = app.project.activeItem;  // 活动合成
for (var ii = 1, ll = comp.numLayers; ii <= ll; ii++) {
    var layer = comp.layer(ii);
    // 对每个图层逐个操作
    layer.xxx
}

遍历合成里的图层(检测子合成）

function comp_recursive(comp) {   
    // 循环合成内的图层与子合成
        var previousComps = [];  //初始化储存合成
        property_recursive(你的合成)
    for (var i=1; i<=comp.numLayers; i++) {        
        var layer = comp.layer(i);

        // 检查图层是否有源 并且类型为合成
        if (layer.source && layer.source instanceof CompItem) {

            // 检查是否遍历过该合成
            check = checkPreviousComps(layer.source.id);

            if (check == null) {                
                // 存储原合成id 用于校对
                var sourceID = layer.source.id;

                // 再次遍历
                comp_recursive(layer.source)
                // 存储新合成id 用于校正
                var destID = layer.source.id;
                // 添加校正id到数组
                previousComps[sourceID] = destID;
            } else {

            }
        }
    }
    // 为了递归，返回复制后的合成
    return comp;
}

// 检查以前的复制，确保一个合成不会复制两次
function checkPreviousComps(checkID) {
        if (previousComps[checkID]) {
                return getItemWithID(previousComps[checkID]);
        }
        return null;
}

// 返回具有指定 ID 的项目
function getItemWithID(id) {
    for (x=1; x<=app.project.numItems; x++) {
        if (app.project.item(x).id == id) {
            return app.project.item(x);
        }
    }
    return null;
}

mainComp = app.project.activeItem;
if (mainComp && mainComp instanceof CompItem) {
    app.beginUndoGroup("Comp Recursive");

    previousComps = [];
    comp_recursive(mainComp);
    app.endUndoGroup();

} else if (!mainComp) {
    alert("请选择一个合成进行复制.");
} else {
    alert("ERROR: 没有选择合成.\n 请在项目面板重新选择.");
}

遍历属性/属性组

function property_recursive(propertyGroup) {
    for (var i = 1; i <= propertyGroup.numProperties; i++) {
        var property = propertyGroup.property(i);

        // 判断当前属性是否为属性组，如果是，则继续遍历
        if (property instanceof PropertyGroup) {
            property_recursive(property);
            //对每个属性组逐个操作
            property.XXX
            continue;
        } 

        // 对每个属性逐个操作
        property.XXX
    }
}

遍历项目面板的文件与文件夹

// 文件夹遍历加判断
function folder_recursive(folderGroup) {
    for (var i = 1; i <= folderGroup.numItems; i++) {
        var items = folderGroup.item(i);

        // 判断当前属性是否为文件夹，如果是，则继续遍历
        if (items instanceof FolderItem) {
            //对每个文件夹逐个操作 比如判断名称
            if (items.name == "footage") {
                XXX
            }  
            folder_recursive(items);
            continue;
        }

        // 对每个文件逐个操作
        // 
    }
}

循环本地文件夹

var FF = new Folder("你的文件夹路径");

folder_recursive(FF);
// 文件夹遍历加判断
function folder_recursive(folderGroup) {
    // 获取文件夹所有文件与文件夹
    var files = folderGroup.getFiles();

    for (var i = 0; i < files.length; i++) {
        var file = files[i];
        // 判断当前属性是否为文件夹，如果是，则继续遍历
        if (file instanceof Folder) {
            //对每个文件夹逐个操作
            folder_recursive(file);
            continue;
        }
        // 比如对每个文件进行处理 比如查看文件名
        alert(file.fsName)
    }
}

POLY FILL

使用JSON对象

// JSON对象
"object" != typeof JSON && (JSON = {}), function () { "use strict"; var rx_one = /^[\],:{}\s]*$/, rx_two = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, rx_three = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, rx_four = /(?:^|:|,)(?:\s*\[)+/g, rx_escapable = /[\\"\u0000-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, rx_dangerous = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, gap, indent, meta, rep; function f(t) { return t < 10 ? "0" + t : t } function this_value() { return this.valueOf() } function quote(t) { return rx_escapable.lastIndex = 0, rx_escapable.test(t) ? '"' + t.replace(rx_escapable, function (t) { var e = meta[t]; return "string" == typeof e ? e : "\\u" + ("0000" + t.charCodeAt(0).toString(16)).slice(-4) }) + '"' : '"' + t + '"' } function str(t, e) { var r, n, o, u, f, a = gap, i = e[t]; switch (i && "object" == typeof i && "function" == typeof i.toJSON && (i = i.toJSON(t)), "function" == typeof rep && (i = rep.call(e, t, i)), typeof i) { case "string": return quote(i); case "number": return isFinite(i) ? String(i) : "null"; case "boolean": case "null": return String(i); case "object": if (!i) return "null"; if (gap += indent, f = [], "[object Array]" === Object.prototype.toString.apply(i)) { for (u = i.length, r = 0; r < u; r += 1)f[r] = str(r, i) || "null"; return o = 0 === f.length ? "[]" : gap ? "[\n" + gap + f.join(",\n" + gap) + "\n" + a + "]" : "[" + f.join(",") + "]", gap = a, o } if (rep && "object" == typeof rep) for (u = rep.length, r = 0; r < u; r += 1)"string" == typeof rep[r] && (o = str(n = rep[r], i)) && f.push(quote(n) + (gap ? ": " : ":") + o); else for (n in i) Object.prototype.hasOwnProperty.call(i, n) && (o = str(n, i)) && f.push(quote(n) + (gap ? ": " : ":") + o); return o = 0 === f.length ? "{}" : gap ? "{\n" + gap + f.join(",\n" + gap) + "\n" + a + "}" : "{" + f.join(",") + "}", gap = a, o } } "function" != typeof Date.prototype.toJSON && (Date.prototype.toJSON = function () { return isFinite(this.valueOf()) ? this.getUTCFullYear() + "-" + f(this.getUTCMonth() + 1) + "-" + f(this.getUTCDate()) + "T" + f(this.getUTCHours()) + ":" + f(this.getUTCMinutes()) + ":" + f(this.getUTCSeconds()) + "Z" : null }, Boolean.prototype.toJSON = this_value, Number.prototype.toJSON = this_value, String.prototype.toJSON = this_value), "function" != typeof JSON.stringify && (meta = { "\b": "\\b", "\t": "\\t", "\n": "\\n", "\f": "\\f", "\r": "\\r", '"': '\\"', "\\": "\\\\" }, JSON.stringify = function (t, e, r) { var n; if (indent = gap = "", "number" == typeof r) for (n = 0; n < r; n += 1)indent += " "; else "string" == typeof r && (indent = r); if ((rep = e) && "function" != typeof e && ("object" != typeof e || "number" != typeof e.length)) throw new Error("JSON.stringify"); return str("", { "": t }) }), "function" != typeof JSON.parse && (JSON.parse = function (text, reviver) { var j; function walk(t, e) { var r, n, o = t[e]; if (o && "object" == typeof o) for (r in o) Object.prototype.hasOwnProperty.call(o, r) && (void 0 !== (n = walk(o, r)) ? o[r] = n : delete o[r]); return reviver.call(t, e, o) } if (text = String(text), rx_dangerous.lastIndex = 0, rx_dangerous.test(text) && (text = text.replace(rx_dangerous, function (t) { return "\\u" + ("0000" + t.charCodeAt(0).toString(16)).slice(-4) })), rx_one.test(text.replace(rx_two, "@").replace(rx_three, "]").replace(rx_four, ""))) return j = eval("(" + text + ")"), "function" == typeof reviver ? walk({ "": j }, "") : j; throw new SyntaxError("JSON.parse") }) }();

数组方法

//Array.filter
if (!Array.prototype.filter) { Array.prototype.filter = function(callbackfn , thisArg) { "use strict"; var O = Object(this), lenValue = O.length, len = lenValue >>> 0, T, A, k, to, Pk, kPresent, kValue, selected; if (typeof callbackfn !== "function") { throw new TypeError(); } T = thisArg ? thisArg : undefined; A = new Array(); k = 0; to = 0; while(k < len) { Pk = k.toString(); kPresent = O.hasOwnProperty(Pk); if (kPresent) { kValue = O[Pk]; selected = callbackfn.call(T, kValue, k, O); if (!!selected) { A.push(kValue); to += 1; } } k += 1; } return A; }; }

字符串方法

// trim()
if(typeof(String.prototype.trim) ==="undefined") { String.prototype.trim = function() { return String(this).replace(/^\s+|\s+$/g, ''); }; }

常用函数（外置）

判断目标是否在数组内

function isInArray(arr, value) {
    for (var i = 0; i < arr.length; i++) {
        if (value === arr[i]) {
            return true;
        }
    }
    return false;
}