カテゴリー: TypeScript

// generics
function comp<T>(arg: T[], comp: T): T[]{
    let ret: T[] = []

    for (let i = 0; i < arg.length; i++){
        if (arg[i] === comp){
        ret.push(arg[i])
        }
    }
    return ret
  }

console.log(comp([3, 2, 8, 10], 3))

console.log(comp(['3', '2', '8', '10'], '3'))

[ 3 ]
[ '3' ]

// rest parameter (type safe compared to arguments method)
function sumRest(message: string, ...numbers: number[]):[string, number]{
    return [message, numbers.reduce((total, n) => total + n, 1)]
}

let res: [string, number] = sumRest('sum :', 1, 2, 3, 4, 5)
console.log(res[0], res[1] )

// using call signature
type sr = (message: string, ...numbers: number[]) => [string, number]
let re_t:sr = (message, ...numbers) => [message, numbers.reduce((total, n) => total + n, 1)]
console.log(re_t('call signature', 1, 2, 3, 4, 5))

[ 'call signature', 16 ]

// argument as an array
function sum(numbers: number[]): number{
    return numbers.reduce((total, n) => total + n, 1)       // the return value starts with 1
}

console.log(sum([1, 2, 3, 4, 5])) // 16

// rest parameter (type safe compared to arguments method)
function sumRest(message: string, ...numbers: number[]):[string, number]{
    return [message, numbers.reduce((total, n) => total + n, 1)]
}

let res: [string, number] = sumRest('sum :', 1, 2, 3, 4, 5)
console.log(res[0], res[1] ) // sum : 16

// default parameter
type Context = {
    appID?: string,
    userID?: string
}

function log(message: string, context: Context = {userID:'aaabID'}){
    let time = new Date().toString()
    console.log(time, message, context.userID)
}

let id: Context = {userID: 'xxxyID'}
log('parameter', id)    // Wed Jun 14 2023 14:43:05 GMT+0900 (日本標準時) parameter xxxyID
log('parameter')        // Wed Jun 14 2023 14:43:05 GMT+0900 (日本標準時) parameter aaabID

% npx tsc --init

Created a new tsconfig.json with:                                               
                                                                             TS 
  target: es2016
  module: commonjs
  strict: true
  esModuleInterop: true
  skipLibCheck: true
  forceConsistentCasingInFileNames: true


You can learn more at https://aka.ms/tsconfig

// union & intersection of types
type Cat = {name: string, purrs: boolean}
type Dog = {name:string, barks: boolean}
type CatOrDog = Cat | Dog
type CatAndDog = Cat & Dog

let a_o: CatOrDog = {
    name: 'ball',   // need not to specify all properties
    barks: false
}

let a_a: CatAndDog = {
    name: "Dounald",
    barks: false,   // need to specify all properties of the Dog and Cat
    purrs: false
}

// object, Object and {}
let o1: {}
let o2: object
let o3: Object  // Object is an interface

o1 = {a: 2} // object
o1 = 123    // primitive

o2 = {a: 2}
//o2 = 123  // primitive is not usable

o3 = {a: 2}
o3 = 123

o1 = {toString() {return 1}}    // accept any type of object
//o3 = {toString() {return 1}}    // treat o3 as a string type which is a predefined type

// unknown type 
let aa: unknown = 10    // type safe 'any'
let cc = aa === 10      // === is usable
console.log(cc)

//let dd = aa + 20      // -> cause error
if (typeof aa === 'number'){
    let dd = aa + 20
    console.log(dd)
}


// any type
let aaa: any = 10    // type safe 'any'
let ccc = aa === 10
console.log(ccc)

let ddd = aaa + 20
ddd = aaa + 20
console.log(ddd)

% ts-node "./hello.ts"
true
30
true
30

// type of unknown
let hh: unknown = 10
if (typeof hh === "number"){
    let hh_m = hh * 3
    console.log(hh_m)
}