TypeScript基础&JavaScript补漏

已于 2022-07-01 15:02:54 修改
阅读量1.6k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 自学 文章标签： typescript javascript 前端
于 2022-03-12 21:53:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41203489/article/details/123450839
这篇博客主要讲解了TypeScript的基础概念，包括箭头函数、this指向、深拷贝和浅拷贝。深入探讨了TypeScript的优化编译、基本类型、类型推论、函数、接口、数组、联合类型和交叉类型等特性。同时，还介绍了枚举、泛型、Class类、元组以及类型断言等内容，帮助读者巩固JavaScript知识并掌握TypeScript的高级特性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

js补漏

箭头函数

一个函数表达式如下：

const fun = function() {
  return 200;
}

以上的函数函数表达式用箭头函数可以写为：

const fun = () => {
  return 200;
}

小括号里面的是参数，没有参数可以写成上面的形式。如果只有一个参数，可以写为：

const fun = x => {
  return x;
}

箭头函数有一个语法：如果函数体中只有一行代码，那么这个return可以省略（json除外），为以下形式：

const fun = () => 200;

箭头函数和普通函数的区别： this指向
有一个对象：

 let obj = {
  name: "小明",
  age: 2,
  sayHello() {
    console.log("我是" + this.name);
  },
}
obj.sayHello();

上面的代码可以输出我是小明

但是如果我们加一个定时器：

let obj = {
  name: "小明",
  age: 2,
  sayHello() {
    setTimeout( function () {
      console.log("我是" + this.name);
    }, 500)
  },
}
obj.sayHello();

以上代码并没有输出我们所期望的“我是小明”，这时候我们在定时器内打印this指向，会发现this指向windows:

let obj = {
  name: "小明",
  age: 2,
  sayHello() {
    setTimeout( function () {
      console.log(this);
      console.log("我是" + this.name);
    }, 500)
  },
}
obj.sayHello();

在这里插入图片描述
但是如果我们把对象内部的函数写成箭头函数:

let obj = {
  name: "小明",
  age: 2,
  sayHello() {
    setTimeout(() => {
      console.log("我是" + this.name);
    }, 500)
  },
}
obj.sayHello();

会发现控制台打印出了“我是小明”。
这就是箭头函数和普通函数的区别：this指向不同：普通函数，谁调用这个函数this指向谁；箭头函数在哪里定义函数，this指向谁。

this指向

1、直接在script标签内部输出this,指向全局

<script>
  // 直接输出this指向全局对象
  console.log(this);
</script>

2、this放在方法中，this指向调用这个方法的对象：
   这个sayName()方法是由cat这个对象调用，所以this指向cat

  const cat = {
    name: "喵喵",
    sayName() {
      console.log("我是" + this.name)
    }
  }
  cat.sayName();

3、全局函数的this指向windows(全局对象)
   这个函数的调用其实是window.fun();，也就是fun()这个方法有window这个对象调用，所以this指向window

  const fun = function() {
    console.log(this);
  };
  fun();  //fun() = window.fun()

4、事件中的this，指向触发这事件的DOM。

<body>
  <button>点击</button>
</body>
<script>

  let btn = document.querySelector("button");
  btn.onclick = function() {
    console.log(this);
  }
</script>

  上面代码的this指向触发点击事件的button在这里插入图片描述

5、构造函数中的this，指向new创建的对象。
构造函数一般大写
构造函数：用来创建对象
new关键字做了什么：new会创建对象，将构造函数中的this指向创建出来的对象

  function F() {
    this.name = "小明";
    console.log(this);
  };

  let f = new F();
  console.log(f);

在这里插入图片描述
6、箭头函数的this。
箭头函数的this可以有三种理解方式：

1、普通函数，谁调用指向谁；箭头函数，在哪里定义指向谁。
2、箭头函数外指向谁就指向谁。
3、箭头函数没有this。

深拷贝和浅拷贝

浅拷贝：

let m = {a: 10, b: 20}
let n = m
n.a = 15
console.log(n);
console.log(m)

输出结果为：
在这里插入图片描述
n和m输出结果一样，是因为浅拷贝，两个变量n和m指向同一个堆，对象复制只是复制的对象的引用。如果用图来解释的话就是：在这里插入图片描述
深拷贝：

let m = {a: 10, b: 20}
let n = {a: m.a, b: m.b}
n.a = 14
console.log(m)
console.log(n.a)
console.log(n);

