TypeScript学习记录

最新推荐文章于 2024-05-17 18:09:22 发布
最新推荐文章于 2024-05-17 18:09:22 发布
阅读量143 收藏 1
点赞数 3
文章标签： typescript 学习 javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_60646136/article/details/126440873
版权

安装TypeScript

TypeScript安装方式

npm install -g typescript

第一个TypeScript程序

一、手动编译typescript

tsc 文件名

二、自动编译typescript

1). 生成配置文件 tsconfig.json
tsc --init
2). 修改tsconfig.json配置
"outdir": "./js"
"strict": "false"
3). 启动监听服务
终端 --> 运行任务 --> 监视tsconfig.json

三、类型注解

类型注解：一种轻量级的为函数或变量添加约束

  function showAge(num:number){
    return '我今年'+num
  }

四、接口

接口是对象的状态和行为的抽象

  (()=>{
    // 定义一个接口
    interface IPerson{
      firstName:string  
      lastName:string
    }
    function showFullName(person:IPerson){
      return person.firstName+person.lastName
    }
    let person ={
      firstName:'上官',
      lastName:'婉儿'
    }
    console.log(showFullName(person)); 
  })()

五、类

// ts中书写js中的类，演示效果
(function(){
  //定义一个接口
  interface IPerson{
    firstName:string
    lastName:string
  }

  // 定义一个类型
  class Person{
    firstName:string
    lastName:string
    fullName:string
    constructor(firstName:string,lastName:string){
      this.firstName=firstName
      this.lastName=lastName
      this.fullName = this.firstName+'-'+this.lastName
    }
  }
  // 定义一个函数
  function showFullName(person:IPerson){
    return person.firstName+'_'+person.lastName
  }
  // 实例化一个对象
  const person =new Person('诸葛','孔明')
  console.log(showFullName(person));
  
})()

TypeScript常用语法

一、基础类型

1.布尔值

最基本的数据类型，类型为boolean，结果只有true和false

  let flag:boolean = false

2.数字型

TypeScript中的数字和JavaScript中的数字都是浮点数，类型为number，支持二进制、八进制、十进制、十六进制

  let binaryLiteral: number = 0b1010; // 二进制
  let octalLiteral: number = 0o744;   // 八进制
  let decLiteral: number = 8;         //十进制
  let hexLiteral: number = 0xf00d;    //十六进制

3.字符串型

类型为string，用 ’ ’ 或者 " " 表示

  let str1:string='碧玉妆成一树高'
  let str2:string='万条垂下绿丝绦'
  let str3:string='不知细叶谁裁出'
  let str4:string='二月春风似剪刀'
  console.log(`${str1},${str2},${str3},${str4}`);

字符串和数字拼接

// 字符串和数字拼接
  let num:number = 2020
  console.log(str5 + num);

ts中变量一开始定义什么类型就以后修改时只能改为这种类型

4.undefined和null

  let udf:undefined = undefined
  let nul:null = null

undefined和null都可以作为其他类型的子类型，前提是必须关闭tsconfig.json的严格模式

  let num1:number = null
  let num2:number = undefined

5.数组

①定义数组方式1：
语法格式：let 变量名:数据类型 = [value1,value2,value3]

  let arr1:number[] = [1,2,3,4,5,6]

②定义数组方式二：泛型写法
语法格式：let 变量名:Array<数据类型> = [value1,value2,value3]

  let arr2:Array<number> = [7,8,9,10,11]

注：数组类型定义后，里面的数据类型必须和定义时保持一致，否则就会报错，编译也不会通过。

6.元祖

数组定义时，它的类型合格书就已经限定了。
语法格式：let 变量名:[number,string,boolean] = [value1,value2,value3]

  let arr3:[number,string,boolean] = [2.12,'张三',false]

注：数据的类型和个数要和定义时保持一致。

7.枚举

它是对js基本数据类型的补充，枚举中的每个值称为元素，每个元素有自己的编号，编号默认从0开始递增
语法格式：

enum 变量名{ 元素1,元素2,元素3}

示例：

 enum Fruits{
    pear,
    apple,
    orange
  }
  console.log(Fruits[2]);  // orange
  console.log(Fruits.pear);  // 1

当然我们也可以手动去设置编号

 enum Fruits{
    pear = 1,
    apple,
    orange
  }
  console.log(Fruits.pear)  // 1
  console.log(Fruits.orange)  // 3

8.any

