npm i  -g  typescript
#或者
yarn  global add  typescript

// 數(shù)值類型
let age: number = 18
// 字符串類型
let myName: string = '小花'
// 布爾類型
let isLoading: boolean = false
// undefined
let un: undefined = undefined
// null
let timer:null = null
// symbol
let uniKey:symbol = Symbol()

let 變量: 類型1 | 類型2 | 類型3 .... = 初始值
let arr1 :number | string = 1 // 可以寫兩個類型

// | 聯(lián)合類型  變量可以是兩種類型之一
let timer:number|null = null
timer = setTimeout()

type 別名 = 類型
type s = string // 定義
const str1:s = 'abc'
const str2:string = 'abc'

 type NewType = string | number
 let a: NewType = 1
 let b: NewType = '1'

// 寫法1：
let 變量: 類型[] = [值1，...]:
let numbers: number[] = [1, 3, 5] 
//  numbers必須是數(shù)組，每個元素都必須是數(shù)字
// 寫法2：
let 變量: Array<類型> = [值1，...]
let strings: Array<string> = ['a', 'b', 'c'] 
//  strings必須是數(shù)組，每個元素都必須是字符串

// 普通函數(shù)
function 函數(shù)名(形參1： 類型=默認值， 形參2：類型=默認值,...): 返回值類型 { }
// 聲明式實際寫法:
function add(num1: number, num2: number): number {
  return num1 + num2
}
// 箭頭函數(shù)
const 函數(shù)名（形參1： 類型=默認值， 形參2：類型=默認值, ...):返回值類型 => { }
const add2 = (a: number =100, b: number = 100): number =>{
   return a + b
 }
 // 注意： 箭頭函數(shù)的返回值類型要寫在參數(shù)小括號的后面
add（1,'1') // 報錯

const add2 = (a: number =100, b: number = 100): number => {
    return a + b
  }
function add1 (a:number = 100 , b: number = 200): number {
    return a + b
  }
// 這里的 add1 和 add2 的參數(shù)類型和返回值一致，
// 那么就可以統(tǒng)一定義一個函數(shù)類型
type Fn = (n1:number,n2:number) => number 
const add3 : Fn = (a,b)=>{return a+b }
// 這樣書寫起來就簡單多啦

function greet(name: string): void {  console.log('Hello', name)  //}

// 如果什么都不寫，此時，add 函數(shù)的返回值類型為： void
const add = () => {}
// 如果return之后什么都不寫，此時，add 函數(shù)的返回值類型為： void
const add = () => { return }
const add = (): void => {
  // 此處，返回的 undefined 是 JS 中的一個值
  return undefined
}
// 這種寫法是明確指定函數(shù)返回值類型為 void，與上面不指定返回值類型相同
const add = (): void => {}

function add(a:number, b:number): undefined { // 這里會報錯
  console.log(a,b)
}

//可選參數(shù)：在可選參數(shù)名的后面添加 ?（問號）
function slice (a?: number, b?: number) {
    // ? 跟在參數(shù)名字的后面，表示可選的參數(shù)
    // 注意：可選參數(shù)只能在 必須參數(shù)的后面
    // 如果可選參數(shù)在必選參數(shù)的前面，會報錯
    console.log(111);
  }
  slice()
  slice(1)
  slice(1,2)
}

const 對象名: {
  屬性名1：類型1，
  屬性名2?：類型2，
  方法名1(形參1: 類型1，形參2: 類型2)： 返回值類型,
  方法名2:(形參1: 類型1，形參2: 類型2) => 返回值類型
} = { 屬性名1: 值1，屬性名2：值2  }

// 創(chuàng)建類型別名
type Person = {
  name: string，
  age: number
  sayHi(): void
}
// 使用類型別名作為對象的類型：
let person: Person = {
  name: '小花',
  age: 18
  sayHi() {}
}

interface 接口名  {屬性1: 類型1, 屬性2: 類型2}
// 這里用 interface 關鍵字來聲明接口
interface IGoodItem  {
	// 接口名稱(比如，此處的 IPerson)，可以是任意合法的變量名稱，推薦以 `I` 開頭
   name: string, price: number, func: ()=>string
}
// 聲明接口后，直接使用接口名稱作為變量的類型
const good1: IGoodItem = {
   name: '手表',
   price: 200,
   func: function() {
       return '看時間'
   }
}
const good2: IGoodItem = {
    name: '手機',
    price: 2000,
    func: function() {
        return '打電話'
    }
}

// 接口的寫法-------------
interface IPerson {
	name: string,
	age: number
}
const user1：IPerson = {
	name: 'a',
	age: 20
}
// type的寫法-------------
type Person  = {
	name: string,
	age: number
}
const user2：Person = {
	name: 'b',
	age: 20
}

interface 接口2 extends 接口1 {
 屬性1： 類型1， // 接口2中特有的類型 
 }
interface a { x: number; y: number }
// 繼承 a
// 使用 extends(繼承)關鍵字實現(xiàn)了接口
interface b extends a {
  z: number
}
// 繼承后，b 就有了 a 的所有屬性和方法(此時，b 同時有 x、y、z 三個屬性)

function useState(n: number): [number, (number)=>void] {
        const setN = (n1) => {
            n = n1
        }
        return [n, setN]
    }
const [num ,setNum] = useState(10)

let str1 = 'hello TS'
const str2 = 'hello TS'

type Gender = 'girl' | 'boy'
// 聲明一個類型，他的值 是 'girl' 或者是 'boy'
let g1: Gender = 'girl' // 正確
let g2: Gender = 'boy' // 正確
let g3: Gender = 'man' // 錯誤

enum 枚舉名 { 可取值1, 可取值2,.. }
// 使用格式：
枚舉名.可取值

enum Direction { Up = 10, Down, Left, Right }
// Down -> 11、Left -> 12、Right -> 13
enum Direction { Up = 2, Down = 3, Left = 8, Right = 16 }

enum Direction {
  Up = 'UP',
  Down = 'DOWN',
  Left = 'LEFT',
  Right = 'RIGHT'
}

let obj: any = { x: 0 }
obj.bar = 100
obj()
// obj 可以是任意類型
const n: number = obj