输出结果为：
在这里插入图片描述
深拷贝不再是复制对象的引用，而是彻底copy了一个对象，深拷贝出来的变量和被深拷贝的对象指向的不再是同一个堆。在这里插入图片描述
总结：

浅拷贝只是复制某个对象的指针，新旧对象指向的还是同一块内存。
深拷贝会开辟一个新的内存来存放复制过来对象。新对象跟原对象不共享内存，修改新对象不会改到原对象。
JSON.parse(JSON.stringify())一般用来深拷贝一个对象

优化编译

1、TS和JS冲突问题：tsc --init
  执行 tsc --init以后，会生成一个tsconfig.json的文件，其中的 "strict": true, 为严格模式的开关。（推荐开启）
2、自动编译：tsc --watch
3、发出错误：tsc --noEmitOnError fileName 出现类型错误，停止编译成js文件
  当我们执行tsc --noEmitOnError --watch以后，ts文件有类型错误，就会停止自动编译成js文件
4、直接运行ts文件：npm install @types/node -D 、 npm install ts-node -g安装好以后直接使用命令ts-node 文件名就可以直接编译ts文件
在这里插入图片描述

基本类型

String、Number、Boolean

在JavaScript中有三个最基本的类型：String、Number、Booleam，在typescript中，声明这些变量需要变量名后面加入类型。

let str: string = 'hello typescript';
let num: number = 100;
let bool: boolean = true;

any

如果是一个普通类型，在赋值过程中改变类型是不被允许的：
在这里插入图片描述
但是如果给他设置为any，则允许被赋值为任意类型：

let obj: any = {
  x: 0
};

obj.foo();
obj.bar = 100;
obj = "hello";

虽然这杨写ts不会报错，但是在编译成js后，运行，会报错，因为根本就没有bar这个属性：
在这里插入图片描述

类型推论

当没有给一个变量声明类型的时候，ts会去自动推断他的类型

let myName = "hahah";

myName = 1;

//不能将类型“number”分配给类型“string”。

实际上，这段代码等价于：

let myName: string = "hahah";

myName = 1;

//不能将类型“number”分配给类型“string”。

由上面可以看出，ts会自动推测变量类型。
如果定义的时候没有赋值，不管之后有没有赋值，都会被推断成 any 类型而完全不被类型检查：

let age;
age = "123";
age = 123;

函数

可以规定函数形参类型

// 规定形参类型
function grtee(name: string) {
  console.log("Hello" + name.toUpperCase() + "!");
};

grtee("JuNe");

也可以规定函数返回类型的规定

// 规定函数返回类型
function Num(x: number, y: number):number {
  return x + y;
};
console.log(Num(1,2));

匿名函数，当我们没有给函数的形参规定类型的时候，typescript可以自动根据上下文推断出他的类型。

const user: string[] = ['June', 'JUNe', 'JUNE'];
user.forEach(function(s) {
  console.log(s.toUpperCase());
  console.log(typeof s); // String
});

可以使用接口来固定函数类参数和返回值类型：

interface User {
  name: string,
  age: number,
};
// const fn = function(user: User):User {
//   return user;
// }
const fn = (user:User):User => user;

let a = fn({
  name: "Tom",
  age: 21
})

函数重载
重载允许一个函数接受不同数量或类型的参数时，作出不同的处理。

function fn(params:number):void
function fn(params:number,param2:string):void
function fn(params:any, param2?:any){
  console.log(params);
  console.log(param2);
}

上面定义了两套方案：当fn有一个参数params传入number类型的时候和 fn有两个参数params传入number类型,param2传入string类型。ts会自动识别我们下面的执行函数传入的是什么类型的参数，决定走那套方案。

let a = fn(1)  
// 1
//undefined

let a = fn(1,"2")
// 1
// 2

接口

接口声明一个普通的对象，接口一般首字母大写

interface A{
  name: string,
  age: number,
  gender: string,
};

let Tom: A = {
  name: "Tom",
  age: 1,
  gender: "man",
}

上面的例子中，我们定义了一个接口 A，接着定义了一个变量 Tom，它的类型是 A。这样，我们就约束了 Tom 的形状必须和接口 A 一致。
我们在Tom中多声明或者少声明，都会报错
在这里插入图片描述
在这里插入图片描述
当两个接口重名的话，会把两个接口内的属性合并
在这里插入图片描述
定义属性可选可不选：在变量名后面加?：