当一个数组中存储多个数据，但是数据的类型和个数都不确定，我们可以使用any类型来定义数组
语法格式：let 数组名：any[ ] = [value1,value2,value3]

  let arr:any[] = [99,'青春不常在，抓紧谈恋爱',true]

9.void

在函数声明时，小括号后面使用：void，代表的该函数没有任何返回值
语法格式：

function 函数名()：void{
			console.log('')
}

示例：

  function showInfo():void{
    console.log('你好啊，玛卡巴卡');
  }

10.object

定义一个函数，参数和返回值必须是object类型（必须要有返回值）
语法格式：

function 函数名(变量名:object):object{
	console.log(obj)	
	return{对象}						
}

示例：

function showObj(obj:object):object{
    console.log(obj);
    return{
      name:'张三',
      age:18
    }
}

11.联合类型

表示取值可以为多种类型中的一种
语法格式：

function 函数名(变量名:数据类型1|数据类型2){
    return 变量名.方法()
   }

示例：

function getStr(str:number|string){
    return str.toString()
   }

12.类型断言

告诉编译器，我知道我自己在干什么，也知道自己是什么数据类型
语法格式：
①：<类型>变量名
②：值 as 类型
示例：

function getStr1(str1:string|number){
    if((<string>str1).length){
      return (<string>str1).length
    }else{
      return str1.toString().length
    }
}

function getStr1(str1:string|number){
    if((str1 as string).length){
      return (str1 as string).length
    }else{
      return str1.toString().length
    }
   }

（13）类型推断
当没有明确指定类型时推测出一个类型

let number = 100  // number

二、接口

1.接口是对象的状态和行为的抽象

接口类型的对象：多了或者少了不允许 只读属性readonly 可选属性：？
语法格式：

定义接口
  interface 接口名{
	变量名1:变量数据类型   
	变量名2:变量数据类型
	...
  }
使用接口
  const student:IStudent={
	变量名1:变量值1
	变量名2:变量值2
	...
  }

示例

定义接口
 interface IStudent{
    id:number
    readonly name:string  // 代表此属性为只读，不能修改
    hobby?:string         // 代表此属性是可选属性
    age:number
  }
使用接口  
 const student:IStudent = {
    id:1,
    name:'张三',
    hobby:'打篮球',
    age:18
  }

2.函数类型

给参数列表的每一项规定一个名字和类型
语法格式：

定义接口
 interface 接口名{
	（变量名1:变量类型，变量名2:变量类型）:返回值的类型
 }
声明函数
 const 函数名:接口名 = function 变量名1:变量类型，变量名2:变量类型）:返回值的类型{
	return 表达式
 }

示例：

定义接口
 interface IFindFunc{
    (source:string,subString:string):boolean
  }
函数中使用
  const search:IFindFunc=function(source:string,subString:string):boolean{
    return source.search(subString) > -1   // 查找source中是否存在subString元素，返回布尔值
  }

3.类类型

定义一个类，可以实现（implements）接口定义的属性和方法

  // 定义一个接口
  interface 接口名{
    属性或方法
  }
  // 定义一个类
  class 类名implements 接口名{
    属性或方法
  }
  // 实例化一个对象

示例：

  //定义一个接口
  interface ISing{
    sing()
  }
  interface IDance{
    dance()
  }
  // 定义一个类
  class Person1 implements ISing{
    sing() {
      console.log('我唱歌贼好听');
    }
  }
  // 实例化一个对象
  const person1 = new Person1()
  person1.sing()

当然，一个类可是实现多个接口

  // 定义接口
  interface ISing{
    sing()
  }
  interface IDance{
    dance()
  }
  // 一个类可以实现多个接口
  class Person2 implements ISing,IDance{
    sing() {
      console.log('我唱歌很好听');
    }
    dance(){
      console.log('我跳舞也好看');
      
    }
  }

一个接口也可以继承多个接口

interface ISingAndIDance extends ISing,IDance{}
  class Person3 implements ISingAndIDance{
    sing() {
      console.log('我唱歌真的很好听');
    }
    dance(){
      console.log('我跳舞也真的很好看');
      
    }
  }

注意：接口与接口之间叫继承（extends），接口与类之间叫实现（implements）

三、类

1.基本示例

