..s

Posted 2022-04-27 xuyan1

/** 为函数定义类型 */

// 为函数的参数指定类型，为函数的返回值指定类型
function add(x: number, y: number): number 
    return x + y;


let myAdd = function (x: number, y: number): number  return x + y; 

// 完整的函数
let myAdd2: (x: number, y: number) => number = function (x: number, y: number): number return x + y 

let myadd3: (x: number, y: number) => number = function (x: number, y: number)  return x + y 

let myadd4: (b: number, y: number) => number = function (x: number, y: number)  return x + y; 

let myadd5: (x:number, y: number) => number=function(x,y)return x+y

// 可选参数和默认参数：ts里传入一个函数的参数个数必须与函数期望的参数个数一致

function buildName(firstName: string, lastName: string) 
    return firstName + " " + lastName


let result = buildName("jsck", "bruce")
let result1 = buildName("jsck")
console.log(result1)

// 可选参数必须放在后面
function buildName2(firstName: string, lastName?: string) 
    return firstName + " " + lastName


let result2 = buildName2("jsck", "bruce")
let result3 = buildName2("jsck")
console.log(result2)
console.log(result3)

// 默认参数，当用户没有传值或者传递的值是undefined的时候生效
function buildName3(firstName: string, lastName="smith") 
    return firstName + " " + lastName


let result4= buildName3("bob", undefined)

// 剩余参数
function buildName4(firstName: string, ...restOfName: string[]) 
    return firstName + ‘,‘ + restOfName.join(",")


let employeeName = buildName4("xiaoju", "weimeng", "ruixin", "tengying")

console.log(employeeName)


/** 泛型 */
// 使用泛型来创建可重用的组件，一个组件可以支持多种类型的数据。


function identity(arg: number): number 
    return arg;
;

// 类型变量
function identity1<T>(arg: T): T 
    return arg;


let output = identity1<string>("myString")
let output2 = identity1("myString") // 类型断言，根据参数判断T的类型


function loggingIdentity<T>(arg: T[]): T[] 
    console.log(arg.length)
    return arg;


function loggingIdentity2<T>(arg: Array<T>): Arrary<T> 
    console.log(arg.length)
    return arg;



/** symbol */

let sym = Symbol();

let obj = 
    [sym]: "value"
;

console.log(obj[sym]); // "value"

// symbol表示独一无二的的，他接受一个字符串作为参数，表示对symbol的描述，如果参数是一个对象，它会调用对象的toString的方法转为string

const log = 

log.levels = 
    DEBUG: Symbol(‘debug‘),
    INFO: Symbol(‘info‘)


console.log(log.levels.DEBUG)

// 作为属性名的写法

let mySymbol = Symbol();

let a = ;
a[mySymbol] = ‘Hello!‘;

let a1 = 
    [mySymbol]: ‘Hello!‘


let a2 = 
Object.defineProperty(a, mySymbol,  value: ‘Hello!‘ );


// 属性名的遍历
// Object.getOwnPropertySymbols方法返回一个数组，成员是当前对象的所有用作属性名的Symbol值
const objSymbol = 
let aa = Symbol(‘aa‘);
let bb = Symbol(‘bb‘);

objSymbol[aa] = ‘aaa‘;
objSymbol[bb] = ‘bbb‘;

const objectSymbols = Object.getOwnPropertySymbols(objSymbol)
console.log(objectSymbols)

//重新使用同一个Symbol值，Symbol.for(),Symbol.keyFor()

//Symbol.for()与Symbol()这两种写法，都会生成新的 Symbol。它们的区别是，前者会被登记在全局环境中供搜索，后者不会。Symbol.for()不会每次调用就返回一个新的 Symbol 类型的值，而是会先检查给定的key是否已经存在，如果不存在才会新建一个值。比如，如果你调用Symbol.for("cat")30 次，每次都会返回同一个 Symbol 值，但是调用Symbol("cat")30 次，会返回 30 个不同的 Symbol 值

console.log(Symbol.keyFor(mySymbol))

/** 枚举 */

// 使用枚举我们可以定义一些带名字的常量，使用枚举可以清晰的表达意图活创建一组有区别的用例。

// 数字枚举

enum Direction 
    Up = 1,
    Down,
    Left,
    Right


enum Response 
    No = 0,
    Yes =1

function respond(recipient: string, message: Response): void 
    // ...


respond("text", Response.No)

// 字符串枚举，每一个字符串枚举里，每个成员必须用字符串字面量，或另外一个字符串枚举成员进行初始化

enum Direction2 
    Up = "UP",
    Down = "DOWN",
    Left = "LEFT",
    Right = "RIGHT"


enum E1 
    X,Y,Z


console.log(E1.X, E1.Y)

enum E2 
    A=1, B, C


console.log(E2.B)

enum FileAccess 
    // constant members
    None,
    Read    = 1 << 1,
    Write   = 1 << 2,
    ReadWrite  = Read | Write,
    // computed member
    G = "123".length


console.log(FileAccess.Read, FileAccess.Write, FileAccess.ReadWrite, FileAccess.G)

// 联合枚举与枚举成员类型