// 当两个接口重名的时候，接口内部的属性会合并
interface A {
  name: string,
  age: number,
};
// 可选属性在变量名后面加入?就可代表可选可不选
interface A {
  gender?: string,
};

let Tom: A = {
  name: "Tom",
  age: 1,
};

后端可能会返给我们一些我们不知道的数据类型，所以就需要我们在接口中定义一个接收任何类型数据的属性，即[propName: string]: any;
在这里插入图片描述
上面并没有在接口定义professional和class，但是对象中却可以存在。

只读属性

如果希望一些字段只能在被创建的时候被赋值。可以使用readonly属性。当我们尝试在后面修改该字段属性的时候，会报错

interface A {
  name: string,
  readonly age: number,  // 希望age为只读属性
  // 对象里面有任意属性
  [propName:string]: string | number,
};

在这里插入图片描述

接口里面定义函数

interface A {
  fun():number,
};

let Tom: A = {
  fun:()=>{
    return 123
  }
};

接口继承

可以使用es6的关键字extends

// 接口继承
interface A {
  name: string,
};
interface B extends A {
  age: number,
};
let person: B = {
  
}

如果这样写，编译器就会提示错误：类型“{}”缺少类型“B”中的以下属性: age, name，可以看到我们给person指定了接口B，但是由于B继承了接口A。所以要求把name也写上。

给函数定义接口

接口不仅仅可以给单独变量定义类型，也可以给函数定义形参类型和函数的返回值定义类型：

interface SearchFunc{
  (source: string, subString: string):string
}

上面的接口定义了如果一个函数使用接口SearchFunc，那么他需要有两个形参(函数的参数不需要与接口定义的名字相同)，并且两个形参的类型都需要是string，如果我们不按照规范使用，ts就会报错：

interface SearchFunc{
  (source: string, subString: string):string
}

let nishuo: SearchFunc 
nishuo = function(a:string, b:number){  // 不能将类型“(a: string, b: number) => string”分配给类型“SearchFunc”。参数“b”和“subString” 的类型不兼容,不能将类型“string”分配给类型“number”。
  let result = a
  return result
}

数组

ts的数组，有两种书写方式：类型+方括号 泛型

// 类型 + 方括号
let arr: number[] = [1,2,3];
arr = ['2'];

// 泛型
let arr2: Array<number> = [1,2,3];
arr2 = ['哈哈'];

当规定好数组的类型以后，再向其中写入其他类型数据，会报错。
在这里插入图片描述
多维数组：
只有一种类型：

// 正常
let arr2: number[][] = [[1],[2,3]];
// 泛型
let arr3: Array<Array<number>> = [[1,2],[3]];

多个类型：

// 普通
let arr2: (number|string)[][] = [[1,2],[3,4]];
// 泛型
let arr3:Array<Array<string | number>> = [[1008611],['wqe'], ['sadsad','adsad']];

arguments类数组

function Arr(...args:any):void {
  console.log(arguments);
  // ts内置内置对象IArguments
  let arr:IArguments = arguments;
};
Arr(4,5,6); // [Arguments] { '0': 4, '1': 5, '2': 6 }

用接口表示数组
一般是用来描述类数组

interface Arrtype {
  [index:number]: number,
};
let zxc:Arrtype = [1,2,3]

联合类型|类型推断|交叉类型

联合类型

// 声明变量的联合类型
let phoneNumber: number|string = 123

// 函数声明的联合类型
let fun = function(type: number|boolean){
  return type
}

交叉类型

和extends功能类似，可以把两个接口的字段整合起来，使用&连接符

interface People{
  name: string,
  age: number
}
interface Man{
  sex: string
}

const Tom = (Info: People & Man):void=>{
  console.log(Info);
  
}

Tom({
  name:"Tom",
  age: 23,
  sex: "man"
})

类型断言

类型断的语法是：

值 as 类型
<类型> 值

但是类型断言只能去欺骗ts，并不能避免错误

let fn1 = function(num:number|string){
  console.log((num as string).length);
}
fn1(1234)   // undefined

上面我们把num推断为string，但是实际调用使用了number类型，ts并没有报错，但是编译出来时undfined
同样，也可以用在函数上：

interface One{
  run: string
}

interface Two{
  bulid: string
}

let fn2 = (type:One|Two)=>{
  console.log((type as One).run);
  
}

fn2({
  bulid: "123"  // undefined
})

内置对象

JavaScript 中有很多内置对象，他们在ts内置，直接声明变量类型即可。