类：可以理解为是个模板，通过模板可以实例化对象

 // 定义一个类
  class Student{
    name:string
    age:number
    grade:string

    // 定义构造函数：为了将来实例化对象时直接对属性的值初始化
    constructor(name = '张三',age = 15,grade = '八'){
      this.name = name
      this.age = age
      this.grade = grade
    }
    // 定义实例方法:
    sayHello(str:string){
      console.log(`我叫${this.name},今年${this.age}岁,我已经${this.grade}年级了`,str);
    }
  }
    // 实例化一个对象
  const stu = new Student()
  stu.sayHello('你今年几年级了啊')

2.继承

继承是类与类之间的关系
继承后类与类之间的叫法：
A类继承了B类，此时A类叫子类，B类叫基类
子类---->派生类
基类---->超类(父类)
示例：

  class Person{
    // 定义属性
    name:string
    age:number
    sex:string
    // 定义构造函数
    constructor(name,age,sex){
      this.name = name 
      this.age = age
      this.sex = sex
    }
    // 定义一个方法
    sayHello(str:string){
      console.log(`你好啊${this.name},${str}`);
    }
  }
    // 定义一个类，继承Person
    class Student extends Person{
      constructor(name,age,sex){
       super(name,age,sex) 
      }
      // 可以调用父类中的方法
      sayHello(){
        console.log('我是父类的方法');
        super.sayHello('哈哈')
      }
    }
    // 实例化person
    const person =new Person('张三',18,'男')
    person.sayHello('呵呵')
    
    // 实例化student
    const stu = new Student('李四',18,'女')
    stu.sayHello()

多态

父类型的引用指向了子类型的对象，不同类型的对象针对相同方法产生不同行为

  // 创建父类
  class Language{
    name:string
    constructor(name:string){
      this.name = name
    }
    read(source:number = 0){
      console.log(`我每天学习${source}个${this.name}词`);
    }
  }
  class English extends Language{
    name:string
    constructor(name:string){
      super(name)
    }
    read(source:number = 5){
      console.log(`我每天学习${source}个${this.name}词`);
    }
  }
  
  // 实例化父类
  const lan:Language = new Language('语言')
  lan.read()
  // 实例化子类
  const eng:English = new English('英语')
  eng.read()
  
  // 父类类型创建子类的对象
  const eng1:Language = new English('英语')
  eng1.read()
  
  // 该函数需要的参数是Language类型的
  function showLanguage(lan1:Language){
    lan1.read()
  }
  showLanguage(eng1)

类中的成员修饰符

TypeScript 可以使用三种访问修饰符（Access Modifiers），分别是 public、private 和 protected。主要是可以描述类成员的可访问性。

（1）public

public修饰的属性和方法是公有的，可以在任何地方被访问到。

class Person{
    // 设置公有访问  public
    public name:string
    public constructor(name:string){
      this.name = name 
    }
    public sayName(){
      console.log('你好啊'+this.name);
      
    }
  }
  const per = new Person('丽丽')
  console.log(per.name);   // 丽丽
  per.sayName() // 你好啊丽丽
（2）private

修饰的属性或方法是私有的，不能在声明它的类的外部访问,当然子类也无法访问

  class Person{
    // 设置私有访问  private
    private name:string
    public constructor(name:string){
      this.name = name 
    }
    public sayName(){
      console.log('你好啊'+this.name);
      
    }
  }
  class Student extends Person{
    constructor(name:string){
      super(name)
    }
  }
  // 实例化父类
  const per = new Person('丽丽')
  console.log(per.name);  // ts(16,19) TS2341: Property 'name' is private and only accessible within class 'Person'.
  per.sayName()
   
  // 实例化子类  子类也无法访问
  const stu = new Student('嘻嘻')
  console.log(stu.name);  // .ts(24,19)TS2341: Property 'name' is private and only accessible within class 'Person'
（3）protected

修饰的属性和方法受保护，与private相似，区别在于子类可以访问

 class Person{
    // 设置受保护的  protected 
    protected name:string
    public constructor(name:string){
      this.name = name 
    }
    sayName(){
      console.log('你好啊'+this.name);
    }
  }
  class Student extends Person{
    constructor(name:string){
      super(name)
    }
    sayHello() {
      console.log('我可以被访问',this.name);
      
    }
  }
  // 实例化父类
  const per = new Person('丽丽')
  console.log(per.name);  // ts(16,19) TS2341: Property 'name' is private and only accessible within class 'Person'.
  per.sayName() // 你好啊，丽丽
  // 实例化子类
  const stu = new Student('嘻嘻')
  stu.sayHello() // 我可以被访问 嘻嘻

readonly修饰符

