node.ts

一.node.ts使用
第一个node.ts程序

const mes:string="hello world ts";
console.log(mes);

二.node.ts变量声明

let a = 25;// 全局变量
class test {
    num = 1; //实例变量
    static x = 123; //静态变量

    queryIndex(mes: string): string {
        let c: string = "5555"; // 局部变量
        return c;
    }
}

三.node.ts基本类型&变量声明

//  定义数据类型

//字符串类型  一个字符系列，使用单引号（'）或双引号（"）来表示字符串类型。反引号（`）来定义多行文本和内嵌表达式
const num: number = 5;  //数值类型
const msg: string = "666"; // 字符串类型
const words: string = `您好，今年是 ${msg} 发布 ${num + 1} 周年`;


// boolean 类型
const flag: boolean = true; //默认值为true | false


// 数组类型
const arr: number[] = [1, 2, 3, 4];  // number类型数组
const arrStr: string[] = ["1", "2", "3", "4"]; //string类型数组
const anyArrNum: Array<number> = [1, 2, 3, 4];  //定义泛型（number）数组
const anyArrStr: Array<string> = ["1", "2", "3", "4"];  //定义泛型（number）数组


// 元组类型数组
let resArr: [number, string];
resArr = [1, "666"];// 不遵循这个规则，编译无法通过
// resArr=["6666",1];


// 枚举
enum Color {
    Red, Green, Blue
}

//使用枚举
let red = Color.Red;


// 方法定义  void标识无返回值
function queryUser(): void {
    alert("hello world");
}

// 返回string
function queryUserStr(): string {
    return "hello";
}

// 返回number
function queryUserNum(): number {
    return 1;
}

// any 任意类型
// 常量
let x: any;
x = 1;
x = "666";
x = true;
// 数组
let y: any[];
y = [1, "666", false];


// null & undefined
null; //表示空，即没有值
undefined; //表示未定义类型变量


//never  never 是其它类型（包括 null 和 undefined）的子类型，代表从不会出现的值。这意味着声明为 never
// 类型的变量只能被 never 类型所赋值，在函数中它通常表现为抛出异常或无法执行到终止点（例如无限循环），示例代码如下：


function f(): void {
    let x: never;
    let y: number;

    // x=1; //数字类型不能转为never类型：编译出错
    y = 1;
    // 定义异常  never 类型可以赋值给 never类型
    x = (() => {
        throw new Error('exception')
    })();
    // never 类型可以赋值给 number类型
    y = (() => {
        throw new Error('exception')
    })();

    // 异常处理方法
    function error(message: string): never {
        throw new Error(message);
    }

    // while循环
    function arras():never{
        while (true){}
    }
}
//  never类型用于异常，never类型以及 while（true（无限））循环

四.node.ts运算符

// 运算符 +，-，*，/，取模% ，++，--

function operato(): void {
    let num: number = 6;
    let a: number = 2;

    let x = num - a; //-
    console.log(x);
    let x1 = num + a; //+
    console.log(x1);
    let x2 = num * a; //*
    console.log(x2);
    let x3 = num / a; // /
    console.log(x3);
    let x4 = num--; //--
    console.log(x4);
    let x5 = num++; //++
    console.log(x5);
}

五.node.ts条件语句

export class user {
    static x=1;
//  if判断
    queryUser(id: string): string {
        if (Number.parseInt(id) > 0 && id != null) {
            return id;
        } else {
            throw new Error("id为空");
        }
    }


    // switch break语句
    static switch(x:number):void{
        switch (x) {
            case 1:
                console.log(x);
                break;
            case 2:
                console.log(x);
                break;
            case 3:
                console.log(x);
                break;

            default:
                console.log(x);
        }
    }

}

六.node.ts循环

/**
 * for 循环
 */
export class User {

    //  普通for循环
    defaultFor(): void {
        let num: number = 5;
        let i: number;
        let factorial = 1;

        for (i = num; i >= 1; i--) {
            factorial *= i;
        }
        console.log(factorial)
    }

