太阳rpg编辑器.webp

TypeScript 的函数

基本函数定义

// 普通函数
function createHero(player: player, x: number, y: number): unit {
 return CreateUnit(player, HERO_ID, x, y, 0);
}

// 带有多个参数的函数
function dealDamage(source: unit, target: unit, amount: number): void {
 let finalDamage = amount;
 if (IsUnitType(target, UNIT_TYPE_HERO)) {
     finalDamage *= 0.8; // 英雄受到的伤害降低
 }
 UnitDamageTarget(source, target, finalDamage, true);
}

构造函数

class Hero {
 unit: unit;
 level: number;
 items: item[];

 // 构造函数
 constructor(player: player, heroId: number, x: number, y: number) {
     // 创建英雄单位
     this.unit = CreateUnit(player, heroId, x, y, 0);
     this.level = 1;
     this.items = [];

     // 初始化英雄属性
     this.initializeHero();
 }

 private initializeHero(): void {
     // 设置初始属性
     SetHeroLevel(this.unit, 1, false);
     SetUnitState(this.unit, UNIT_STATE_MANA, 100);
 }
}

// 使用构造函数创建英雄
let myHero = new Hero(Player(0), PALADIN_ID, 0, 0);

箭头函数

// 基础箭头函数
let calculateDamage = (base: number, multiplier: number): number => {
 return base * multiplier;
};

// 简写形式（单行返回）
let getUnitHealth = (unit: unit): number => GetUnitState(unit, UNIT_STATE_LIFE);

// 在事件回调中使用箭头函数
let trigger = CreateTrigger();
TriggerAddAction(trigger, () => {
 let unit = GetTriggerUnit();
 let damage = calculateDamage(100, 1.5);
 dealDamage(unit, GetTriggerUnit(), damage);
});

函数作为参数

class BuffSystem {
 // 函数类型定义
 type BuffEffect = (unit: unit) => void;

 // 使用函数作为参数
 applyBuff(target: unit, duration: number, effect: BuffEffect): void {
     // 立即应用效果
     effect(target);
     
     // 设置定时器移除效果
     TimerStart(CreateTimer(), duration, false, () => {
         effect(target);
         DestroyTimer(GetExpiredTimer());
     });
 }
}

// 使用示例
let buffSystem = new BuffSystem();
buffSystem.applyBuff(hero, 10, (unit) => {
 // 增加移动速度
 SetUnitMoveSpeed(unit, GetUnitMoveSpeed(unit) * 1.5);
});

方法函数（类中的函数）

class ItemSystem {
 private items: Map<number, item>;

 constructor() {
     this.items = new Map();
 }

 // 实例方法
 addItem(itemId: number, x: number, y: number): item {
     let newItem = CreateItem(itemId, x, y);
     this.items.set(GetHandleId(newItem), newItem);
     return newItem;
 }

 // 静态方法
 static isValidItem(item: item): boolean {
     return item != null && GetHandleId(item) > 0;
 }

 // 私有方法
 private cleanupItem(item: item): void {
     this.items.delete(GetHandleId(item));
     RemoveItem(item);
 }
}

异步函数

class SpellSystem {
 // 异步施法函数
 async castDelayedSpell(caster: unit, target: unit, delay: number): Promise<void> {
     // 开始施法动作
     SetUnitAnimation(caster, "spell");
     
     // 等待延迟
     await new Promise(resolve => {
         TimerStart(CreateTimer(), delay, false, () => {
             resolve();
             DestroyTimer(GetExpiredTimer());
         });
     });

     // 施放法术效果
     this.applySpellEffect(target);
 }
}

函数重载

class DamageSystem {
 // 函数重载声明
 dealDamage(source: unit, target: unit, amount: number): void;
 dealDamage(source: unit, target: unit, amount: number, damageType: number): void;

 // 函数实现
 dealDamage(source: unit, target: unit, amount: number, damageType?: number): void {
     if (damageType === undefined) {
         // 默认物理伤害
         UnitDamageTarget(source, target, amount, true);
     } else {
         // 特定类型伤害
         BlzSetUnitDamage(source, amount, damageType);
         UnitDamageTarget(source, target, amount, true);
     }
 }
}

闭包函数

class BuffManager {
 createBuff(baseEffect: number) {
     // 返回一个新函数，它记住了baseEffect的值
     return (unit: unit) => {
         let currentLevel = GetHeroLevel(unit);
         let totalEffect = baseEffect * (1 + currentLevel * 0.1);
         return totalEffect;
     };
 }

 // 使用闭包
 let strengthBuff = this.createBuff(50);
 let actualBonus = strengthBuff(hero); // 根据英雄等级计算实际加成
}

实际应用示例

class SpellSystem {
 constructor() {
     // 在构造函数中初始化
     this.initializeSpells();
 }

 private initializeSpells(): void {
     // 使用箭头函数注册技能效果
     this.registerSpell("火球术", (caster, target) => {
         let damage = 100 + GetHeroInt(caster, true) * 2;
         this.dealSpellDamage(caster, target, damage);
     });

     this.registerSpell("治疗术", (caster, target) => {
         let healing = 150 + GetHeroInt(caster, true) * 1.5;
         this.healUnit(target, healing);
     });
 }