readonly修饰符，对类中的属性成员进行修饰，修饰后该属性成员无法在外部修改。

  class Person{
    // 定义属性
    readonly name:string
    // 构造函数
    constructor(name:string){
      this.name = name
    }
    sayHello(){
      console.log('你好啊'+this.name);
    }
  }
  // 实例化对象
  const person:Person = new Person('阿辉')
  person.name = '小刘'  // Cannot assign to 'name' because it is a read-only property

类中的方法也无法修改属性成员。
在这里插入图片描述
注意：如果 readonly 和其他访问修饰符同时存在的话，需要写在其后面。

 class Person{
    // 构造函数
    constructor(public radonly name:string){
      this.name = name
    }
    sayHello(){
      console.log('你好啊'+this.name);
    }
  }

存取器

可以让我们有效控制对 对象成员中的访问，通过get 和 set 进行操作

  class Person{
    firstName:string
    lastName:string
    constructor(firstName:string,lastName:string){
      this.firstName = firstName
      this.lastName = lastName
    }
    // 读取器
    get fullName(){
      console.log('get中...');
      return this.firstName + "_" + this.lastName
    }
    // 设置器
    set fullName(val){
      console.log('set中...');
      
      let names = val.split('_')
      this.firstName = names[0]
      this.lastName = names[1]
    }
    
  }
  // 实例化对象
  const person:Person = new Person('上官','婉儿')
  console.log(person);
  console.log(person.fullName);
  // 设置该属性的数据
  person.fullName = '阿里_爸爸'
  console.log(person.fullName);

静态成员

在类中通过static修饰的属性和方法，就叫做静态成员，构造函数不能通过static来修饰
语法格式：类名.静态属性/方法

  class Person{
    static name1:string = '张三' 
    static sayName(){
      console.log('你好啊');
    }
  }
  // 通过类名.静态属性方式访问成员数据
  console.log(Person.name1);
  // 通过类名.静态属性方式来设置成员数据
  Person.name1 = '李四'
  console.log(Person.name1);
  // 通过类名.静态方法方式来设置成员数据
  Person.sayName()

抽象类

包含抽象方法，也可以包含实例方法，抽象类不能被实例化，为了让子类进行实例化及实现内部抽象方法

  abstract class Animal{
    abstract eat()
    // 会报错，抽象方法不能有具体实现
  // console.log('吃');
    // 实例方法
    sayHi(){
      console.log('你好啊');
    }
  }
  // 定义一个子类
  class Dog extends Animal{
    eat(){
      console.log('真好吃');
      
    }
  }
  // 实例化Dog对象
  const dog:Dog = new Dog()
  dog.eat()
  dog.sayHi()

  // 无法实例化抽象类的对象
  // const ani:Animal = new Animal()

四、函数

函数基本语法

语法格式：let 函数名(参数1：数据类型，参数2：数据类型) => 返回值类型 = function(参数1：数据类型，参数2：数据类型):返回值类型{ 函数表达式 }

  // 函数声明，命名函数
  function add(x:number,y:number):number{
    return x + y
  }
  const result = add(4,3)
  console.log(result);
  // 函数表达式，匿名函数
  const reduce = function(x:number,y:number):number{
    return x - y
  }
  const result2 = reduce(4,3)
  console.log(result2);
  // 函数完整写法
  const reduce1:(x:number,y:number) => number = function (x:number,y:number):number{
    return x / y
  }
  const result3 = reduce1(4,3)
  console.log(result3);

可选参数、默认参数和剩余参数

可选参数、默认参数

  // firstName:string='李'  默认参数
  // lastName?:string       可选参数
  const getFullName = function(firstName:string='李',lastName?:string):string{
    if(lastName){
      return firstName + '_' + lastName
    }else{
      return firstName
    }
  }
  console.log(getFullName());

剩余参数
语法格式：…args: 数据类型 [ ]

  function add(a:number,...args: number[]){
    console.log(a);
    console.log(args);
  }
  add(1,5,6,2,4)

函数重载

函数名字相同，函数的参数及个数不同，如果传入非法数据，会提示错误信息

  function add (x: string,y: string): string
  function add (x: number,y: number): number
  function add(x: string| number,y:string | number): string | number{
    if(typeof x === 'string' && typeof y === 'string'){
      return x + y  // 字符串拼接
    }else if(typeof x === 'number' && typeof y === 'number'){
      return x + y  // 数字相加
    }
  }
  console.log(add('上官','婉儿'));
  console.log(add(10,20));

