TypeScript 基础类型--仅供参考 更多内容大家可以参考TypeScript的官方教程https://www.typescriptlang.org/docs

//布尔值--TypeScript中可以使用boolean来表示这个变量是布尔值，可以赋值为true或者false

let sj: boolean = false

//数字--TypeScript里的所有数字都是浮点数，这些浮点数的类型是 number 除了支持十进制，还支持二进制、八进制、十六进制

let number1: number = 2023
let number2: number = 0b11111100111
let number3: number = 0o3747
let number4: number = 0x7e7

//字符串--TypeScript里使用 string表示文本数据类型， 可以使用双引号（""）或单引号（''）表示字符串

let name: string = "sj"
name = "sj1"
name = 'sj2'

//数组--TypeScript有两种方式可以定义数组 第一种，可以在元素类型后面接上 []，表示由此类型元素组成的一个数组

let list: number[] = [1, 2, 3]

//第二种方式是使用数组泛型，Array<元素类型>

let list1: Array<number> = [1, 2, 3];

//元组--TypeScript中元组类型允许表示一个已知元素数量和类型的数组，各元素的类型不必相同 比如，你可以定义一对值分别为 string和number类型的元组

let s: [string, number];
s = ['hello', 10]; // OK
s = [10, 'hello']; // Error

//枚举--TypeScript中不清楚类型的变量指定一个类型 可以使用unknown类型来标记

let a: unknown = 4;
a = 'instead';
a = false;


//Void--TypeScript中当一个函数没有返回值时，我们通常会见到其返回值类型是 void

function as(): void {
    console.log('This is function is void');
}

//Null 和 Undefined --TypeScript中undefined和null两者各自有自己的类型分别叫做undefined和null

let u: undefined = undefined;
let n: null = null;

//联合类型 --TypeScript中联合类型（Union Types）表示取值可以为多种类型中的一种

let qa: string | number; // 可以使字符串 也可以是 数字
qa = 'seven';
qa = 7;

//条件语句 if 语句--TypeScript if 语句由一个布尔表达式后跟一个或多个语句组成

var num:number = 59
if (num > 0) { 
   console.log('数字是正数') 
}

//if...else 语句 -- 一个 if 语句后可跟一个可选的 else 语句，else 语句在布尔表达式为 false 时执行

var num:number = 20; 
if (num % 2==0) { 
    console.log('偶数'); 
} else {
    console.log('奇数'); 
}

//if...else if....else 语句在执行多个判断条件的时候很有用

var num:number = 9
if(num > 0) { 
    console.log(num+' 是正数') 
} else if(num < 0) { 
    console.log(num+' 是负数') 
} else { 
    console.log(num+' 为0') 
}

// switch…case  一个 switch 语句允许测试一个变量等于多个值时的情况。每个值称为一个 case，且被测试的变量会对每个 switch case 进行检查

var grade:string = 'd'; 
switch(grade) { 
    case 'A': { 
        console.log('优'); 
        break; 
    } 
    case 'B': { 
        console.log('良'); 
        break; 
    } 
    case 'C': {
        console.log('及格'); 
        break;    
    } 
    case 'D': { 
        console.log('不及格'); 
        break; 
    }  
    default: { 
        console.log('非法输入'); 
        break;              
    } 
}

//函数--函数是一组一起执行一个任务的语句，函数声明要告诉编译器函数的名称、返回类型和参数TypeScript可以创建有名字的函数和匿名函数

// 有名函数
function ad(x, y) {
    return x + y;
  }
  
  // 匿名函数
  let myAd = function (x, y) {
    return x + y;
};

// 为函数定义类型 为了确保输入输出的准确性


// 有名函数：给变量设置为number类型
function ase(x: string, y: string): string {
    return x + y;
  }
  
  // 匿名函数：给变量设置为number类型
  let myase = function (x: string, y: string): string {
    return x + y;
};

// 可选参数--在TypeScript里我们可以在参数名旁使用 ?实现可选参数的功能

//注意可选参数必须在所有参数末尾
function bName(firstName: string, lastName?: string) {
    if (lastName)
        return firstName + ' ' + lastName;
    else
        return firstName;
}

let result1 = bName('a');
let result2 = bName('a', 'c'); 

//剩余参数--剩余参数会被当做个数不限的可选参数。 可以一个都没有，同样也可以有任意个。 可以使用省略号（ ...）进行定义：

function getEmployeeName(firstName: string, ...restOfName: string[]) {
    return firstName + ' ' + restOfName.join(' ');
  }
  
  let employeeName = getEmployeeName('a', 'b', 'c', 'd');

//箭头函数--ES6版本的TypeScript提供了一个箭头函数，它是定义匿名函数的简写语法，用于函数表达式，它省略了function关键字。箭头函数的定义如下，其函数是一个语句块：

let test = (num: number) => {
    if (num > 0) {
      console.log(num + ' 是正数');
    } else if (num < 0) {
      console.log(num + ' 是负数');
    } else {
      console.log(num + ' 为0');
    }
}

test(0) 

//类--TypeScript支持基于类的面向对象的编程方式，定义类的关键字为 class，后面紧跟类名。类描述了所创建的对象共同的属性和方法

class OP {
    private name: string
    private age: number
  
    constructor(name: string, age: number) {
      this.name = name;
      this.age = age;
    }
  
    public getPersonInfo(): string {
      return `My name is ${this.name} and age is ${this.age}`;
    }
}

let person1 = new OP('sj', 18);
person1.getPersonInfo();

//继承--继承就是子类继承父类的特征和行为，使得子类具有父类相同的行为。TypeScript中允许使用继承来扩展现有的类，对应的关键字为extends

class Employee extends OP {
    private department: string
  
    constructor(name: string, age: number, department: string) {
      super(name, age);
      this.department = department;
    }
  
    public getEmployeeInfo(): string {
      return this.getPersonInfo() + ` and work in ${this.department}`;
    }
}

let person2 = new Employee('zz', 26, 'HuaWei');
person2.getPersonInfo();
person2.getEmployeeInfo();

// 模块--两个模块之间的关系是通过在文件级别上使用 import 和 export 建立的。模块里面的变量、函数和类等在模块外部是不可见的，
//除非明确地使用 export 导出它们。类似地，我们必须通过 import 导入其他模块导出的变量、函数、类等


//导出--任何声明（比如变量，函数，类，类型别名或接口）都能够通过添加export关键字来导出，例如我们要把NewsData这个类导出，代码示意如下
export class NewsData {
    title: string;
    content: string;
    imagesUrl: Array<NewsFile>;
    source: string;
  
    constructor(title: string, content: string, imagesUrl: Array<NewsFile>, source: string) {
      this.title = title;
      this.content = content;
      this.imagesUrl = imagesUrl;
      this.source = source;
    }
  }


// 导入
import { NewsData } from '../common/bean/NewsData';

// 迭代器--在 TypeScript 中，Symbol.iterator 是一个内置的符号（Symbol），用于定义对象的迭代器方法。它被用于实现可迭代协议（Iterable Protocol），使对象可以被 for...of 循环迭代

//for..of 语句会遍历可迭代的对象，调用对象上的Symbol.iterator方法

let sArray = [1, "string", false];

for (let entry of sArray) {
    console.log(entry); // 1, "string", false
}

// or..of和for..in均可迭代一个列表，但是用于迭代的值却不同：for..in迭代的是对象的键，而for..of则迭代的是对象的值

let list4 = [4, 5, 6];

for (let i in list4) {
    console.log(i); // "0", "1", "2",
}

for (let i of list4) {
    console.log(i); // "4", "5", "6"
}