 // 异步施法函数
 async castSpell(spellName: string, caster: unit, target: unit): Promise<void> {
     let spellEffect = this.spellEffects.get(spellName);
     if (!spellEffect) return;

     // 检查施法条件
     if (!this.canCastSpell(caster)) return;

     try {
         await this.startCasting(caster);
         spellEffect(caster, target);
     } catch (error) {
         print("施法失败：" + error);
     }
 }
}

关键点总结：

构造函数用于初始化类实例
箭头函数提供更简洁的语法和词法作用域的this
函数可以作为参数传递
异步函数处理需要等待的操作
函数重载提供多种调用方式
闭包可以记住其词法作用域

延伸阅读：构造函数

构造函数是一个特殊的函数，用于创建和初始化对象。它在创建对象时自动调用，通常用于设置对象的初始状态或属性。下面是一些通俗易懂的解释和示例：

1. 什么是构造函数？

定义：构造函数是一个类中的方法，用于初始化新创建的对象。
自动调用：当你使用 new 关键字创建一个对象时，构造函数会被自动调用。

2. 构造函数的作用

初始化属性：构造函数可以设置对象的初始属性值。
执行启动逻辑：可以在对象创建时执行一些必要的逻辑，比如分配资源或设置状态。

3. 构造函数的基本语法

在 TypeScript 中，构造函数的定义通常在类中，使用 constructor 关键字。

class ClassName {
    constructor(parameters) {
        // 初始化代码
    }
}

4. 示例

假设我们要创建一个表示“英雄”的类，构造函数可以用来初始化英雄的名称、等级和生命值。

class Hero {
    name: string;   // 英雄名称
    level: number;  // 英雄等级
    health: number; // 英雄生命值

    // 构造函数
    constructor(name: string, level: number, health: number) {
        this.name = name;       // 设置名称
        this.level = level;     // 设置等级
        this.health = health;   // 设置生命值
    }
}

// 使用构造函数创建一个新的英雄对象
let myHero = new Hero("战士", 1, 100);

// 访问英雄的属性
console.log(myHero.name);   // 输出: 战士
console.log(myHero.level);  // 输出: 1
console.log(myHero.health); // 输出: 100

5. 关键点

this 关键字：在构造函数中，this 代表当前正在创建的对象。通过 this 可以访问和设置对象的属性。
参数：构造函数可以接受参数，以便在创建对象时传入初始值。
自动调用：构造函数在使用 new 关键字创建对象时自动调用，无需手动调用。

6. 总结

构造函数是创建对象时的“启动器”，它帮助我们设置对象的初始状态。通过构造函数，我们可以确保每个对象在创建时都有合理的初始值和状态。

延伸阅读：箭头函数

箭头函数是 JavaScript 和 TypeScript 中的一种简化函数定义的语法。它们提供了一种更简洁的方式来编写函数，同时还具有一些独特的特性。下面是对箭头函数的通俗易懂的介绍：

1. 什么是箭头函数？

定义：箭头函数是一种使用 => 符号定义的函数。它可以用来替代传统的函数表达式。

语法：箭头函数的基本语法如下：

(参数1, 参数2, ...) => {
    // 函数体
}

2. 箭头函数的特点

简洁性：箭头函数的语法比传统函数更简洁，尤其是在处理简单的逻辑时。
没有自己的 this：箭头函数不会创建自己的 this，它会从外部上下文中继承 this 的值。这在处理回调函数时非常有用。

3. 示例

传统函数 vs 箭头函数

传统函数定义：

function add(a, b) {
    return a + b;
}

箭头函数定义：

const add = (a, b) => {
    return a + b;
};

简化的箭头函数

如果函数体只有一行代码，可以省略大括号和 return 关键字：

const add = (a, b) => a + b; // 省略了大括号和 return

4. 使用场景

1. 数组操作

箭头函数常用于数组的 map、filter 和 reduce 等方法中：

const numbers = [1, 2, 3, 4, 5];

// 使用箭头函数进行平方计算
const squares = numbers.map(num => num * num);
console.log(squares); // 输出: [1, 4, 9, 16, 25]

2. 事件处理

在事件处理函数中，箭头函数可以避免 this 的问题：

class Counter {
    count = 0;

    increment = () => {
        this.count++; // 这里的 this 指向 Counter 实例
        console.log(this.count);
    }
}

const counter = new Counter();
const button = document.createElement('button');
button.innerText = '增加';
button.addEventListener('click', counter.increment); // 使用箭头函数
document.body.appendChild(button);

5. 总结

简洁性：箭头函数提供了一种更简洁的函数定义方式，特别适合用于简单的逻辑。
this 绑定：箭头函数不会创建自己的 this，而是从外部上下文中继承，这在处理回调时非常有用。
适用场景：常用于数组操作、事件处理等场景。

#太阳编辑器