let countDemo4: number;
countDemo4 = 123;

let countInterfence = 123; //let countInterfence: number

const one = 123;
const two = "abc";
const three = one + two;

function getTotal(one, two) {
    return one + two;
  }
const total = getTotal(1, 2); //正常情况
const Warningtotal = getTotal(1, "字符串"); //非正常情况

function GoodgetTotal(one: number, two: number) {
    return one + two;
  }
const Goodtotal = getTotal(1, 2); 

const XiaoJieJie = {
    name: "刘英",
    age: 18,
  };

/* 
const XiaoJieJie: {
    name: string;
    age: number;
}
 */

/**
* Demo4.ts
 * 类型注解 & 类型推断
 * @date 2021-1-1
 * @author Wibus
 * TypeScript 中的两个基本概念：类型注解和类型推断，这两个概念在我们编写 TypeScript 代码时会一直使用(重点)
 */

 // 1 type annotation 类型注解
let countDemo4: number;
countDemo4 = 123;
// 这段代码就是类型注解，意思是显示的告诉代码，我们的count变量就是一个数字类型，这就叫做类型注解

 // 2 type inferrence 类型推断
 let countInterfence = 123; //let countInterfence: number
 /**
  * 我并没有显示的告诉你变量countInference是一个数字类型，但是如果你把鼠标放到变量上时，你会发现 TypeScript 自动把变量注释为了number（数字）类型
  * 也就是说它是有某种推断能力的，通过你的代码 TS 会自动的去尝试分析变量的类型。
  * 这个就彷佛是人的情商比较高，还没等女生表白，你就已经看出她的心思🤣
  */

  /**
   * 如果 TS 能够自动分析变量类型， 我们就什么也不需要做了
   * 如果 TS 无法分析变量类型的话， 我们就需要使用类型注解
   */

// 3 不需要写注解的例子 🌰
const one = 123;
const two = "abc";
const three = one + two;

// 4 需要写的例子 🌰
function getTotal(one, two) {
    return one + two;
  }
const total = getTotal(1, 2); //正常情况
const Warningtotal = getTotal(1, "字符串"); //非正常情况
//   这种形式，就需要用到类型注释了，因为这里的one和two会显示为any类型。这时候如果你传字符串，你的逻辑就是错误的，所以你必须加一个类型注解
function GoodgetTotal(one: number, two: number) {
    return one + two;
  }
const Goodtotal = getTotal(1, 2); 
// 为什么total这个变量不需要加类型注解，因为当one和two两个变量加上注解后，TypeScript 就可以自动通过类型推断，分析出变量的类型。

// 5 推断对象中属性的类型
/* 
const XiaoJieJie: {
    name: string;
    age: number;
}
 */
const XiaoJieJie = {
    name: "刘英",
    age: 18,
  };


// 写 TypeScript 代码的一个重要宗旨就是每个变量，每个对象的属性类型都应该是固定的，如果你推断就让它推断，推断不出来的时候你要进行注释。

function LastgetTotal(one: number, two: number) {
    return one + two;
}
const LastTotal = LastgetTotal(1, 2);

function BadgetTotal(one: number, two: number) {
    return one + two + "";
  }
  
const Badtotal = BadgetTotal(1, 2); 

const total: number = getTotal(1, 2);

function BettergetTotal(one: number, two: number): number {
    return one + two;
}
const BetterTotal = BettergetTotal(1, 2);
//这段代码就比较严谨了

function sayHello() {
  console.log("hello world");
}

function sayHello(): void {
  console.log("hello world");
}

function errorFuntion(): never {
  throw new Error();
  console.log("Hello World");
}

function forNever(): never {
  while (true) {}
  console.log("Hello ");
}

function add({ one, two }) {
  return one + two;
}

const total = add({ one: 1, two: 2 });

function add({ one: number, two: number }) {
  return one + two;
}

const total = add({ one: 1, two: 2 });

function add({ one, two }: { one: number, two: number }): number {
  return one + two;
}

const three = add({ one: 1, two: 2 });

function getNumber({ one }: number) {
  return one;
}

const one = getNumber({ one: 1 });

function getNumber({ one }: { one: number }): number {
  return one;
}

