interface IPerson {
    name: string;
    age: number
    
}

class Person {
    //接口的第一个用法 ，作为一个方法的参数的类型声明(声明属性)
    constructor(public config: IPerson) {
        
    }
}

//传入的对象必须符合接口的定义，（名称一样，数量一样）
var p1 = new Person({
    name: '3',
    age:4
})



//接口的第二个用法 ，(声明一个方法)
interface Animal{
    eat()
}

//Sheep类去实现Animal这个接口
//当一个类要去实现一个一个接口的时候，必须要实现接口里边声明的方法
class Sheep implements Animal{
    eat() {
        console.log('============== i am eat grass',);
    }
} 

class Tiger implements Animal{
    eat() {
        console.log('============== i am eat meat',);
    }
}

var arr = [1,2,3,4]
arr.desc = "an array"

arr.forEach(val => {
    console.log('==============',val)
    // 1,2,3,4
})

var arr = [1,2,3,4]
arr.desc = "an array"


for (var key in arr){
    console.log('==============',key)
        // 0,1,2,3,desc
}

var arr = [1,2,3,4]
arr.desc = "an array"


for (var val of arr){
    console.log('==============',val)
        // 1,2,3,4
}

class Persion{
    
    //只有在类被实例化的时候才会被调用（每一次实例化只会调用一次）
    //只能在类的内部被访问到
    constructor(public name: string){
        console.log('==============father','constructor');
    }
        
    //默认是public，类的内外都可以访问
    // public name;
    
    //类的内部和子类的才可以访问
    protected age;

    //类的内部才可访问的到
    private sex;
    
    eat(){
        console.log('==============eating');
    }
}

//extends关键字是用来声明一种继承关系
//子类会继承父类的所有属性和方法
class Employee extends Persion {

    constructor(name: string, code: string) {
        //super的第一个作用，调用父类的构造函数
        super(name)
        this.code = code
        console.log('==============son','constructor');
    }
    code: string;
    
    work() {
        //super的第二个作用，调用父类的其他方法
        super.eat()
        this.doWork()
    }
    
    doWork(){
        console.log('==============doWork',);
    }
}

let el = new Employee('name', '111')
el.work()



let p1 =new Persion('liu')
p1.name = "batMan"
//p1.eat()

let p2 =new Persion('jia')
p2.name = "superMan"
//p2.eat()

var a = {}
var b= new Object()

a.__proto__ === b.__proto__ //true   一般情况   obj.constructor.prototype === obj.__proto__

//等同于下方
a.constructor === b.constructor === Object() //true

function Test(name){
this.name = name
}

Test.prototype.sayName = function (){
console.log('xxxxx',this.name)
}

const t = new Test('Jeffrey')
console.log(t.name) // 'Jeffrey'
t.sayName() // 'Jeffrey'

Number(null) //0
//null+5=0

Number(undefined) //NAN
//undefined+5=NAN

const http = require('http')
const url = require('url')
http.createServer((req, res) => {
    const data = {name: 'uthus'}
    // 获取查询参数callback，就是我们在客户端定义的jsonpCb
    const callback = url.parse(req.url, true).query.callback
    if (callback) {
        const str = callback + '(' + JSON.stringify(data) + ')'
        // 以字符串的形式返回
        res.end(str)
    } else {
        res.end('hello world')
    }  
}).listen(3000)
console.log('xxxxxxxxxxx000', 'listen at 3000');

foo({name: 'uthus'});

/**
 * 获取随机字符串,用于拼接
 * @param {string} prefix [前导名字]
 * @param {number} num  [字符串长度]
 */
function getRandomName (prefix, num) {
	return prefix + Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, num)
}
/**
 * 创建script标签
 * @param {请求路径} url 
 */
function createScript (url) {
	const script = document.createElement('script')
	script.setAttribute('type', 'text/javascript')
	script.setAttribute('src', url)
	script.async = true
	return script
}
/**
 * 实现请求
 * @param {路径} url 
 */
function jsonp (url) {
	return new Promise((resolve, reject) => {
		const cbName = getRandomName('callback')
		window[cbName] = function (data) {
			resolve(data)
		}
		url += url.indexOf('?') > -1 ? '&' : '?'
		const script = createScript(`${url}callback=${cbName}`)
		script.onload = function () {
			script.onload = null
			if (script.parentNode) {
				script.parentNode.removeChild(script)
			}
			window[cbName] = null
		}
		script.onerror = function () {
			reject()
		}
		document.getElementsByTagName('head')[0].appendChild(script)
	})
}

// 调用
jsonp('http://localhost:3000').then(res => {
    console.log(res)
}).catch(err => {
    console.log(err)
})