typescript 简洁使用
*做最简洁核心的记录,可以节约时间、再是提炼概括,理解归纳、便于日后查阅联想*
> typescript原则之一: 对值所具有的结构进行类型检查
#### 基础类型
* boolean
    `let isDone: boolean = false;`
    
* number
    `let hexLiteral: umber = 7`
    
* string
    
    `let name: string = 'bob'`
    
* anrray
    `let list: number[] = [1,2,3,4]`
    `let list: Array<number> = [1,2,3,4]`
    
* Tuple 元组
    > 允许定义一个已知元素数量和类型的数组,各元素类型不必相同
    
        let x: [string, number];
        x = ['hello', 10]; ok
        x = [10, 'hello']; error
        x[0].substr(1); ok
        x[0].substr(1); error 'number' does not have 'substr'
    
* enum 枚举
    > 可以为一组数值富裕有好的名字,还可以由枚举的值查找相应的值
    
        enum Color {
            Red = 1,
            Green = 'green',
            Blue = 'blue'
        }
        let c: Color = Color.Green;
        let colorName: string = Color[2];
    
* Any
    
    > 对于不清楚的类型,不希望类型检查器对这些值进行检查而是直接编译
    
        let notSure: any = 4;
        notSure = 'maybe a string instead'
        notSure = false; ok
        
        let list = any[] = [1, true, 'free']
        list[1] = 100
        
* Void
    > 表示没有任何返回值
    
        function warnUser(): void {
            alert('...')
        }
        
类型断言
> 可以通过类型断言的方式,告诉编译器,我确定这是什么,不需要进行检查了。
    1.尖括号<>
        let someValue: any = 'this is a string';
        let stringLen: number = (<string>someValue).length;
    
    2. as
        let stringLen: number = (someValue as string).length;
    
接口 interface
> 为类型命名和代码定义契约
    interface LabelValue {
        label: string;
        color? string;
        [propName: string]: any;
    }
    
    function printLabel(labelObj: LabelValue) {
        console.log(labelObj.label);
    }
    
    let myObj = {size: 10, label: 'size 10 object'};
    printLabel(myObj);
    
> 要求printLabel传入的参数对象,必须有一个类型为string的label属性,color可传可不传,和另外不确定的属性,也可以定义函数类型
    
    interface SearchFun {
        someFun(source: string, subString: string): boolean;
        reset(): void;
    }
    
> 可索引的类型
    interface ReadonlyStringArray {
        readonly [index: number]: string;
    }
    let myArray: readonlyStringArray = ['Allice', 'bob'];
    myArray[2] = 'Mallory'; error
        
    class Greeter {
        static standardGreeting = 'Hello, there';
        greeting: string;
        greet() {
            if (this.greeting) {
                return 'hello, ' + this.greeting;
            } else {
                return Greeter,standardGreeting;
            }
        }
    }
    
    let greeter1: Greeter;
    greeter1 = new Greeter();
    
    let freeterMarker: typeof Greeter = Greeter;
     //typeof Greeter: 表示取Greeter的类型,而不是实力的类型(包含了类的所有静态成员和构造函数)
    greeterMarker.standardGreeting = 'hey there!';
    let greeter2: Greeter = new greeterMaker();
    
函数
> 为函数定义类型
    let myAdd = function(x: number, y:number): number {return x + y};
    
> 可选参数、默认参数、剩余参数
    function(firstName: string, lastName = "smith", age?: number, ...restOfName: string[]){}
    
泛型
> 使用泛型来创建可重用组件,一个组件可以支持多种类型的数据
> 需要一种方法使返回值的类型与传入参数的类型是相同的,这里使用*类型变量*,表示的是类型而不是值。
    function identity<T>(arg: T): T {
        console.log(arg.length) // error:T dont have .length (泛型约束)
        return arg;
    }
    // 给函数添加了类型变量T,(帮助捕获用户传入的类型,如string),再次使用T当做返回值类型,那可以知道参数类型和返回值类型是相同的了
    // 使用1:明确制定了T是string类型
    let output = identity<string>('myString');
    // 使用2:类型推论(编译器会根据参数自动确定T的类型)
    let output = identity('myString')
    