五、泛型

泛型基本用法

在定义接口、类和函数不能确定是什么类型，而是在使用函数、接口、类的时候菜鸟确定数据的类型
语法格式：

  function 函数名<T>(变量名:T，变量名:数据T):T[]{
  }
  调用时
  函数名<数据类型>()

示例：

  function getArr<T>(value:T,count:number):T[]{
    const arr = []
    for(let i = 0;i < count; i++){
      arr.push(value)
    }
    return arr
  }
  const arr1 = getArr<number>(3.1415926,5)
  const arr2 = getArr<string>('我爱你',3)
  console.log(arr1);
  console.log(arr2);
  console.log(arr1[0].toFixed(2));
  console.log(arr2[0].split(''));

多个泛型参数的函数

  function showMessage<K,V>(value1:K,value2:V):[K,V]{
    return [value1,value2]
  }
  const arr = showMessage<string,number>('abc',123.4567)
  console.log(arr);
  console.log(arr[0].split('-'));
  console.log(arr[1].toFixed(2));

泛型接口

在定义接口时，为接口中的属性或方法定义泛型类型，在使用接口时，再指定具体的泛型类型

  interface IBaseCRUD<T>{
    data:Array<T>
    add:(t:T) => T
    getUserId:(id:number) => T
  }
  class User{
    id:number
    name:string
    age:number
    constructor(name:string,age:number){
      this.name = name 
      this.age = age
    }
  }
  class UserCRUD implements IBaseCRUD<User>{
    data:Array<User>=[]
    add(user:User):User{
      user.id = Date.now()+Math.random()
      this.data.push(user)
      return user
    }
    getUserId (id: number):User{
      return this.data.find(user => user.id === id)
    }
  }
  const userCRUD:UserCRUD = new UserCRUD()
  userCRUD.add(new User('jack',20))
  userCRUD.add(new User('tom',25))
  userCRUD.add(new User('lucy',23))
  userCRUD.add(new User('rousi',21))
  console.log(userCRUD.data);

泛型类

类中的属性值类型是不确定的，方法中的参书返回值类型也是不确定的。

  class Add<T>{
    count:T
    add:(a:T,b:T) => T
  }
  const a1:Add<number> = new Add<number>()
  a1.count = 10
  a1.add = function(a,b){
    return a + b
  }
  console.log(a1.add(1,2));
  
  const a2:Add<string> = new Add<string>()
  a2.count = '10'
  a2.add = function(a,b){
    return a + b
  }
  console.log(a2.add('亮亮','真帅'));

泛型约束

如果我直接对一个泛型参数取length属性会报错，因为这个泛型根本就不知道它有这个属性

  interface ILength{
    length:number
  }
  
  function getLength<T extends ILength>(x:T):number{
    return x.length
  }
  console.log(getLength<string>('bilibili'));