// 正则表达式
const regexp:RegExp = /\w\d\s/
// Date
const date:Date = new Date(); 
// error
const error:Error = new Error()

等等等

DOM
Document、HTMLElement、Event、NodeList 等。

let body: HTMLElement = document.body

let allDiv: NodeList = document.querySelectorAll('div')

//读取div 这种需要类型断言 或者加个判断应为读不到返回null
let div:HTMLElement = document.querySelector('div') as HTMLDivElement

document.addEventListener('click', function (e: MouseEvent) {
	// 操作
}

Class类

ES6新增了Class语法。
ts也支持Class类。ts需要提前声明变量以及类型，不然会报错：类型“xxxx”上不存在属性“yyyy”

class Person {
  // ts需要提前声明变量以及类型，不然会报错：类型“xxxx”上不存在属性“yyyy”
  name: string
  age: number
  sub: boolean
  constructor (name:string, age:number, sub:boolean) {
    this.name = name;
    this.age = age;
    this.sub = sub;
  }
}
new Person("Tom", 23, true)

元组

元组是一个数组的变种。
元组是固定数量的不同类型的元素的组合。
数组合并了相同类型的对象，而元组合并了不同类型的对象。

定义一个string和number类型的元组：

let person:[string, number] = ['string', 22]

我们可以对元组进行赋值或者索引：

let person:[string, number] = ["Tom", 23]


let arrLength = person[0].length
console.log(arrLength);

person[1] = 24
console.log(person);

在这里插入图片描述
对于越界元素，ts会在元组中给你推断为联合类型：

let person:[string, number] = ["Tom", 23]

person.push(false)

在这里插入图片描述

枚举

数字枚举

默认枚举

在ts中，枚举的关键字是enum：

enum Color {
  red,
  green,
  blue,
}

而且ts的枚举，默认是从0开始
在这里插入图片描述
也可以通过console输出来确认：
在这里插入图片描述

增长枚举

当我们不想让枚举从0开始的时候，可以手动给第一个枚举对象设置一个初始化的值：

enum Color {
  red = 1,
  green,
  blue,
}

这样，默认就从1开始了，后面的索引值也会自动递增：
在这里插入图片描述

自定义枚举

我们也可以给枚举对象的数字

enum Color {
  red = 1,
  green = 2,
  blue = 3
}

字符串枚举

字符串枚举没有自增长，可以很好的序列化

enum Type {
  red = "red",
  green = "green",
  blue = "blue"
}

异构枚举

字符串和数字混合枚举

enum Type {
  yes = 1,
  no = "no"
}

const枚举

let和var是不允许声明枚举的，只能是const。因为大多数情况下，枚举是十分有效的方案。在某些情况下要求很严格，为了避免在额外生生成的代码上的开销和额外的非直接对枚举对象的访问，一般会使用const枚举。

泛型

定义一个函数：

function demo(arg:number):number {
  return arg
}

这个函数规定了传入的参数和返回的值都是number类型，但是当我们不知道出入的参数和返回值类型的时候，这么写就会出现问题。为了不出现因为不确定类型而导致的报错，我们会想到用any类型：

function demo(arg:any):any {
  return arg
}

但是当我们使用any以后会失去ts的检查机制，这个例子最明显的点就是参数和返回值可以类型不一样了,这并不是我们最初想要的内容。这时候就需要泛型：

function demo<T>(arg:T):T{
  return arg
}

我们给demo添加类型T，并且用<>包裹起来，T帮我们捕获输入的数据类型，给形参arg定义相同的数据类型T，并且返回值也定义为T这样就可以保证可以传入任何参数，并且实现最初的功能：保持形参和返回值是同一数据类型。

当我们使用泛型创建函数的时候，因为传入的参数可能是任何类型，所以当我们试图打印arg的长度的时候：

function demo<T>(arg:T):T{
  console.log(arg.length);  // Error：类型"T"上不存在属性“length”
  return arg
}

ts会报错：类型"T"上不存在属性“length”。因为传入的数据类型可以是任何类型，假设是number，而number是没有长度的，所以ts会报错。
所以，我们要把这些参数当做是任意或所有类型
泛型还可以自定义数据类型：

function fnz<T>(arg:T):T {
	return arg
}

fnz<number>(13)
fnz<string>("string")

泛型接口

定义一个通用泛型函数：

function ident<T>(arg:T):T{
  return arg
}

如果我们想声明一个基于该通用函数的函数的话，可能需要这么写：

function ident<T>(arg:T):T{
  return arg
}

let fun : <T>(arg:T) =>T = ident

这时候就可以把fun后面的类型，写成一个接口：

interface Gener{
  <T>(arg:T):T
}
function ident<T>(arg:T):T{
  return arg
}

let fun: Gener  = ident

我们也可以把泛型参数作为整个接口的一个参数，这样我们就能清楚的知道使用的具体是哪个泛型类型。接口里的其它成员也能知道这个参数的类型。

interface GenericIdentityFn<T> {
    (arg: T): T;
}

function identity<T>(arg: T): T {
    return arg;
}

let myIdentity: GenericIdentityFn<number> = identity;

myIdentity("string")   // Error:类型“string”的参数不能赋给类型“number”的参数。

以上需要注意的是，当我们使用GenericIdentityFn的时候，还需要传入一个类型参数来指定泛型类型，上面是给了number类型，给了类型参数以后，后面的代码就只能使用传入的参数类型。 如果我们调用myIdentity给他一个参数为string类型：myIdentity("name")，ts就会给出报错类型“string”的参数不能赋给类型“number”的参数。

type

type 可以声明基本类型别名，联合类型，元组等类型：

// 类型别名
type Name = string

// 联合类型
interface Dog {
    wong();
}
interface Cat {
    miao();
}
type animal = Cat | Dog
// 元组类型
let Yuanzu = ["One", "Two"]
TypeScript自学课(5)-使用TSC编译TS
发果叁
06-16 2892
在上一章中，我们介绍了TSC工作，但是并没有完整的走完一个使用流程，本文，我们通过一个add函数来学习编写TS代码的流程。在编码之前，是需要配置好TSC的配置文件,执行 初始化项目,自动生成文件，并默认配置项。对于一个前端项目，肯定是分文件夹的。例如：我们的代码可能是放在src下面，如果有使用npm拉取使用第三方包，会生成文件夹。src我们是需要编译的，但是是不需要编译的，我们就需要将排除掉，就像是webpack打包也会配置排除TSC提供了和来配置编译和忽略文件。 启动监听，不打包 此时你会在控制台发现，
前端技术栈查缺补漏
最新发布
前端金牌摸鱼达人
08-03 810
前端技术栈涵盖广泛，涉及多个领域和技术方向。以下是全面的分类总结，帮助你对前端技术生态有系统化的了解：
createjs typescript代码提示
weixin_45051415的博客
11-26 406
最近迁移项目到新框架,用上了typescript,结果日常被类型检查搞得不堪其扰,今天测试createjs的时候就遇到了这么一个问题。
“typecheck“:“tsc --noEmit“ 只进行类型检查，不输出结果
Yan的博客
04-17 1538
tsc --noEmit` 是 TypeScript 编译器（tsc）的一个命令行参数。当你运行 `tsc --noEmit` 时，TypeScript 编译器会执行类型检查，但不会生成任何 JavaScript 输出文件。使用这个参数的好处在于，你可以在不做实际构建（emit JavaScript 文件）的情况下检查 TypeScript 代码的类型正确性，这对于持续集成、代码审查或者只想进行类型检查而不生成实际产物的场景非常有用。- `tsc` 是 TypeScript 编译器的命令。
vue-tsc --noEmit导致打包报TS类型错误
热门推荐
编码世界
06-30 7万+
当我们新建vue3项目，package.json文件会自动给我添加一些配置选项，这写选项基本没有问题，但是在实际操作过程中，当项目越来越复杂就会出现问题。本文列举一个目前我遇到的一个问题：打包后报了一堆TS类型错误，怎么消除这些错误？
vue3+ts打包报错处理
会烘焙的工程师的博客
12-06 2万+
打包报错 但是npm run dev 是运行正常的 经过一番搜索之后，这个错误是比较难搜索到的注意看package.json 中的vue-tsc --noEmit 删掉就可以了 { “name”: “vuevitec”, “version”: “0.0.0”, “scripts”: { “dev”: “vite”, “build”: “vue-tsc --noEmit && vite build”, “preview”: “vite preview” }, 改成如下 { “name”: “vuevitec”
前端跳槽面试必备技巧 面试官全流程指导、知识串讲、差缺补漏.zip
03-16
- **JavaScript**：掌握ES6及以上语法，理解闭包、原型链、异步编程等概念。 - **DOM操作**：熟练使用选择器、事件处理和性能优化。 - **框架与库**：React、Vue、Angular等主流框架的基本原理和应用场景。 - **...
TypeScript进阶 之 重难点梳理
全栈前端精选
03-23 1981
点击上方“全栈前端精选“，回复“1”进交流群加入我们一起学习，天天进步THE LAST TIME❝The last time, I have learn...
JavaScript全领域思维导图资源分享
- **TypeScript**：介绍TypeScript作为JavaScript超集的优势、类型系统、接口、类、模块和装饰器。 - **前端测试**：基本的单元测试、集成测试、端到端测试的工具和框架，例如Jest、Mocha、Chai、Karma和Jasmine。 -...
秋招之后的学习java心得
Feng_clay的博客
11-27 964
2021.3.20投出第一份实习简历，5.28收到华为实习意向书。8月12日实习离职开始投递秋招，期间边面试边查缺补漏，算法能力、面经八股文以及项目经验都在这个过程中不断提高，最终收获了几个比较满意的offer。国庆假期刚结束，我的秋招之旅也随之结束。在非科班转码的路上，走了很多的弯路也干了很多无意义的工作，其中的酸甜苦辣只有经历过的朋友才能体会，最终如愿成功上岸，我十分庆幸自己的选择和坚持，也十分感谢一路上互相帮持的转码小伙伴。 背景介绍 本科江苏某双非一本，机械天坑专业，研究生江苏某国防七子之一..
vue-tsc
03-03
vue-tsc vue-tsc --noEmit && vite build
typescript开发环境准备
水痕
08-27 798
一、软件的安装 1、安装软件 npm install -g typescript 二、配置tsconfig.json 1、命令行生成文件 tsc --init yes 2、附上我介绍的 { "compilerOptions": { /* 基本选项 */ "target": "es5", // 指定 ECMASc...
vue+tsc+noEmit导致打包报TS类型错误问题及解决方法
m0_63026408的博客
05-06 946
是否正确，也不会对。
vite+vue3构建项目打包异常
qq_43413883的博客
04-15 7421
vite+vue3项目初始化完成后打包异常Cannot access ambient const enums when the '--isolatedModules' flag is provided.
vite—打包常见问题
m0_37616866的博客
12-15 6615
问题：打包时使用ts校验报错，原因是代码不符合ts校验规范 解决方案： 1. 关闭ts打包校验, 关闭vue-tsc ，修改package.json 2. 修改不符合ts规范的代码, vsCode中划横线的代码 // 方案一 "scripts": { "dev": "vite", // "build": "vue-tsc --noEmit && vite build", "build": "vite build", "serve": "vite prev.
记录vite打包报错问题
qq_36821274的博客
02-28 2896
项目搭建（vue3+element-plus+vite） 报错信息： 配置文件： 原因： 我这个项目不是使用ts开发的，但是在配置项目的时候加入了vue-tsc --noEmit 这个东西 去掉vue-tsc --noEmit这个然后再执行，就可以了。 ...
nodejs + typescript + nodemon + ts-node 服务器端搭建demo
lck8989的博客
05-01 8259
之前都是用js开发的nodejs应用，今天试着用typpescript写服务端程序，这里遇到的一些坑总结一下： 1: 首先创建一个文件夹用于存放nodejs项目，这里起名为 node-ts-server 2：执行npm init项目会生成一个package.json文件 3：安装typescript npm install typescript 4: 执行tsc --init 自动生成ts...
tsconfig常用配置解析
cnmeimei的博客
02-13 9874
一、TypeScript编译工具安装 我们用TypeScript开发项目的时候，编写的源文件都是以".ts"结尾的文件，而".ts"文件是无法直接被浏览器或node环境下直接运行的，所以必须进行编译，将".ts"的文件编译成".js"文件后才能直接运行。要想编译TypeScript文件，那么必须使用tsc编译工具，需要注意的是，我们并不是直接去安装tsc，而是全局安装typescript，全局安装...
typescript &&运算符
04-29
TypeScript是一种由微软开发的开源编程语言，它是JavaScript的超集，意味着它支持JavaScript中的所有语法和特性，同时还提供了额外的静态类型、类、接口和命名空间等特性，以帮助开发者编写更加健壮、可维护的代码。TypeScript还提供了一些工具和语言服务，例如代码自动完成、重构支持和代码导航等，这些都使得开发者更加高效地进行开发。TypeScript最终会被编译成JavaScript，因此它可以在任何支持JavaScript的平台上运行，包括浏览器、服务器和移动应用程序等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值