> 使用泛型变量
    function loggingIdentity<T>(arg: T[]): T[] {
        console.log(arg.length);
        return arg;
    }
枚举 enum
> 用于定义一些带名字的常量,可以清晰的表达意图或创建一组有区别的用例
* 数字枚举
        enum Direction {
            Up = 1,
            Down,
            Left,
            Right
        }
        // 初始化Up为1,其余开始自增长;也可以不指定值,则从0开始记值
        function respond(recipient: string, message: Direction): void {}
        respond('princess Caroline', Direction.left)
        
* 字符串枚举
        enum Direction {
        Up = "UP",
        Down = "DOWN",
        Left = "LEFT",
        Right = "RIGHT",
        }
        
* 常量枚举
> 为了避免在额外生成的代码上的开销和额外的非直接的对枚举成员的访问,我们可以使用 const枚举。 常量枚举通过在枚举上使用 const修饰符来定义。
        const enum Directions {
          Up,
          Down,
          Left,
          Right
        }
        let directions = [Directions.Up, Directions.Down, Directions.Left,      Directions.Right]
        var directions = [0 /* Up */, 1 /* Down */, 2 /* Left */, 3 /* Right */];
* 交叉类型
> 是将多个类型合并为一个类型,把现有的多种类型叠加到一起成为一种类型,包含所有类型的特性
> 如 Person & Serializable & Loggable
    function extend<T, U>(first: T, second: U): T & U {
    let result = <T & U>{};
    for (let id in first) {
    (<any>result)[id] = (<any>first)[id];
    }
    for (let id in second) {
    if (!result.hasOwnProperty(id)) {
    (<any>result)[id] = (<any>second)[id];
}
}
    return result;
    }
* 联合类型
> 表示一个值可以是几种类型之一,使用(|)分割,
    function padLeft(value: string, padding: string | number) {
// ...
    }
    
* 类型保护和类型断言
> 由于可以为null的类型是通过联合类型实现,那么你需要使用类型保护来去除 null。 幸运地是这与在JavaScript里写的代码一致:
    function f(sn: string | null): string {
    if (sn == null) {
    return "default";
    }else {
    return sn;
    }
    }
    // ||
    function f(sn: string | null): string {
    return sn || "default";
    }
    
    // 类型断言手动去除: 添加 ! 后缀
    function fixed(name: string | null): string {
     return name!.charAt(0) + '. the ' + epithet;
     }
    
* 类型别名 type
> 类型别名有时和接口很像,但是可以作用于原始值,联合类型,元组以及其它任何你需要手写的类型。
    type Name = string;
    type NameResolver = () => string;
    
