JavaScript基础 EcmaScript/04-02条件语句补充，初识引用值，typeof，类型转换（下）

JavaScript基础 EcmaScript/04-02-条件语句补充，初识引用值，typeof，类型转换（下）

本节课知识小结点：
条件判断语句 switch case
终止循环 break ; 必须放在循环里，放在循环外就会报错!!!**
终止本次循环，进行下次循环!continue

条件语句补充

1、条件判断语句 switch case
switch是条件，会和case里的值去比对，条件判断语句，符合哪条就执行哪条,下边的不看……

var n = 3;
switch(true) {
	case "a":
		console.log('a')
		break;
	case 2:
		console.log('b')
		break;
	case true:
		console.log('c')
		break;
}

1、里面的值可以不统一，
2、switch case执行语句及其不负责任，满足第一个，也会打印下边的，
3、消除不负责任，break 终止执行，
4、<>处理不了，=可以

<script>
    var date = window.prompt('输入周几');
    switch(date) {
        case "monday":
            console.log('working');
            break;
        case "tuesday":
            console.log('working');
            break;
        case "wednesday":
            console.log('working');
            break;
        case "thursday":
            console.log('working');
            break;
        case "friday":
            console.log('working');
            break;
        case "星期六":
            console.log('relaxing');
            break;
        case "星期天":
            console.log('relaxing');
            break;
    }
</script>

代码耦合程度非常高，重复太多，简化代码，自然下漏

<script>
    var date = window.prompt('输入周几');
    switch(date) {
        case "monday":
        case "tuesday":
        case "wednesday":
        case "thursday":
        case "friday":
            console.log('working');
            break;
        case "星期六":
        case "星期天":
            console.log('relaxing');
            break;
    }
</script>

2、终止循环 break
switch case也是循环语句，另两种是for循环和while循环

<script type="text/html">
    var i = 0;
    while(1) {
        i ++;
        console.log(i);
        if(i > 100){
            break;
        }
    }
</script>

break; 必须放在循环里，放在循环外就会报错!!!

<script>
        var i = 0;
        if(1 > 2){
            break;
        }
</script>

加到100终止程序……

for也可以用break终止
<script type="text/html">
    var i = 0;
    var sum = 0;
    for(var i = 0; i < 100; i ++){
        sum += i;
        console.log(i);
        if(sum > 100) {
            break;
        }
    }
</script>

3、终止本次循环，进行下次循环!continue
很有意思.有点继续的语法…… 用得不多！

<script>
    for(var i = 0; i < 100; i ++){
        if(i % 7 == 0 || i % 10 == 7){
            continue;
        }
        console.log(i);
    }
</script>

初识引用值

数组 估计有两节课专课数组……
数组-是存放很的东西的盒子

<script>
var arr = [1,2,3,45,5,7,"abc",undefined];
   console.log(arr[0])
    //打印数组第0位 取
arr[0] = 3;
//写入
console.log(arr[0])
    //把第0位赋值为3  写入
console.log(arr.length);
//arr.length 数组长度
    //打印数组的长度