Xu.Youth
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
typeScript学习笔记
04-27
typeScript学习笔记
console 打印函数名和行号
04-15 477
function static print(...args) { const err = new Error(); const stack = err.stack.split('\n').slice(2).map(line => line.trim()); const caller = stack[0].match(/at (.+) \(/)[1]; const fileLine = stack[0].match(/\((.+)\)/)[1];
Typescript数据类型
m0_46684624的博客
09-08 170
typescript 非常包容，javascript 定义简单到复杂的一切类型 ts如果报错，依然可以生产js文件 ts拥有活跃的社区， typescript缺点 学习成本高 短期项目，简单的项目，效率低下 和其他库兼容性不高 安装typescript npm install -g typescript 将ts文件编译成js tsc index.ts typescript数据类型 原始数据类型：布尔，数值，字符串，null,undefined; 布尔类型定义：直接调用Boolean是可以的 let
TypeScript-02基础知识之函数
BlackStar的博客
11-01 256
TypeScript中的函数相关知识
typescript笔记
qq_31539817的博客
05-25 764
一：typescript介绍和环境搭建 1.typescript介绍 TS是属于JavaScript的超集，可以编译成纯JavaScript，TS新增了许多特性，例如数据类型、类、继承以及接口等。 2，typescript环境搭建 i.项目环境搭建 安装node.js=>全局按照typescript：npm i -g typescript ii.编写一个ts文件并编译 编写一个.ts文件=>命令行tsc b.ts=>编译成一个JavaScript文件。 iii.vscode
TypeScript函数和类
m0_72738258的博客
09-08 237
const a = function(b:string,c:string):string{ return b+c}function aa(bb:string,cc:string):string{ return bb;}输出单个括号可以省略const aaaaa = (time:number):void=>console.log(`2022年9月8日10:00:48${time}`);const aaa = (time:number):void=>{ console.log(`2022年9月
typescript 学习系列-函数
潇湘子的博客
03-05 188
介绍：函数是JavaScript应用程序的基础。 它帮助你实现抽象层，模拟类，信息隐藏和模块。 在TypeScript里，虽然已经支持类，命名空间和模块，但函数仍然是主要的定义行为的地方。 TypeScript为JavaScript函数添加了额外的功能，让我们可以更容易地使用 js中的函数 // 命名函数 function add(x, y) { return x + y; } // 匿名函数（或者也叫函数表达式） let addNum = function(x, y) { return x + y;
获取当前类名和方法名
chunzong9477的博客
09-15 474
当前类名： Stringclazz=this.getClass().getName(); Stringclazz=Thread.currentThread().getStackTrace()[1].getClassName(); 当前方法名： Stringmethod=...
【TypeScript】类类型：如何高效使用类型化的面向对象编程利器？
吉帅振博客
08-09 287
在JavaScript（ES5）中仅支持通过函数和原型链继承模拟类的实现（用于抽象业务模型、组织数据结构并创建可重用组件），自 ES6 引入 class 关键字后，它才开始支持使用与Java类似的语法定义声明类。TypeScript 作为 JavaScript 的超集，自然也支持 class 的全部特性，并且还可以对类的属性、方法等进行静态类型检测。在 TypeScript 中，因为我们需要实践 OOP 编程思想，所以离不开类的支撑。在实际工作中，类与函数一样，都是极其有用的抽象、封装利器。...
TypeScript+Vue3.0笔记二
weixin_51245887的博客
05-11 1783
TypeScript 类、泛型、接口
TS进阶小记
weixin_42173625的博客
06-08 255
TS学习
typescript学习笔记
03-04
typescript学习笔记
TypeScript 学习笔记
05-16
大学牲学习 TypeScript 的学习笔记，欢迎小伙伴们一起来学习！
TypeScript学习笔记
02-07
TypeScript学习笔记
string类的基本使用以及常用接口
时过夏末
06-07 262
string类的基本使用以及常用接口string类基本使用迭代器capacity等接口遍历操作string类对象的修改操作string常用接口 string类基本使用 #include <string> void test() { string str;//"" string str2("123");//"123" string str3 = "abc";//"abc" string str4("0123456789", 5);//"01234" string cpy(st
ts类与兼容性相关
恰饭的博客
05-22 600
1.类 // ts和ES6区别, 需要先定义实例属性, 才能够使用实例属性 class Person { name:string; // 和es6的区别：需要先定义实例属性，才能够使用实例属性，如果没定义就使用会报错 age:number; constructor(name:string,age:number){ this.name = name; this.age = age; } say():void{ consol
《前端面试题》- TypeScript - TypeScript的优/缺点
小张微说的博客
04-22 7084
问题 简述TypeScript的优/缺点 答案 优点 增强了代码的可读性和可维护性 包容性，js可以直接改成ts，ts编译报错也可以生成js文件，兼容第三方库，即使不是ts编写的 社区活跃，完全支持es6 缺点 增加学习成本 增加开发成本，因为增加了类型定义 需要编译，类型检查会增加编译时长，语法和类型系统复杂的话时间特别特别长 eval和new Function()这种操作类型系统管不到 ...
FME学习之旅---day27
最新发布
summer_corner的博客
05-17 201
我们付出一些成本，时间的或者其他，最终总能收获一些什么。
使用多实例学习进行乳腺癌组织病理学图像分类和定位
qq_47896523的博客
05-16 1105
乳腺癌是女性最主要的死亡原因，病理学家根据病理切片中观察到的各种视觉特征（例如细胞核的形态特征、细胞核的微观和宏观结构等）做出决定。计算机辅助诊断（CAD）系统可以帮助病理学家自动做出决策。卷积神经网络是最广泛使用的深度学习框架，用于学习图像类别之间的复杂判别特征。多年来，VGG16 [3] 和 ResNet18 [4] 等各种 CNN 架构在海量 ImageNet 数据集上产生了出色的结果。CNN 被用于医学图像以产生最先进的结果。为图像中存在的所有类别提供了定位信息。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值