* 索引类型
> 通过使用 索引类型查询 和 索引访问操作符
    function pluck<T, K extends keyof T>(o: T, names: K[]): T[K][] {
        return names.map(n => o[n]);
    }
    
    interface Person {
        name: string;
        age: number;
    }
    let strings: string[] = pluck(person, ['name])
    
    
> keyof T: 索引类型查询操作符(对于任何类型T,keyof T的结果为T上已知的公共属性名的联合)
    let personProps: keyof Person; // 'name' | 'age'
    
> 第二个操作符是 T[K], 索引访问操作符。
    function getProperty<T, K extends keyof T>(o: T, name: K): T[K] {
        return o[name];
    }
    
> 索引类型和字符串索引签名
    interface Map<T> {
        [key: string]: T;
    }
    let keys: keyof Map<number>; // string;
    let value: Map<number>['foo]; // number;
    
    type Keys = 'option1' | 'option2';
    type Flags = { [K in Keys]: boolean };
    

ts简单点的更多相关文章

  1. Problem B: 农夫果园 简单点,出题的方式简单点

    我走过最长的路,就是教主的套路#include <iostream> #include <string> using namespace std; class Fruit { ...

  2. 什么是Socket?简单点,通俗易懂的?

    网络上的两个程序通过一个双向的通信连接实现数据的交换,这个连接的一端称为一个socket. 建立网络通信连接至少要一对端口号(socket).socket本质是编程接口(API),对TCP/IP的封装 ...

  3. java数据结构简单点

    java常用的数据结构一 集合框架主要就是Collection和Map: 1.Collection包含了List和Set两大分支. (1)List是一个有序的集合,每一个元素都有它的索引.第一个元素的 ...

  4. vector 有点麻烦啊 能简单点么?

    #include <iostream> #include <cstdlib> #include <cstring> #include <cstdio> ...

  5. 别让HR再质问我:我费劲招的人,你用缓存问废了,不能简单点?

    概念 缓存穿透 在高并发下,查询一个不存在的值时,缓存不会被命中,导致大量请求直接落到数据库上,如活动系统里面查询一个不存在的活动. 缓存击穿 在高并发下,对一个特定的值进行查询,但是这个时候缓存正好 ...

  6. React v16-alpha 从virtual dom 到 dom 源码简读

    一.物料准备 1.克隆react源码, github 地址:https://github.com/facebook/react.git 2.安装gulp 3.在react源码根目录下: $npm in ...

  7. Android : SELinux 简析&修改

    一 SELinux背景知识 SELinux出现之前,Linux上的安全模型叫DAC,全称是Discretionary Access Control,翻译为自主访问控制.DAC的核心思想很简单,就是: ...

  8. 【Ts 5】Httpclient的应用和封装

    一.基本概述 1.1,什么是Httpclient HttpClient 是 Apache Jakarta Common 下的子项目,可以用来提供高效的.最新的.功能丰富的支持 HTTP 协议的客户端编 ...

  9. python极简教程07:封装、多态和继承

    测试奇谭,BUG不见. 这一场主讲python的面向对象部分--封装.多态和继承. 目的:掌握Python面向对象的三个核心概念. 封装 01 什么是封装? 封装的目的是,保护隐私.通俗的讲:不想让别 ...

随机推荐

  1. Catalan数的通项公式(母函数推导)

    首先 \[h_n=\sum_{i}h_ih_{n-i-1}\] 写出 \(h\) 的母函数 \(H(x)\) 那么 \[H(x)=H^2(x)x+1,H(x)=\frac{1-\sqrt{1-4x}} ...

  2. 04.CSS动画示例-->烟花

    <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...

  3. MD5计算器

    private void radioBtnFlie_CheckedChanged(object sender, EventArgs e) { RadioButton rb = sender as Ra ...

  4. CentOS6.5(1)----设置静态IP并禁用IPV6

    使用vim命令编辑 /etc/sysconfig/network-scripts/ifcfg-eth0 文件 vim /etc/sysconfig/network-scripts/ifcfg-eth0 ...

  5. jQuery实现动态选中select

    // jquery实现动态选中select var active = $('.all_sla_title1 .active') var group_name = active.html(); var ...

  6. Oracle PL/SQL Dev工具(破解版)被植入勒索病毒的安全预警及自查通告

    [问题描述] 近日,有项目组遇到了勒索软件攻击:勒索代码隐藏在Oracle PL/SQL Dev软件中(网上下载的破解版),里面的一个文件afterconnet.sql被黑客注入了病毒代码.这个代码会 ...

  7. yum 安装LAMP

    一.安装 MySQL 首先来进行 MySQL 的安装.打开超级终端,输入: [root@localhost ~]# yum install mysql mysql-server 安装完毕,让 MySQ ...

  8. CC150相关问题

    18.9 动态计算中位数 利用两个堆:一个最大堆,存放小于中位数的值:一个最小堆,存放大于中位数的值. 则两个堆的堆顶即为数组中最中间的两个数. 在插入新元素的时候,我们只要维护两个堆, 使其堆中元素 ...

  9. sort 、sorted、range、join方法 数字的正序、倒叙、翻转

    大家可以想象一下 如果一串数字 是混乱的没有顺序这个时候你想要排序怎么办呢?  这个时候顺势而生的就有了sort方法 把数字从大到小的排列----->sort() 只对列表 li = [3, 5 ...

  10. [tools]excel转lua的python实现

    time:2015/04/13 描述:需要将excel表格内容转成lua,并且作为工具使用,能够批量转换 步骤: (1)文章[1]已经做了大部分的内容,而且也已经能够使用了 (2)根据自己新的需求: ...