Typescript and go --- essence

A formal parameter is a copy of the contents of an argument , To modify an argument, you must pass in the address

map and chan, Slices are all pointer types , So you can directly assign values to functions , No need to take the address

When the pointer operates , No need to go again *p Value operation , You can directly call methods and variables with pointers , because GO Automatically added

var phone Phone
phone = new(NokiaPhone)
phone.call()

s :=make(map[int]*person){
    1:&user{"jack“,20}
}
s[1].name = "li"

 

Use new Function to allocate memory for a new struct variable , It returns a pointer to allocated memory ：var t *T = new(T)

var t *T = new(T)

type struct1 struct {
    i1 int
    f1 float32
    str string
}

func main() {
    ms := new(struct1)
    ms.i1 = 10
    ms.f1 = 15.5
    ms.str= "Chris"
}

map Same as interface, They're all pointer types

// here x You get the address 
m := make(map[string]int)
func text(x map[string]int){
    fmt.Printf(x)
}

struct Anonymous fields implement inheritance , Will inherit the previous method

type Student struct {
	Person //  Anonymous fields implement inheritance  ( Structure nested structure )
	//p Person  //  It can also be a structure Person names 
	score int
}

 

var b *Books
  
b = &Book1
fmt.Println(b)    //&{Go  Language  www.runoob.com Go  Language course  6495407}
fmt.Println(*b)   //{Go  Language  www.runoob.com Go  Language course  6495407}
fmt.Println(&b)   //0xc000082018
fmt.Println(Book1)    //{Go  Language  www.runoob.com Go  Language course  6495407}

chan:

 The main thread does not wait for the child thread to end , Unless time.Sleep

chonlyread := make(<-chan int) // ( Out ） Create read only channel 
chonlywrite := make(chan<- int) //( Enter into ） Create write only channel 
chan  The difference between buffered and unbuffered ： Every few elements can block another GO Threads 

 Monitor multiple channels ,  It can be used at this time select select{case n = <-ch:}

close(ch) // End channel 

case <-time.After(time.timeOut) // You can exit without waiting for an abnormal error 

if x,ok := ch; ok{}  for x:= range ch 

var wg sync.WaitGroup  wg.add(lenth) wg.Done() wg.Wait() // Number of open tasks , End task ,wait Used to block subsequent programs until the end of the channel 

interface It's a type of , The default is a pointer .interface Types can define a set of methods , But these don't need to be realized . also interface Can't contain any variables .
The structure implementation interface can be used as a class new
No, let、 The colon 、 Brackets 、 function func、 Define the method for the structure 、 Structure pointer 、 Defining interfaces , The structure implements the interface method , Array of structs ,map Structure
Increase slice capacity make([]int,3,5) append(numbers, 2,3,4)  make(chan int,10) make(map[string]int) make([]int{},1,2)
typescript Interfaces can define methods
func getAverage(arr []int, size int) float32 // Distinguish between definition and initialization

defer Only after all statements in the current function have been executed , Is the scope in the current function And exist at the same time defer

Execute in reverse order
panic recover
Interface

x,ok :=m["b"]

for index,value := range arr // It's kind of like foreach How to write it

x,_ :=  On behalf of ignore

fallthrough Ignore case Conditions continue

 

TypeScript There is only one type of number in , No, byte、short、int、uint、long、float、double Other types , and TypeScript Of number It's actually a 64 Is a double precision floating-point number , It can be seen as... In other languages double type .

 

let x: number =10
let arr: number[] = [1,2]
let a: [string,number] = [22,"a"]
let xx: any = 2
var hello : string|number

var foo = (x:number) =>10+x 
function name(x: string,b: number = 0.6):number{
    retrun parseInt(b)+x
}
name(10,20)

functionbulid(first:strting,....seconde:number[]) {
    retrun first + seconde
}
let name = buildType("jsonk",2,3,4,5)

// Think of an interface as a type
interface a{}
interface b{}
interface c extends a,b{}

var name :c ={
    v1:12
    v2:22
}

interface Person {
  name: string;
  age?: number;      // Add... After the attribute ？ Indicates that the attribute is optional
 [propName: string]: any;     // It means that you can add any number of attributes  , The added attribute type is any
}

class Car {
    engine:string,
    constructor(engine:string){
        this.engine = engine
    }
    disp():void{

    }
}

class hello extends Car {
    static num:number
    static disp():void{
        super.disp()
        console.log()
    }
    private str2:string = "world"
}

var obj = new hello()
let status = obj instaceof hello

class hello implements name{
    constructor(num:number,helo:string){
        this.num = num 
        this.hello = height
    }
}

export interface name {}
import name  = require("/name")
export class Circle implements shape.index{
}
import Circle = require ("/Circle")