const one = getNumber({ one: 1 });

/**
 * Demo5.ts
 * TypeScript 函数参数和返回类型定义
 * @date 2021-1-1
 * @author Wibus
 */


// 1 复习下demo4的getTotal
function LastgetTotal(one: number, two: number) {
    return one + two;
}
const LastTotal = LastgetTotal(1, 2);
//  代码其实有一个小坑，就是我们并没有定义getTotal的返回值类型，虽然TypeScript可以自己推断出返回值是number类型。 但是如果这时候我们的代码写错了，比如写程了下面这个样子。
function BadgetTotal(one: number, two: number) {
    return one + two + "";
  }
  
const Badtotal = BadgetTotal(1, 2); //这时候total的值就不是number类型了，但是不会报错。
// 1.1 某些人的解决办法
const SomePersontotal: number = BadgetTotal(1, 2); //这样写虽然可以让编辑器报错(不能将类型“string”分配给类型“number”。)，但是这还不是很高明的算法，因为你没有找到错误的根本

// 1.2 合适的做法是给函数的返回值加上类型注解

function BettergetTotal(one: number, two: number): number {
    return one + two;
}
const BetterTotal = BettergetTotal(1, 2);
//这段代码就比较严谨了

// 2 never 返回值类型
// 如果一个函数是永远也执行不完的，就可以定义返回值为never
function errorFuntion(): never {
    throw new Error();
    console.log("Hello World");
}
// 👆执行执行的时候，抛出了异常，这时候就无法执行完了

//void 无返回值类型
function avoid(): void {
    const a = 123
    //这个时候这个函数里面是不允许return一个值的
    return a;
}

function forNever(): never {
  while (true) {}
  console.log("Hello");
}
// ⬆️死循环，这样也运行不完

const numberArr = [1,2,3]'

const numberArr: number[] = [1, 2, 3];

const stringArr: string[] = ["a", "b", "c"];

const undefinedArr: undefined[] = [undefined, undefined];

const arr: (number | string)[] = [1, "string", 2];

const xiaoJieJiesDemo6: {name: string, age: number}[] = [
    {name: "Ming", age: 15},
    {name: "Wibus", age: 14},
];

type lady = {name: string, age: number};

const GoodxiaoJieJiesDemo6: lady[] = [
    {name: "Ming", age: 15},
    {name: "Wibus", age: 14},
];

class ladys{
    name: string;
    age: number;
};
const GoodxiaoJieJiesDemo6_2: ladys[] = [
    {name: "Ming", age: 15},
    {name: "Wibus", age: 14},   
];

/**
 * Demo6.ts
 * TypeScript 中数组类型的定义
 * @date 2021-1-2
 * @author wibus
 */

// 1 一般数组类型的定义
const numberArr = [1,2,3];
// 这是最简单的数组类型（number) 当你鼠标放上变量名时，就可以看得出来是number类型（类型推断）
const numberArr2: number[] = [1,2,3];
// 类型注解
const stringArr: string[] = ["a","b","c"];
// 所以说你可以定义任何类型的数组
const undefinedArr: undefined[] = [undefined, undefined];
// 1.1 多种数据类型
const arr: (number|string)[] = [1,2,"abc"];
// 数组简单类型定义就这样了，其实不难

// 2 数组中对象类型的定义
// 在实际项目当中肯定会有对象出现，那这个时候定义的话就麻烦一点点了

const xiaoJieJiesDemo6: {name: string, age: number}[] = [
    {name: "Ming", age: 15},
    {name: "Wibus", age: 14},
];
//这样子的形式看起来比较复杂，当然这段程序是可以的，但是不好读嘛

// 2.1 Type Alias 类型别名

type lady = {name: string, age: number};
const GoodxiaoJieJiesDemo6: lady[] = [
    {name: "Ming", age: 15},
    {name: "Wibus", age: 14},
];
//这样子就好读多了

// 2.2 使用class
// 当然，使用class来定义也是可以的，例如这样子
class ladys{
    name: string;
    age: number;
};
const GoodxiaoJieJiesDemo6_2: ladys[] = [
    {name: "Ming", age: 15},
    {name: "Wibus", age: 14},   
]
// 我们可以看到，是可以的~