今天在项目代码里看见这么一段
export default function asyncComponent(getComponent: () => Promise<any>) {
....
}
主要懵在这个参数上
| asyncComponent(getComponent: () => Promise<any>) |
冒号左边 getComponent 应该是参数名
冒号右边 () => Promise<any> 应该是这个参数的类型
但是() => Promise<any>到底是个什么类型呢?
写个例子试一试
Main.ts
所有的函数都从Function.prototype中继承了call, apply 和 bind 方法
这些方法可以设置函数内部的this值
初始化
npm init -y
安装ts
npm install -g typescript ( linux 或者 mac 如果出现权限错误需要sudo )
先定义一个Student类, 包含两个属性name和age, 实际上我只使用了name
|
export class Student { public name: string; public age: Int16Array; public hello() { console.log("hello, i am " + this.name); } } |
起这么个名字主要是为了自己备忘
1. 原生node使用的是CommonJS
2. CommonJS, TypeScript, ES6 是三种不同的Javascript
3. 通过 babel 等库, 上面这3种 Javascript都可以被编译成在浏览器端可以运行的代码
4. CommonJS里每个文件都是一个模块, 每个模块有自己的作用域, 其中的变量和方法都是私有的
5. CommonJS通过module.exports变量导出变量和方法, Node还会为每个模块提供var exports = module.exports; 所以可以直接使用exports变量
6. require 是运行时调用, 所以require理论上可以运用在代码的任何地方
7. import 是编译时调用, 所以必需放在文件开头
8. require 是赋值过程, require的结果就是对象,数字,字符串或者函数等
9. import 是解构过程, 但是目前所有的引擎都没有实现import, 所以在node中使用的ES6 import 都需要babel转为ES5代码之后才能运行
metrics-registry = "https://registry.npmjs.org/"
npm config ls
npm install --registry=https://registry.npm.taobao.org --loglevel=silly
npm cache clean --force
|
package lizhe
import ( "errors" )
func Division(a, b float64) (float64, error) { if b == 0 { return 0, errors.New("除数不能为0") }
return a / b, nil }
|
|
package lizhe |
|
package main
import ( "fmt" "reflect" )
type User struct { Id int Name string Age int }
func (u User) Hello() { fmt.Println("Hello world!") } func Info(o interface{}) { t := reflect.TypeOf(o) fmt.Println("Type:", t.Name())
|
|
package main
import ( "database/sql" "log"
_ "github.com/go-sql-driver/mysql" )
func checkErr(err error) {
if err != nil {
//log.Println(err)
}
}
func main() {
|
sync.Pool 用于缓存
1. pool 可以减少GC对高并发的性能影响
2. 提供了对象重用
3. 并发安全
4. 仅受限于内存大小
5. 减少GC
6. 对象被删除时不会通知
7. 动态扩容或者收缩
|
package main
import ( "log" "sync" )
func main() { var intPool = sync.Pool{} for i := 0; i < 5; i++ { intPool.Put(i) } log.Println(intPool.Get()) |
通道
atomic和互斥锁都可以保证线程安全, 不过在go语言里, 还有一种有趣的实现就是通道
|
package main
import ( "fmt" )
func main() { buffered := make(chan string, 10) buffered <- "hello world" value := <-buffered fmt.Println(value) }
|
当一个资源需要在goroutine之间共享时, 通道在goroutine之间传递数据, 并且还提供了同步交换数据的机制.
线程不安全的版本
|
package main import ( "fmt" "runtime" "sync" ) var ( count int32 wg sync.WaitGroup ) func main() { wg.Add(2) go addValue() go addValue() wg.Wait() fmt.Println(count) } func addValue() { defer wg.Done() |