    // for in循环
    forIn(): void {
        let j: any;
        let n: any = "a,b,c";
        // for in用于一组值的集合或者列表输出
        for (j in n) {
            console.log(n[j]);
        }
    }

    // for of循环
    // 此外，TypeScript 还支持 for…of 、forEach、every 和 some 循环。
    //
    // for...of 语句创建一个循环来迭代可迭代的对象。在 ES6 中引入的 for...of 循环，以替代 for...in 和 forEach() ，
    // 并支持新的迭代协议。for...of 允许你遍历 Arrays（数组）, Strings（字符串）, Maps（映射）, Sets（集合）等可迭代的数据结构等
    forOf(msg: string): void {
        let someArray = [1, "string", false];
        for (let entry of someArray) {
            console.log(entry); // 1, "string", false
        }

    }

    // for...each 循环 属于js内的语法
    foreEach(): void {
        let list = [4, 5, 6];
        list.forEach((val, idx, array) => {
            console.log(val + "===" + idx + "===" + array)
            // val: 当前值
            // idx：当前index
            // array: Array
        });
    }

    // forEvery循环 ts
    forEvery(): void {
        let list = [4, 5, 6];
        list.every((val, idx, array) => {
            console.log(val + "===" + idx + "===" + array)
            // val: 当前值
            // idx：当前index
            // array: Array
        });
    }

    // while 循环
    while(): void {
        let num: number = 5;
        let fac = 1;
        while (num > 1) { //小于1的时候跳出循环
            fac = fac + 1;
            num--;
        }
        console.log("fac为：" + fac);
    }

    // do...while循环
    doWhile(num: number): void {
        do {
            console.log(num);
            num--;
        } while (num >= 0); // 小于0的时候跳出循环
    }

    // break
    break(): void {
        let i: number = 1;
        while (i <= 10) {
            if (i % 5 == 0) { //结果为0的时候跳出循环
                break;
            }
            i++;
        }
    }


    // continue
    continue(): void {
        let num = 0;
        let count = 0;
        for (num = 0; num < 20; num++) {
            if (num % 2 == 0) { //num%2 ==0 跳过继续执行
                continue;
            }
            count++;
        }
    }

    // 无限循环
    whileTrueOrFor():void{
        while (true){
            console.log('aaaa');// 一直打印
        }

        for(;;){
            console.log(";;;;")// 一直打印
        }
    }
}

七.node.ts函数

export class Method {

    // 不带返回值method
    methodVoid(msg: string): void {
        console.log(msg);
    }

    // 返回string
    stringMethod(msg: string): string {
        console.log(msg);
        return msg;
    }

    // 返回number
    numberMethod(num: number): number {
        return num + 1;
    }

    // 返回number数组
    numArrMethod(num1: number, num2: number): number[] {
        let num: number[] = [num1, num2];

        for (let number of num) {
            if (number<0){
                throw new Error("返回值不能<于0");
            }else {
                // 往数组当中添加新的元素
             num.push(number);
            }
        }
        return num;
    }

    // 返回string数组
    stringArr(mesArr: string, mes: string): string[] {
        let msg: string[] = [mesArr, mes];
        return msg;
    }

    // 返回任意类型数组
    anyMethod(mes: string, age: number): any[] {
        let anyArr: any[] = [age, mes];
        return anyArr;
    }

    // //方法重载和上一个anyMethod一样
    // anyMethod(mes: string): string {
    //     let msg: string = mes;
    //     return msg;
    // }


}

/**
 * class里面定义method 不用加function，class外需要加function
 * @param num
 */


export function f(num: number): number {
    return num;

}

// function f(num: number,num1:number): number {
//     return num+num1;
//
// }

八.node.ts Number

