精华内容
下载资源
问答
  • ts ES5 / ES3中的异步函数或方法需要’Promise’构造函数(ts An async function or method in ES5/ES3 requires the ‘Promise’ constructor) 解决方法: 在tsconfig.json中配置lib // tsconfig.json { ...

    ts ES5 / ES3中的异步函数或方法需要’Promise’构造函数(ts An async function or method in ES5/ES3 requires the ‘Promise’ constructor)

    解决方法:
    在tsconfig.json中配置lib

    // tsconfig.json
    {
      "compilerOptions": {
        "lib": [ "es2015" ]
      }
    }
    

    解决!!!

    展开全文
  • 方法装饰器不能用在声明文件( .d.ts),重载或者任何外部上下文(比如declare的类)中。 方法装饰器表达式会在运行时当作函数被调用,传入下列3个参数: 对于静态成员来说是类的构造函数,对于实例成...

    Typescript-ts 装饰器源码分析——方法装饰器

    这里写图片描述
    方法装饰器声明在一个方法的声明之前(紧靠着方法声明)。 它会被应用到方法的 属性描述符上,可以用来监视,修改或者替换方法定义。 方法装饰器不能用在声明文件( .d.ts),重载或者任何外部上下文(比如declare的类)中。

    方法装饰器表达式会在运行时当作函数被调用,传入下列3个参数:

    1. 对于静态成员来说是类的构造函数,对于实例成员是类的原型对象。
    2. 成员的名字。
    3. 成员的属性描述符

    思考一个问题,装饰器是在什么时候被传递进参数的?
    为了解决这个疑问,我分两个方面去看,第一个是单个方法装饰器的情况,第二个是多个方法装饰器的情况,其实在了解了单个装饰器的情况之后,多个装饰器的情况就迎刃而解了

    在开始之前,我们需要了解ts是如何定义类的,也就是它的面具之下的js是怎么样的

    Ts的类

    为了方便解释,先写一个简单的类,就叫它Person吧

    "use strict";
    var Person = /** @class */ (function () {
        function Person() {
        }
        Person.prototype.sayHello = function () {
            console.log("hello");
        };
        return Person;
    }());

    经过ts编译后的代码:

    "use strict";
    var Person = /** @class */ (function () {
        function Person() {
        }
        Person.prototype.sayHello = function () {
            console.log("hello");
        };
        return Person;
    }());

    很明了了吧,其实ts类的本质就是一个立即执行函数,然后在内部声明了一个Person函数,给原型添加方法,最后把它导出来

    废话不多说了,来看一下装饰器吧!

    单个装饰器

    装饰器的作用有很多,比如可以应用到方法的 属性描述符上,可以用来监视,修改或者替换方法定义,下面写一个简单的例子,改变方法的定义

    function methodDeractor(msg:string):Function{
        return function(target:any, name:string, descriptor:PropertyDescriptor){
            descriptor.value = () => console.log(msg)
        }
    }
    
    class Person{
        @methodDeractor("hello world")
        sayHello(){
            console.log("hello")
        }
    }
    
    let a = new Person();
    a.sayHello(); //hello world

    上面的例子是通过属性描述符来修改方法的定义的
    methodDeractor内部return的函数才是ts所关心的装饰器,这个装饰器接收三个参数

    • target 目标方法所属类(函数)的原型
    • name 目标方法的名字
    • descriptor 目标方法的属性描述符

    这样又回到了开始的问题,那么这些参数是在什么时候被传递的呢?我们来看一下编译过后的js代码:

    "use strict";
    var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
        return c > 3 && r && Object.defineProperty(target, key, r), r;
    };
    function methodDeractor(msg) {
        return function (target, name, descriptor) {
            descriptor.value = function () { return console.log(msg); };
        };
    }
    var Person = /** @class */ (function () {
        function Person() {
        }
        Person.prototype.sayHello = function () {
            console.log("hello");
        };
        __decorate([
            methodDeractor("hello world")
        ], Person.prototype, "sayHello", null);
        return Person;
    }());
    var a = new Person();
    a.sayHello();

    代码底部是类的定义,上面我们已经说过了,ts里的类其实就是一个普通的函数,我们的关注点是下面这些

    var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
        return c > 3 && r && Object.defineProperty(target, key, r), r;
    };

    这是装饰器的定义, 也就是代码中的__decorate的定义。我们稍稍把它变成我们容易理解的形式

    //装饰器,类的原型对象,方法名,属性描述符
    var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
        var c = arguments.length,
            //参数个数<3为目标方法,>3为属性描述符
            r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,
            //装饰器
            d;
    
        //检测新特性
        if (typeof Reflect === "object" && typeof Reflect.decorate === "function"){
            r = Reflect.decorate(decorators, target, key, desc);
    
        }
        //无新特性
        else {
            //遍历装饰器个数
            for(var i = decorators.length - 1; i >= 0; i--){
                if (d = decorators[i]){
                    // console.log(d(target, key));
                    r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
                }
            }
        }
    
        return c > 3 && r && Object.defineProperty(target, key, r), r;
    };

    从头部开始
    首先__decorate会检查是否已经存在__decorate,检查的方法是检查this上的__decorator是否存在,在浏览器端,全局的this指代window对象,在node端,this指代module.exports,module.exports的默认值是{},一个空对象,由此判断,这里的__decorate被赋值为后面那个函数。

    function (decorators, target, key, desc) {
        var c = arguments.length,
            //参数个数<3为目标方法,>3为属性描述符
            r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,
            //装饰器
            d;
    
        //检测新特性
        if (typeof Reflect === "object" && typeof Reflect.decorate === "function"){
            r = Reflect.decorate(decorators, target, key, desc);
    
        }
        //无新特性
        else {
            //遍历装饰器个数
            for(var i = decorators.length - 1; i >= 0; i--){
                if (d = decorators[i]){
                    // console.log(d(target, key));
                    r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
                }
            }
        }

    这个函数接收4个参数

    • decorators 其类型为一个数组,表示应用到目标方法的所有装饰器
    • target 其类型为一个对象,是该方法所属类的原型对象
    • key 其类型为字符串,是该方法的名称
    • desc 其类型也为一个对象,是目标方法的属性描述符

    在开头,定义了三个变量,c,r,d

    • c为参数的个数,后文通过判断参数的个数来进行传参
    • r为目标方法的属性描述符或该方法所属类的原型对象
    • d为具体的装饰器

    下面看一下c,r,d的赋值:
    c:

     var c = arguments.length //通过arguments.length直接获取到参数个数

    r:

    r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc 
    //通过划分3这个参数个数来进行分别传值,小于3就是<=2,通常只有装饰器数组和该方法所属类的原型对象被传递进来,此时的r为原型对象,大于3也就是有4个参数,r通过Object.getOwnPropertyDescriptor被赋值为该方法的属性描述符

    d:
    d没有被明确的赋初始值,在后文,会通过遍历装饰器数组对其进行赋值,现在知道d是一个具体的装饰器就行了

    再接着看下一段代码:

    //检测新特性
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function"){
        r = Reflect.decorate(decorators, target, key, desc);
    }

    这里是检测是否已经支持新特性了,该新特性是能够支持JS元数据反射的API

    如果没有该特性的话直接进入else代码块

     //遍历装饰器个数
    for(var i = decorators.length - 1; i >= 0; i--){
        if (d = decorators[i]){
            // console.log(d(target, key));
            r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
        }
    }

    这里做的事情很简单,就是遍历传进来的装饰器个数,然后把遍历出的每个装饰器赋值给d,然后通过传递进来的target,key,r参数对其进行传参执行,此时也是通过判断参数个数来进行的传参,不同个数的参数进行不同的传参。

    最后一句,返回目标方法的属性描述符,也就是r

    return c > 3 && r && Object.defineProperty(target, key, r), r;

    理解完了这段代码,我们再结合起来,综合来看一下,下面两段是:

    function methodDeractor(msg) {
        return function (target, name, descriptor) {
            descriptor.value = function () { return console.log(msg); };
        };
    }
    var Person = /** @class */ (function () {
        function Person() {
        }
        Person.prototype.sayHello = function () {
            console.log("hello");
        };
        __decorate([
            methodDeractor("hello world")
        ], Person.prototype, "sayHello", null);
        return Person;
    }());
    var a = new Person();
    a.sayHello();

    开头的methodDeractor是我一开始就声明的装饰器,这里没有做任何的变动,原样的写了下来

    下面是我声明的Person类,里面除了给Person附加sayHello方法以外,还做了一件事情,那就是执行装饰器,这里调用了上面声明的__decorate函数,传入四个参数,装饰器列表,该类的原型,目标方法的名称,还有就是目标方法的属性描述符,该属性描述符在此被传递为null,而真正的传值在__decorate内部,也就是r的值。

    现在我们回到之前讨论的问题

    装饰器是在什么时候被传递进参数的?

    答案非常明了了,__decorate调用在A类的定义中,因此,可以说,装饰器是在Person类构造的时候就已经传值了,这也就意味着,装饰器不等Person类new出实例,直接执行,恰恰可以体现装饰器的作用,比如在类的构造阶段为类添加各种元数据进行装饰或者改变目标方法的定义等等。

    多个装饰器

    上面说了一大堆都是单个装饰器,那多个装饰器呢?

    其实多个装饰器和单个装饰器并没有太大的差别,仅仅是decorators扩大了,也就是装饰器数组扩大了,在内部还是得遍历装饰器数组一个一个执行,因此,我们可以得出

    就拿文档上的一个例子来说

    function f() {
        console.log("f(): evaluated");
        return function (target, propertyKey: string, descriptor: PropertyDescriptor) {
            console.log("f(): called");
        }
    }
    
    function g() {
        console.log("g(): evaluated");
        return function (target, propertyKey: string, descriptor: PropertyDescriptor) {
            console.log("g(): called");
        }
    }
    
    class C {
        @f()
        @g()
        method() {}
    }

    看一下这个结果

    开始在C类的立即执行函数里会执行__decorate函数,f(),g()会被直接传递进去,此时的f,g已经被执行了,因此先打印的应该是:

    f(): evaluated
    g(): evaluated

    在__decorate函数中,通过遍历装饰器列表进行执行,由于遍历的时候是倒序遍历的

    for (var i = decorators.length - 1; i >= 0; i--)

    因此g装饰器会被先执行

    g(): called
    f(): called

    综上

    f(): evaluated
    g(): evaluated
    g(): called
    f(): called

    先执行f函数,然后执行g,之后通过倒序遍历执行g装饰器,然后再执行f装饰器

    总结

    至此,源码分析完了,是不是感觉还是很简单的
    装饰器会使我们的代码变得优雅,同一个装饰器可以用于不同的目标,因此提高了复用度,像nest框架,基于express上,用ts写的一套框架,如果你喜欢ts,不妨去试试

    展开全文
  • GregRos..79此答案适用于TypeScript ...您需要声明一个与要修改的构造函数/类同名的接口,并将其放在正确的声明的命名空间/模块下.这称为范围扩充.以这种方式扩展模块只能在特殊的声明.d.ts文件*中完成.//in a .d.ts ...

    GregRos..

    79

    此答案适用于TypeScript 1.8+.这类问题有很多其他答案,但它们似乎都涵盖旧版本.

    在TypeScript中扩展原型有两个部分.

    第1部分 - 声明

    声明新成员,以便它可以传递类型检查.您需要声明一个与要修改的构造函数/类同名的接口,并将其放在正确的声明的命名空间/模块下.这称为范围扩充.

    以这种方式扩展模块只能在特殊的声明.d.ts文件*中完成.

    //in a .d.ts file:

    declare global {

    interface String {

    padZero(length : number) : string;

    }

    }

    外部模块中的类型具有包含引号的名称,例如"bluebird".

    全球类型,如模块名称Array和String是global,没有任何报价.但是,在许多版本的TypeScript中,您可以完全放弃模块声明并直接声明接口,具有以下内容:

    declare interface String {

    padZero(length : number) : string;

    }

    在1.8之前的某些版本中也是这种情况,在2.0之后的某些版本中也是如此,例如最新版本2.5.

    请注意,除了文件中的declare语句之外,您不能拥有任何内容.d.ts,否则它将无效.

    这些声明被添加到包的环境范围中,因此它们将应用于所有TypeScript文件,即使您从不直接import或///

    *从技术上讲,你可以通过这个限制并将声明放在常规.ts文件中,但这会导致编译器出现一些挑剔的行为,并且不建议这样做.

    第2部分 - 实施

    第2部分实际上是实现成员并将其添加到它应该存在的对象中,就像在JavaScript中一样.

    String.prototype.padZero = function (this : string, length: number) {

    var s = this;

    while (s.length < length) {

    s = '0' + s;

    }

    return s;

    };

    请注意以下几点:

    String.prototype而不仅仅是String,它是String构造函数,而不是它的原型.

    我使用显式function而不是箭头函数,因为a function将正确地this从调用它的位置接收参数.箭头函数将始终使用this与其声明的位置相同的内容.有一次我们不希望发生这种情况是在扩展原型时.

    显式this,所以编译器知道this我们期望的类型.此部分仅适用于TS 2.0+.this如果您正在编译1.8-,请删除注释.没有注释,this可以隐式输入any.

    导入JavaScript

    在TypeScript中,declare构造将成员添加到环境范围,这意味着它们出现在所有文件中.为了确保第2部分的实现已连接,import文件就在应用程序的开头.

    您导入文件如下:

    import '/path/to/implementation/file';

    没有任何进口.您也可以从文件中导入某些内容,但不需要导入在原型上定义的函数.

    此外,如果您尝试将其放在2.5.1中的`.d.ts`文件中,则会出现以下错误:`全局范围的扩充只能直接嵌套在外部模块或环境模块声明中. (5认同)

    展开全文
  • 声明用class分三部分 属性 构造函数(给属性赋值) 方法 class Greeter { greeting: string; constructor(message: string) { this.greeting = message; } greet() { return "Hello, " + this.gre...

    类 声明用class 分三部分

    属性

    构造函数(给属性赋值)

    方法

    class Greeter {
        greeting: string;
        constructor(message: string) {
            this.greeting = message;
        }
        greet() {
            return "Hello, " + this.greeting;
        }
    }
    
    let greeter = new Greeter("world");
    
    
    
    // .....................
    class People {
        move(distance: number) {
            console.log(`People moved ${distance}m.`)
        }
    }
    class King extends People {
        bark() {
            console.log("aaa")
        }
    }
    let xiaoming = new King()
    xiaoming.bark();
    xiaoming.move(20)

    上面只是简单的书写了方法继承 属性继承则需要super 用来调用父类的构造函数

     

    class People {
        name: string;
        constructor(fname: string, age: number) {
            this.name = fname;
        }
        move(distance: number) {
            console.log(`People moved ${distance}m.`)
        }
    }
    
    //需要注意的是 继承哪些属性 constructor里面的参数就要有哪些 父类定义的初始化赋值方法如果不变则不用再写this.*****  
    //但是新增的属性赋值 虽然是新增的但是也要在super的参数中写一下(暂不明白具体原因 尝试  如果constructor的参数两个 super参数一个 会报错)
    //换句话说 constructor里面的参数应该和super里面的参数是一样的 (想要继承的 和新增的函数)
    
    class King extends People {
        age: number;
        constructor(name, tage) {
            super(name,tage)
            this.age = tage;
        }
        bark() {
            console.log("aaa")
        }
    }
    let xiaoming = new King("小明",18)
    console.log(xiaoming.name+xiaoming.age)
    

    public与private

    //在上面代码的基础上
    console.log(new King("测试一",18).name)
    //可以访问   默认为 public
    
    
    class King extends People {
        private age: number;
        constructor(name, tage) {
            super(name, tage)
            this.age = tage;
        }
        bark() {
            console.log("aaa")
        }
    }
    
    
    //将属性用private声明一下 则无论是
    console.log(new King("测试一",18).age)
    //还是
    console.log(xiaoming.age)
    //都将会报错  拒绝外部访问

    类的存储器

    class Employee {
        fullName: string;
    }
    
    let employee = new Employee();
    employee.fullName = "Bob Smith";
    if (employee.fullName) {
        console.log(employee.fullName);
    }

    在以前不用 getter  setters的时候 我们可以随意的修改fullName 很方便  但是这里我们想加一个检查(过滤或者说判断) 比如

    先检查用户密码是否正确,然后再允许其修改员工信息。

    let password = "start password"
    class Employee {
        private _fullName: string;
        get fullName(): string {
            return this._fullName+"访问";
        }
    
        set fullName(newName: string ){
            if (password && password == "start password") {
                this._fullName = newName
                console.log(this._fullName+"456")
            }
            else {
                console.log("Error")
            }
        }
    }
    
    let employee=new Employee();
    employee.fullName="Bob";
    if(employee.fullName){
        console.log(employee.fullName)
    }
    
    
    //需要注意的是 当我们访问fullName这个属性的时候 get这个函数就会被触发(或者说执行)
    //         当我们对fullNname这个属性进行设置的时候  set 这个函数就会被触发(执行)
    //当变量password 发生改变的时候  set判断不成立 则 Erroe

    书写完整函数类型

    有两种写法

    let add = function (a: number, b: number): string {
        return a + b + "0"
    }
    console.log(add(1, 1));
    
    
    //另一种感觉像是箭头函数
    
    let decrease: (a: string, b: string) => string =
        function (a: string, b: string): string {
            return a +b
        }
    console.log(decrease("20", "1111"))
    
    
    //需要注意的是在TS 中 减法运算左右侧必须是数字类型的变量
    
    
    function add(name:string,age:number):any{
        console.log("123")
    }
    add("的",12)
    //这样也是可以的  只不过add 不是声明的变量

    可选参数

    传递给一个函数的参数个数必须与函数期望的参数个数一致。(可以用默认参数或者可选参数减少传入的值  但是绝对不可以比期待传入的参数还多了

    function buildName(firstName: string, lastName: string) {
        return firstName + " " + lastName;
    }
    
    let result1 = buildName("Bob");                  // error, too few parameters
    let result2 = buildName("Bob", "Adams", "Sr.");  // error, too many parameters
    let result3 = buildName("Bob", "Adams");         // ah, just right

    这时候如果我们改成可选参数  传递的参数可有可无 则加上? 即可 需要注意的是 必须参数必须在前面  可选参数必须在后面

    如果 想让fistName 是可选参数  就需要 改变他们两个的顺序

    function buildName(firstName: string, lastName?: string) {
        if (lastName)
            return firstName + " " + lastName;
        else
            return firstName;
    }
    
    let result1 = buildName("Bob");  // works correctly now
    let result2 = buildName("Bob", "Adams", "Sr.");  // error, too many parameters
    let result3 = buildName("Bob", "Adams");  // ah, just right

    默认参数  

    与ES6类似 在传参那里 用= 赋予默认值

    function abc(a:string,b="默认"):any{
        console.log(a+b)
    }
    abc("bbbb")
    
    //此时 就不需要一定要传两个参数了  
    //需要注意的是 此时函数没有返回值  函数类型需要注意

    泛型

    可以使传入的类型与返回的类型一致

    一个接口函数类 传入的类型不一定的时候使用泛型 不确定是哪种类型

    function abc <T>(a:T):T{
        return a
    }
    console.log(abc("你好啊"))

    我们给identity添加了类型变量T。 T帮助我们捕获用户传入的类型(比如:number),之后我们就可以使用这个类型。 之后我们再次使用了 T当做返回值类型。现在我们可以知道参数类型与返回值类型是相同的了。 这允许我们跟踪函数里使用的类型的信息。  这个函数abc 就叫做泛型。

    需要注意的是类型T 有可能是任何的类型变量  比如有的有.length属性 有的没有 所以就不能使用

    但是 像数组 就明确有.length属性的  可以这样写

    function loaa<T>(arg: T[]): T[] {
        console.log(arg.length);  // Array has a .length, so no more error
        return arg;
    }

    枚举

    需要注意的是  基于数字的枚举与基于字符串的枚举 使用的时候不太一样 看例子

    enum Direction {
        Up,
        Down,
        Left,
        Right,
    }
    //默认是数字
    console.log(Direction[0])     //up
    console.log(Direvtion.Up)    //0
    enum Direction {
        Up = "a",
        Down = "DOWN",
        Left = "LEFT",
        Right = "RIGHT",
    }
    console.log(Direction["Up"])  //a
    
    

    声明文件 如 jq

     npm install @types/jquery --save-dev 

    乍一用 好像没什么用  将编译出来的js  引入html 还是会报错的啊 

     实际上这条命令的作用是使ts识别jq命令  $

    但是需要注意的是  即使编译成了js  因为没有引入JQ 所以 html文件还是无法识别 $ 所以 需要在html文件中引入JQ 即可

     

     

    声明文件

    我个人理解 就是声明了 很多的全局变量 类之类的  在.d.ts中  用全局声明以后  在.ts中直接就可以使用不用引入

    //animal.d.ts
    
    declare class Animal{
        name:string;
        constructor(name:string);
        say():string;
    }
    
    // index.ts
    
    let cat =new Animal("小猫")
    // 同时会验证cat 是否符合 Animal的结构 (需要一个参数)

     

    展开全文
  • 装饰器:装饰器是一种特殊类型的声明,它能够被附加到类声明方法,属性或参数上,可以修改类的行为。 通俗的讲装饰器就是一一个方法, 可以注入到类、方法、属性参数上来扩展类、属性、方法、参数的功能。 常见的...
  • TS之装饰器

    2020-06-21 17:07:40
    装饰器是一种特殊类型的声明,它能够被附加到类声明方法,属性或参数上,可以修改类的行为。 通俗的讲,装饰器就是一个方法,可以注入到类、方法、属性、参数上来扩展类、方法、属性、参数的功能。 常见的装饰器有...
  • 一文掌握ts中的装饰器类装饰器无参写法传参写法(装饰器工厂)类装饰器重载构造函数属性装饰器方法装饰器使用方法装饰器修改方法方法)参数装饰器 类装饰器 类装饰器:在类声明之前被声明,紧靠着类声明。应用于...
  • ts-学习类型-class

    2021-01-29 14:58:55
    声明constructor的简化方法 class Person { // 简化写法 constructor(public name:string){} } 子类继承父类时,需要先调用父类的构造函数super(),若父类的构造函数中有需要传递的参数,则必须传递参数 class...
  • 这个类有3个成员:一个叫做greeting的属性,一个构造函数和一个greet方法。 我们在引用任何一个类成员的时候都用了this。 它表示我们访问的是类的成员。 我们使用new构造了Greeter类的一个实例。 它会调用之前定义...
  • 1.在ts文件引入Router(不是...2.在构造器里声明(ts文件里): constructor(private router:Router){}/*声明路由*/ 3.自定义定义一个方法: goDetail () { // 这里的router是构造器里声明的router,跳转通过navigate(...
  • 在 app.module.ts 中引入 HttpClientModule ...在用到的地方引入 HttpClient 并在构造函数声明 import {HttpClient} from "@angular/common/http"; constructor(public http:HttpClient) { } get 请求数据 var api =
  • Angular 响应式表单 FormArray 与 FormGroup 相互嵌套 在类文件中(组件的TS文件): ...在构造方法中: private fb: FormBuild; 声明一个FormBuild的对象 在构造方法中: constructor(pri...
  • 声明类的属性和方法时可以加 访问控制符,作用是:类的属性和方法是否可以在类的外部访问到。 默认public,还可以取值private,protected。 对应prototype 2、类的构造函数 构造函数是类的特殊方法,只有在类被...
  • 2.使用 constructor 关键字声明构造函数;3.使用 private 关键字声明私有成员(或属性);4.可以使用 get/set 来实现私有成员访问器;5.支持 static 静态字段或方法;实例代码如下,首先声明一个Person 类://...
  • typescript学习笔记

    2019-01-11 15:46:30
    1,ts是js的超集,ts是强类型语言。ts比js入门更难。ts的面向对象写法比js更优雅。ts更适合团队协作。 2,声明变量篇。...子类不写construct默认继承父类的实例和方法,子类super在构造函数中写。 4....
  • 2.在用到的地方【common.service.ts】引入HttpClient、HttpHeaders(非必须),并在构造函数声明HttpClient 3.开始封装post方法 把ajaxGet()方法复制一份,修改: (1)函数名ajaxGet(url) 改成 ajaxPost...
  • HttpClientModule 模块 get 方法 在 app.module.ts 中引入 HttpClientModule 模块并注入 import { HttpClientModule }... imports: [ HttpClientModule, ], ...在用到的地方引入 HttpClient 并在构造函数声明 impor...
  • Typescript注解

    千次阅读 2019-06-21 11:21:21
    注解(装饰器)是一类特殊类型的声明,可以用在类、方法构造器、属性和参数上。 * 2.其实本质上,定义一个注解,就是定义一个TypeScript方法,只是该方法必须符合官方的规范。 * 3.方法分别返回符合规范的函数闭包...
  • (1)如1.3 所写,测滑菜单写在app.html,所以测滑菜单中的各个按钮的实现就在app.component.ts中写了,如果像其他普通界面一样在app.component.ts中引入NavController并在构造函数constructor中声明public navCtrl:...
  • 1.在需要传参数的组件的类文件(ts文件)中,构造方法中,声明对象: constructor(private route: Router) { } 2.在路由中设置参数(有三种方式) routerLink属性 a.对于单一参数 &lt;a [routerLink]=&...
  • 【register-step3.page.ts】 1.引入StorageService并声明 2.在构造函数里读取存储的电话号码和验证码,并赋给变量 二、密码和确认密码双向数据绑定 三、点击完成按钮,执行doRegister()方法,完成...
  • 该接口声明一个get()方法,该方法接受一个ContextRequest标识所请求的值(例如ContextKey实例),以及一个非强制性选项。 以下代码返回与key关联的字符串值,如果找不到该值,则抛出异常。 import { ...
  • 在需要传分博累发口小定逻间框加题览果些屏洁动理应参数的组件的类文件(ts文件)中,构造方法中,声明对圈件浏用是刚。它学编套互学工久不都维逻直数构过曾结里总经网屏广明果名象:constructor(private route: ...
  • ionic2 获取dom节点

    2019-01-07 22:52:00
    ionic2页面上面获取dom节点,可以直接用原生的方法,document.querySelector()等, 但是不建议这样使用,建议使用官方的。...然后在构造器里面声明使用@viewchild('name') name 就可以了,一般使用都是this.n...
  • 在Angular中使用依赖注入,可以帮助我们实现松耦合,可以说只有在组件中使用依赖注入才能真正的实现可重用的组件。...Angular中的注入器只有一种实现方法就是在构造函数中声明。 例如在一个组件中 con
  • 新手学习C++入门资料

    2008-12-28 23:58:50
    有时候,根据表达式的需要,某个数据需要被当成另外的数据类型来处理,这时,就需要强制编译器把变量或常数由声明时的类型转换成需要的类型。为此,就要使用强制类型转换说明,格式如下: int* iptr=(int*) &...
  • 方法实现了信号和槽函数的关联,第一个按钮我们直接在设计器中实现其关 联;第二个按钮我们自己写了槽函数语句,其实图形的设计与直接写代码效果是 一样的。 这个程序里我们实现了两类窗口打开的方式,一个是自身...

空空如也

空空如也

1 2
收藏数 30
精华内容 12
关键字:

ts声明构造方法