JavaScript入门 对象检查数据类型/原型链/class类 Day19

对象检查数据类型

基本数据类型

• typeof

复杂数据类型

• instanceof     实例对象 instanceof 类型  匹配打印true
• Array  Date  ->  Object 

数组类型

• Array.isArray(obj) -> true | false 

   function test1(){
              let num = 100
              let str = 'hello'
              console.log( typeof num)
              console.log( typeof str)
  
              let obj = {name:'jack'}   //Object
              console.log(typeof obj)  // object
  
              let arr = [1,2]          // Array
              console.log(typeof arr) // object
  
              let date = new Date()
              console.log( typeof date) // object  Date
          }
          // test1()
          function test2(){
              let obj = {name:'jack'}
              let arr = [1,2]   
              let date = new Date()
              // obj instanceof Array  -> true | false
              console.log( date instanceof Array  )
          }
          // test2()
          function test3(){
              let obj = {}
              let arr = [1,2]
              console.log(  Array.isArray(obj) )
          }
          test3()

原型链 

显示原型和隐式原型

• prototype是构造函数都有的属性，称为显示原型。
• ___proto__是每个对象都有的属性，又称为隐式原型。
• 但是，___proto__不是一个规范属性，只是部分浏览器实现了此属性，对应的标准属性是[[Prototype]]
• * 每个对象都有一个__proto__属性指向它的原型 *
• 原型对象也是一个对象, 原型对象也有__proto__指向它的原型

什么是原型链

多个原型通过隐藏__proto__连接起来，形成的一种链式结构，称为原型链.

原型链作用 

访问对象属性或方法时，会沿着原型链上的所有原型进行查找，至到根null为止

• 属性和方法共享 
• 继承
• 

class类[ES6新增]

ES6新增的面向对象语法

解决: 使用构造函数和原型定义对象属性方法问题更加简易

语法

创建对象之前， 一般先定义对象的类型, 在类型中定义属性和方法

先类型再有对象

 class 类名{
// 构造器 -> 私有
 constructor(name,age){
 //属性和方法
 this.name = name
 this.age = age
}
 // 方法 -> 原型->公共
say(){
                      
     }
}
let p = new 类名(name,age)

 // ES5面向对象
			function Person(name, age) {
				this.name = name
				this.age = age
			}
            Person.prototype.say = function(){
                console.log('说话');
            }
			/*
                创建人类，它有姓名name，年龄age属性
            */
			class Person {
                // 私有
				constructor(name, age) {
					this.name = name
					this.age = age
				}
                // 公共
                say(){
                    console.log('说话');
                }
			}
			let p = new Person('jack', 18)
			console.log(p.name, '  ', p.age)
            console.dir(Person.prototype);
            console.dir(p);

 考试部分

/* 
  假设：编写一个方法，求一个字符串的字节长度。 一个英文字符占用一个字节，一个中文字符占用两个字节
    分析: 
       要点： 中文字符unicode编码大于255
               hello
               01234
               字符串.charCodeAt(索引号)

       思路:  原字符串长度保存到变量bytes中。 
              遍历字符串，判断字符，如果字符是中文字符bytes++。

        let str = 'hello大家好'
        let count = 0 //统计字节长度

        for(let i = 0; i < str.length; i++){
            let code = str.charCodeAt(i)
            if(code > 255){
                count += 2
            }else{
                count++
            }
        }
*/
function GetBytes(str) {
	var len = str.length
	var bytes = len
	for (var i = 0; i < len; i++) {
		if (str.charCodeAt(i) > 255) bytes++
	}
	return bytes
}

/**
 * 利用欧几里得算法（辗转相除法）编写一个函数gcd(x,y) 求最大公约数，编写一个函数lcm(x,y)求最小公倍数
 
 1.最大公约数
    递归的方式：
    首先确定如何求最大公约数，我们采用欧几里得算法（辗转相除法），算法描述如下：
    例：48,57
    57%48=9     大数对小数求余
    48%9=3       小数对上次的余数求余，重复这个过程直到余数为0

    9%3=0         余数为0时，此次求余的小数就是最大公约数

 2.最小公倍数
  定理：x、y 两个数的最小公倍数乘以它们的最大公约数等于 x 和 y 本身的乘积。
 
  即LCM(x,y)=(x*y)/GCD(x,y)

 */
function gcd(x, y) {
	let max = x > y ? x : y
	let min = y < x ? y : x
	if (max % min == 0) {
		//如果能整除，小数就是最大公约数
		return min
	} else {
		return gcd(min, max % min)
	}
}

function lcm(x, y) {
	return (x * y) / gcd(x, y)
}

/*
	随机颜色值
		颜色值:   RGB      Red   Green    Blue
						0-255  0-255    0-255
						RGB(156,240,210)
				十六进制
				0 - 9  A B C D E F 
				#A35EB1
*/

function getRandom16Color() {
	var r = getRandom(0, 256)
	var g = getRandom(0, 256)
	var b = getRandom(0, 256)

	var r1 = r.toString(16)
	r1 = r1.length == 1 ? '0' + r1 : r1
	var g1 = g.toString(16)
	g1 = g1.length == 1 ? '0' + g1 : g1
	var b1 = b.toString(16)
	b1 = b1.length == 1 ? '0' + b1 : b1

	var rgbColor = `#${r1}${g1}${b1}` // #0abc02

	document.querySelector('div').style.backgroundColor = rgbColor
}
getRandom16Color()

/**
 * RGB随机颜色
 */
function getRandomRGBColor() {
	var r = getRandom(0, 256)
	var g = getRandom(0, 256)
	var b = getRandom(0, 256)
	var rgb = `rgb(${r},${g},${b})`
	document.querySelector('div').style.backgroundColor = rgb
}

/**
 * 生成m-n之间随机数
 * @param {*} m 
 * @param {*} n 
 * @returns 
 */
function getRandom(m, n) {
	var max = Math.max(m, n)
	var min = Math.min(m, n)
	return Math.floor(Math.random() * (max - min) + min)
}
function mhy(){
            var str = 'jt编程实现学生表格显示'
            var count = 0
            for(var i = 0; i < str.length ;i++){
                if(str.charCodeAt(i) > 255){
                    count += 2
                }
                else{
                    count += 1
                }
            }
            console.log('字符串长度为：',count)
        }
        mhy()