export class Number{
    id: number | undefined;
    name: string | undefined;
    email: string | undefined;
    queryUserAge(name:string,age:number):string{
        return name+"===="+age;
        // 1.MAX_VALUE 最大值
        // 可表示的最大的数，MAX_VALUE 属性值接近于 1.79E+308。大于 MAX_VALUE 的值代表 "Infinity"。

        // 2.MIN_VALUE
        // 可表示的最小的数，即最接近 0 的正数 (实际上不会变成 0)。

        // 3.NaN
        // 非数字值（Not-A-Number）。

        // 4.NEGATIVE_INFINITY
        // 负无穷大，溢出时返回该值。该值小于 MIN_VALUE。

        // 5.POSITIVE_INFINITY
        // 正无穷大，溢出时返回该值。该值大于 MAX_VALUE。

        // 6.prototype
        // Number 对象的静态属性。使您有能力向对象添加属性和方法。

        // 7.constructor
        // 返回对创建此对象的 Number 函数的引用。


        //8.number.toFixed返回指定数值和控制小数位数
        // toFixed()
        // 把数字转换为字符串，并对小数点指定位数。



    }
    //nan
    nan():void{
        var month = 0
        if( month<=0 || month >12) {
            // month = Number.NaN;
            console.log("月份是："+ month)
        } else {
            console.log("输入月份数值正确。")
        }
    }

    prototype(id:number,name:string){
        this.id = id
        this.name = name
    }

    test(){
        // @ts-ignore
        let emp = new Number.prototype(123,"admin")
        Number.prototype.email = "admin@runoob.com"

        console.log("员工号: "+emp.id)
        console.log("员工姓名: "+emp.name)
        console.log("员工邮箱: "+emp.email)
    }
}

九.node.ts String

let txt = new String("string");
// 或者更简单方式：
let txt1= "string";

//字符串长度
console.log(txt1.length);
//去空
console.log(txt1.trim());
// 拼接字符串
console.log(txt.concat(txt1));

//指定位置字符
console.log(txt1.charAt(0));

//查找字符串位置(角标)
console.log(txt1.indexOf("t"));

//match()
// 查找找到一个或多个正则表达式的匹配。
console.log(txt1.match(/tr/g));

//替换
let re = /(\w+)\s(\w+)/;
let stra = "zara ali";
let newstr = stra.replace(re, "$2, $1");
console.log(newstr); // ali, zara

//提取索引之间的字符
var str = "RUNOOB GOOGLE TAOBAO FACEBOOK";
console.log("(1,2): "    + str.substring(1,2));   // U
console.log("(0,10): "   + str.substring(0, 10)); // RUNOOB GOO
console.log("(5): "      + str.substring(5));     // B GOOGLE TAOBAO FACEBOOK

// 将字符串转为大写
let strs = "Runoob Google";
console.log(strs.toLocaleUpperCase( ));  // RUNOOB GOOGLE
let s1 = "Runoob Google";
console.log(s1.toUpperCase( ));  // RUNOOB GOOGLE

//将字符串转为小写
let s = "Runoob Google";
console.log(s.toLowerCase( ));  // runoob google


//返回对象原来的值
let seix = new String("Runoob");
console.log(seix.valueOf( ));  // Runoob

十.node.ts Map

export class Maps {

    queryUser(): void {
        // 创建map
        let maps = new Map();
        // 赋值
        maps.set("age", 21);
        maps.set("name", "李四");
        console.log(maps.get("age") + "===" + maps.get("name"));

        // 判断map是否包含对应值
        console.log(maps.has("name"));

        // 移除对应值
        console.log(maps.delete("name"));

        // map长度
        console.log(maps.size);

        // 遍历map
        // 迭代 Map 中的 key
        for (let key of maps.keys()) {
            console.log(key);
        }
        // 迭代map中的value
        for (let value of maps.values()) {
            console.log(value);
        }

        //迭代map中key-value
        for (let kv of maps.entries()){
            console.log(kv[0],kv[1]);
        }

        //使用对象解析
        for (let [key,value] of maps){
            console.log(key,value);
        }
    }
}