for(var i = 0; i < arr.length; i ++) {
    console.log(arr[i]);
for(var i = 0; i < arr.length; i ++) {
    arr[i] += 1;
    console.log(arr[i]);
    //每一位加1赋给自身
}
</script>

对象估计有三节课专讲对象…………
面向对象的编程方式 例 对象定义的基本方式如样

<script>
var deng = {
	//key 属性名	    value 属性值  “值是重点”
	lastName:"Deng",
	age	: 40,
	sex: undefined,
	wife: "tangli",
	father: "dengFu",
	son: "xiaodeng",
	handsome: false,	
}
consonle.log(deng.lastName);
//取值方法：点儿，有点像的的意思
deng.lastName = “wang”
//赋值方式
</script>

编程形式的区别
解释性语言……编译性语言

面向过程……面向对象（从逻辑上的分法）
早期语言 如 C……（Jvav继承多态 封装） 对象调用方法
第一步，第二步

弱数据类型……强数据类型
脚本语言……非脚本语言

Javascript 既面向对象也面向过程
开始是面向过程的 后来倾向面向对象 现在又回归面向过程，

typeof操作符

typeof 转换成六种数据类型 作用于区分数据类型
number、string、boolean、……undefined、object、function（函数、方法）
前三个是最基本的值……

<script>
typeof() //括号里放数据
var num = 123;
console.log(typeof(num));   //反回number
//打印出
var num = "123";  //反回string
var num = "true"; //反回string
var num = true; //反回boolean
var num = 【】;  //反回object 不单指对象，泛指一种引用值
var num = null	
null原始值是1 反回object 浏览器遗留问题 null 最早作为代替空对象，给对象占位
var num = nudefined //反回"nudefined"
var num = function(){} //反回"function"
typeof()   typeof  num
//后边加括号…… 后边空格隔开  最加好括号
</script>

显示类型转换和隐示类型转换

<script>
var num = 1 + 1 ;// 2
var num = 1 + "1"; //2 number
consonle.log(typeof(num) + " : " + num);
var num = 1 + " 1 " ;// 0  number
var num = " 2 " -  " 1 " ;// 1  number
//javascript 独有的
</script>

显示类型转换
01、Number(mix)……括号里的东西转换成数字

var num = number("123"); 括号里的东西转换成数字  操作完后反回给num 
console.log(typeof(num) + " :" + num);  //number 123
var num = number(boolean); //number 1
var num = number(false); //number 0
number(unll); //number 0
number(undefined); //number NaN 最特殊的一个 
number(" a "); //number NaN  看起来不是数字的，都转不了数字
number(-123); //number -123
number("123abc"); //number NaN
</script>

02、parseInt(string,radix) radix=基底……括号里的东西转换成整数

A 转成整形
var num = parseInt("123abc"); 括号里的东西转换成数字  操作完后反回给num 
parseInt("123abc") //123 从数字位看到非数字位截止
parseInt(true) //NaN 不关注其他的，只看能不能转成整数
parseInt(nudefined、null)//NaN
parseInt(123.3)//123 后边的直接去
parseInt(“123.9”)//123 后边的直接去

B 转换成目标进制
parseInt(string,radix)以16进制为基底，把它转换为10进制 radix=基底   取值 2-36 0
var demo = " 10 ";
var num = parseInt(demo,16); //16   以16进制为基底，把它转换为10进制
var demo = " b ";
var num = parseInt(demo,16); //11
var demo = " 100px ";
var num = parseInt(demo,16); //100
</script>

03、parseFloat(string) 和parseInt 及其相似，没有parseInt那么复杂
将其转换成浮点类型的，正常数 ()
100.2……//100.2
100.2.3……// 100.2
100.2abc……//100.2

04、toString(radix)

<script>
A
var demo = 123; 
var num = demo.toString();
console.log(typeof(num) + " : " + num);
重要，有两个不能用toString 
01\undefined 用会报错，没有这个属性
02\null 也会抱错

B toString(radix) 以十进制为基底，转换成目标进制
var demo = 10;   //12
20  //16
var num = demo.toString(8);
console.log(typeof(num) + " : " + num); //12

问，将一个二进制的数转为16进制
parseInt  	 toString
	2-----10-----16
var num = 10101010;
var test = parseInt(num, 2);
console.log(test.toString(16));

</script>

05、string(mix)
致力于把其转换成字符串
undefined //“undefined”
06、Boolean
致力于把其转换成布尔值
“” //false

隐式类型转换 （隐式都是调用显示的方法）
01、inNaN()

isNaNa() 判断是不是NaN 并把结果返回
先把（）里的值用number转换，转换完了再和NaN比对
console.log(isNaN(NaN));
isNaNa(123); //false
isNaNa("123"); //false
isNaNa("abc"); //true
isNaNa(null); //false
isNaNa(undefined); //true

02、++ /-- +/-(一元正负运算)

var a = "123";
a ++; Number("123")  //124 number
+"abc";  Number("abc") NaN number
-a  Number("abc")也是调用number

03、+ ( 隐式调用string 只要+号一侧有"" 就会调用string)
04、- * / % (他们隐式也是调用的number)

“1” * 1 = 1 number,
"a" * 1 = NaN number,

05、&& || !
06、< > <= >=

1 > " 2 " // false boolean
"3" > "2" 比asq码
"3" > 2  // true 

07、== 等于 != 不等于

1 == "1"  //true bolean
1 == true  //true bolean

几个特别的例子

1 > 2  //false
false > true //false
2 > 1 > 3 //false
2 > 3 < 1 // true
10 > 100 > 0 // false
100 > 10 > 0 //true
undefined > 0 //false
undefined < 0 //false
undefined == 0 //false
null > 0 //false
null < 0 //false
null == 0 // false
undefined == unll  //true
NaN == NaN 这个最特殊，非数自己不等于自己，也不等于任何东东
===  绝对等于，!==绝对不等于，这种符号相比，不发生类型转换
NaN === NaN //false

var a = 123; 变量声明并赋值
a = 123 未经申明的变量就使用，会报错，
console.log(typeof(a)); 只有这种没声明的变量就使用，不报错//undefined
console.log(typeof(typeof(a)));//string  typeof(a) 先返回"unddfined" 是字符串的
typeof 返回的种值，都是字符串的""

作业小练习

alert(typeof(a)); // "unddfined"
alert(typeof((undefined)); //"unddfined"
alert(typeof(NaN)); //number
alert(typeof(unll)); //object
var a = "123ABC"; 
alert(typeof(+a)); //number
alert(typeof(!!a); //boolean
alert(typeof(a + "")); // string
alert(1 == "1"); // true
alert (NaN == NaN); // false
alert (NaN ==undefined); // false
alert("11" + 11); //"1111"
alert(1 === "1"); //false
alert(parseint("123abc")); //123
var num = 123123.345785; 
alert(num.toFixed(3)); //123123.346
typeof(typeof(a)); // string