十一.node.ts 联合类型

//联合类型
let val:string|number;
val="6666";
console.log("字符串为："+val);
val=666;
console.log("数值为："+val);

//将联合类型作为参数使用
function lianheType(val:string|number){
    // 校验是否是字符串类型
    if (typeof val=="string"){
        console.log(val);
    }else{
        console.log(val);
    }
}

function lianHeArray(val:string[]|number) {
    if (typeof val=="number"){
        console.log(val);
    }else {
        for (let str of val) {
            console.log(str);
        }
    }
}
// lianheType("hello");
// lianheType(2323);
let strVal:string[]=["1","2","3"];
lianHeArray(123);
lianHeArray(strVal);

十二.node.ts 接口

// ts接口使用定义为需要实现的接口类型实现方法就可以了

interface IPerson {
    firstName: string;
    lastName: string;
    // 定义一个返回类型为string 类型method
    sayHello: () => string;

    // 定义一个返回类型为string，参数类型为string的method
    sayHellos: (msg: string) => string;
}

let customer: IPerson = {
    firstName: "java", lastName: "Mr.", sayHello(): string {
        return "hello java";
    }, sayHellos(msg: string): string {
        return msg + "msg";
    }
}

console.log(customer.sayHello);
console.log(customer.firstName);
console.log(customer.lastName);
console.log(customer.sayHellos("你好"));

// 联合类型和接口一起使用
interface IPersonPlus {
    program: string;
    com: string[] | string | (() => string);
}

let IPersonaPlus: IPersonPlus = {
    com: "hello", program: "你好"
}

let ms: string[] = ["1", "2", "3"];
let IPersonaPlus1: IPersonPlus = {
    com: ms, program: "你好"
}

console.log(IPersonaPlus.com + ",===" + IPersonaPlus.program);
console.log(IPersonaPlus1.com + ",===" + IPersonaPlus1.program);

十三.node.ts 类class

class Car {
    //字段
    engine:string;

    // 构造函数
    constructor(engine: string) {
        this.engine = engine;
    }
    disp():void{
        console.log("发动机型号为："+this.engine);
    }
}

//获取对象实例

let car=new Car("H0104");
// 访问属性
console.log(car.engine);
// 访问method
car.disp();

// 继承（子类继承父类）

class CarSub extends Car{
    area:number;

    constructor(engine: string, area: number) {
        super(engine);
        this.area = area;
    }

    disps():void{
        console.log("Parent："+this.engine+"===Sub"+this.area);
    }
}

CarSub carSub=new CarSub("1023",123);
carSub.disps();

十四.对象（objcet）

// 对象实例
var object_name = {
    key1: "value1", // 标量
    key2: "value",
    key3: function () {
        // 函数
    },
    key4: ["content1", "content2"] //集合
}

let sites = {
    site1: "123456",
    site2: "54321",
    sayHello: function () {
    } //类型魔板
};
// 往方法当中传递参数
sites.sayHello = function () {
    console.log(sites.site1);
};
//传递对象
let invokeSites = function (obj: { site1: string, site2: string }) {
    console.log("site1:" + obj.site1 + "===site2:" + obj.site2);
}

//自定义传递对象测试
let say = {
    name: "张三",
    age: 22,
    sex: [22, 33, 44],
    ageMap: {age1: 1, age2: 2, age3: 4} // 自定义集合
}
let sayTest = function (say: { name: string, age: number, sex: number[], ageMap: {} }) {
    if (say.sex.length > 0) {
        console.log("name:" + say.name + "=====age:" + say.age + "======ageMap.age1:" + say.ageMap.age1);
        for (let sex of say.sex) {
            console.log(sex);
        }
    } else {
        throw new Error("性别不能为null");
    }
}
console.log(sites.site1 + "===" + sites.site2);
sites.sayHello();
invokeSites(sites);

sayTest(say);