一.弹窗和输出
**javascript执行顺序是从上到下执行**1.控制浏览器弹出一个警告框
alert('HelloWord');2.让计算机在页面中输出一个内容在 document中写一个内容 （write写）
document.write(); 可以向body中输出一个内容
document.write('看我出不出来···');3.向控制台输出一个内容
console.log(); 作用是向控制台输出一个内容
console.log('你猜我在哪出来');
二 .js编写位置
1.可以将js代码编写到外部js文件中，然后通过script标签引入
写到外部文件中可以在不同的页面中同时引用，也可以利用到浏览器的缓存机制
推荐使用方法
2.script标签一旦用于引入外部文 件了，内部就不能再编写代码了，即使编写了
浏览器也会忽略
如果需要可以在创建一个新的script标签用于编写内部代码
<script type="text/javascript" src="./jsweizhi.js"></script>
<script>
alert('我是内部js代码');
</script>
<script>
可以将js代码编写到script标签
alert('我是script标签中的代码')
</script> 3.可以将js代码编写到标签的onclick属性中
当我们点击按钮时，js代码才会执行
虽然可以写在标签的属性中，但是他们属于结构与行为耦合，不方便维护
<button onclick="(alert('讨厌，你点我干嘛'))">点我</button>
可以将js代码写在超链接的href属性中，这样当点击超链接时，会执行js代码
<a href="javascript:alert('让你点你就点');">你也点我一下</a>
<!--点了以后链接没有反应-->
<a href="javascript:;">你也点我一下</a>
三.基本语法
1.js注释（/**/）
多行注释，注释中的内容不会被执行，但是可以在源代码中查看
要养成良好的编写注释的习惯，也可以通过注释来对代码进行一些简单的调试
2.单行注释（//）
3.JS中严格区分大小写
4.JS中每一条语句以分号（;）结尾
-如果不写分号，浏览器会自动添加，但是会消耗一些系统资源
而且有点时候浏览器会加错分号5.JS中会忽略多个空格和换行，所以我们可以利用空格和换行对代码进行格式化
四.字面量和变量
1.字面量都是一些不可改变的值
比如：1 2 3 4 5
字面量都是可以的直接使用，但是我们一般都不会直接使用字面量变量 变量可以用来保存字面量，而且我们一般都不会直接使用字面量
变量更加方便我们使用，所以在开发中都是通过变量去保存一个字面量
而很少直接使用字面量
可以通过变量对字面量进行描述
变量 字面量
x = 1
2.把声明变量和对该变量赋值一次完成：
var mood(心情) = "happy"，age = "22";3.变量名允许包含字母、数字、美元符号和下划线（但第一个字符不允许是数字）。为了让比较长的变量名更容易阅读，可以在变量名中的适当位置插入下划线，就像这面这样：
var my_mood = "happy";
五、标识符
-在js中所有的可以由我们自主命名的都可以称为标识符
-例如：变量名，函数名，属性名都属于标识符
-命名一个标识符时需要遵守如下的规则：
1.标识符中可以含有字母、数字、_、$
2.标识符不能以数字开头
3.标识符不能是ES中的关键字或保留字
4.标识符一般都采用驼峰命名法
通常驼峰法格式是函数名、方法名和对象属性名命名的首选格式
-首字母小写，每个单词的开头字母大写，其余字母小写
helloworld 驼峰命名法:helloWorld
var myMood = "happy";
--注意：js底层保存标识符是实际上是采用的Unicode编码，
所以理论上讲，所有的utf-8中含有的内容都可以作为标识符
a标识符 自己起的名字
var a = 1;
可以含有字母、数字、_、$
var a_1_$ = 123;
console.log(a_1_$); //输出为123
标识符不能是ES中的关键字或保留字
ES
var var = 123;
console.log(var); //会报错
注意：
var 锄禾日当午 = 789; //千万不要这么用
console.log(锄禾日当午);
六、字符串
1.数据类型指的就是字面量的类型
在js中一共有六中数据类型
String 字符串 "123"
Number 数值 123
Boolean 布尔值 true或是false
Null 空值
Undefined 未定义
Object 对象 其中String Number Boolean Null Undefined 属于基本数据类型
而Object 属于引用数据类型
2.String字符串
1.-字符串由零个或多个字符构成，字符包括（但不限制）字母、数字、标点符号和空号
-在js中字串符需要使用引号引起来
-使用双引号或单引号都可以，但是不要混着用
-引号不能嵌套，双引号不能放双引号，单引号不能放单引号，
单引号里面可以放双引号，双引号里面可以放单引号
2.在字符串中我们可以使用\作为转义字符，
当表示一些特殊符号时可以使用\进行转义
\"\" 表示 ""
\'\' 表示 ''
\n 表示换行
\t 表示制表符（空格）
\\ 表示\
str ="我说:\"今天\n天气真不错\"";
str="\\"
//输出字面量 字符串str
alert("str");
//输出变量str
alert(str);
3.如果想在上面这条语句中使用单引号，就必须保证字母“n”和“t”之间的单引号能别当成这个字符串的一部分，这种情况下这个单引号需要被看做一个普通字符，而不是这个字符串的结束标志，这种情况我们需要对这个字符进行转义，在js里用反斜线对字符串进行转义：
var mood = 'don\'t ask';
4.类似地，如果想用双引号来包住一个本身就包含双引号的字符串，就必须用反斜线对字符串中的双引号进行转义：
var height = "about 5'10\" tall";
alert(height);会弹出下面：
七、Number
1.在js中所有的数值都是Number类型
如果想给一个变量赋一个数值，不用限定它必须是一个整数，js允许使用带点小数点的数值，并且允许任意位小数，这样的数称为浮点数
var age = 33.25;也可以使用负值，在有关数值的前面加上一个减号（-）表示它是一个负数：
var temperture = -20;js也支持负数浮点数
var temperture = -20.690;
包括整数和浮点数（小数）
//数字123
var a = 123;
//字符串123
var a = "123";
console.log(typeof a);
/*
* 可以使用一个运算符typeof
* 来检查一个变量的类型
* 语法：typeof 变量
* 检查数值时，会返回number
* 检查字符串时，会返回string
*/
2.js中可以表示的数字的最大值 (最大值:1.7976931348623157e+308)
Number.MAX_VALUE
1.7976931348623157e+308
Number.MIN_VALUE 大于0的最小值
5e-324 (0.后面的三百位数)
console.log(Number.MAX_VALUE); //会输1.7976931348623157e+308
a = Number.MAX_VALUE*Number.MAX_VALUE;
a = "abc" * "bcd" //会输出NaN
a = NaN; //不加引号 输出number 加了会输出string
a = Number.MIN_VALUE; //会输出Infinity
console.log(a);
3.如果使用Number表示的数字超过了最大值，则会返回一个Infinity
Infinity 表示正无穷
-Infinity 表示正无穷
使用typeof检查Infinity也会返回Number NaN 是一个特殊的数字，表示Not A Number
使用typeof检查NaN也会返回Number
// 在js中整数的运算基本可以保证精确
var c = 1+1;
//如果使用js进行浮点运算，可能得到一个不精确的结果
//所以千万不要使用js进行对精确度要求比较高的运算
var c = 0.1 + 0.2;
console.log(c);
八、布尔值
Boolaen 布尔值
布尔值只有俩个，主要用来做逻辑判断
true -表示真
false -表示假
使用typeof检查一个布尔值时，会返回boolean
var bool = true;
console.log(typeof true);
九、Null和Undefined
1.Null类型的值只有一个，就是 Null
null这个值专门用来表示一个为空的对象
使用typeof检查一个null时，会返回object
2.Undefined（未定义）类型的值只有一个，就undefined
当声明一个变量，但是并不给变量赋值时，它的值就是undefined
使用typeof检查一个undefined时也会返回undefined
var a = null;
console.log(typeof a); //会输出object
var b;
console.log(b); //会输出undefined
十、强制类型转换-string
1.强制类型转换
- 指将一个数据类型强制转换为其他的数据类型
- 类型转换主要指，将其他的数据类型，转换为
String Number Boolean
-
将其他类型转换为String
方式一：- 调用被转换数据类型的toString()方法 - 该方法不会影响到原变量，它会将转换的结果返回
-但是要注意：null和 undefined这俩个值没有toString()方法
如果调用他们的方法会报错
var a = 123;
//调用a的toString()方法
//调用xxx的yyy()方法，就是xxx.yyy()
var a = a.toString();
console.log(a);
var a = true; //先写一个类型
// var a = a.toString(); //在写a.toString() 可以转
console.log(a);
a = null; //空值
// a = a.toString(); //不能转 会报错
console.log(a);
a = undefined;
// a = a.tostring(); //不能转 会报错
console.log(a);
方式二：
-调用 String()函数，并将转换的数据作为参数传递给函数
-使用String()函数做强制类型转换时
对于 Number 和 Boolean实际上调用的就是toString()方法
但是对于null 和 undefined就不会调用toString()方法
它会将（字面量）null直接转换为（字符串）"null"
它会将（字面量）undefined直接转换为（字符串）"undefined"
a = 123;
//调用tostring()函数，来将a转换为字符串 （转谁就把谁写在括号里面）
a = String(a); //S一定要大写
a = null;
a = String(a); //不会报错
a = undefined;
a = String(a); //不会报错
console.log(typeof a);
console.log(a);
十一、强制类型转换-Number
1.将其他的数据转换为Number
转换方法一：
使用Number()函数
-字符串-->（转换）数字
1.如果是纯数字的字符串，则直接将其转换为数字
2.如果字符串中有非数字的内容，则转换为NaN
3.如果字符串是一个空串或者是一个全是空格的字符串，则转换为0
-布尔（boolean）-->（转换）数字
true 转换为1
false 转换为0
-Null-->数字==0
-undefined-->数字==NaN
//转换方式一：
var a = "123";
//调用Number()函数来将a转换为Number类型
a = Number(a); //括号里面要写数值
a = true; //true的类型是boolean
a = Number(a); // 输出为1
a = false; //false的类型是boolean
a = Number(a); // 输出为0
a = null;
a = Number(a); // 输出为0
a = undefined;
a = Number(a); // 输出为NaN
转换方式二：
-这种方式专门用来对付字符串
-parseInt()把一个字符串转换为一个整数
-parseFloat() 把一个字符串转换为一个浮点
//转换方式二：
a = "123px";
//调用parseInt()函数将a转换为Number
/*
parseInt()可以将一个字符串中的有效的整数内容取出来，（px不是数字所以不读，就只剩下数字）
然后转换为Number
（如果第一个是英文字母 转换的就是NaN（包括点.也在内 .以后的东西也不读））
*/
a = parseInt(a);
/*
parseFloat()作用和parseInt()类似，不同的是它可以获得有效的小数
*/
a = '123.456px';
a = parseFloat(a); //输出123.456
/*
如果对非String使用parseInt()或parseFloat()
它会现将其转换为String然后再操作
*/
a = true;
// a = parseInt(a); // 输出为NaN
a = parseFloat(a);
console.log(typeof a);
console.log(a);
十二、其他进制的数字
1.在js当中，如果需要表示16进制的数字，则需要以0x开头
如果需要表示8进制的数字，则需要以0开头
如果需要表示2进制的数字，则需要以0b开头,但是不是所有的浏览器都支持
//16进制数字
a = 0xDD;
//8进制数字
a = 056;
//2进制数字
a = 0b10;
console.log(a);
var height = "about 5'10\" tall";
alert(height);
十三、转换为boolean
将其数据类型转换为boolean
一种方法：使用boolean()函数
-数字--->布尔
除了0和NaN，其余的都是true
-字符串--->布尔
除了空串，其余的都是true
-null和undefined都会转换为false
-对象也会转换为true
var a =123; //输出为true
a = -123; //输出为true
a = 0; //输出为fals
a = Infinity; //输出为true Infinity无穷
a = NaN; //输出为true
//调用Boolean()函数来将a转换为布尔值
a = Boolean(a);
a = "hello"; //本身输出为string
a = boolean(a); //加上boolean()以后输出为true
a = "flase";
a = boolean(a); //输出为true
a = "null";
a = boolean(a); //输出为flase
console.log(typeof a);
console.log(a);
十四、算数运算符
1.运算符也叫操作符
通过运算符可以对一个或多个值进行运算，并获取运算结果
比如：tupeof就是运算符，可以来获得一个值得类型
它会将该值的类型以字符串的形式返回
number string boolean underfined objuct2.算数运算符
当对非Number类型的值进行运算时，会将这些值转换为Number然后在运算
任何值和NaN做运算都得NaN
+
+可以对两个值进行加法运算，并将结果返回
如果对俩个字符串进行加法运算，则会做拼串
会将俩个字符串拼接为一个字符串，并返回
任何的值和字符串做加法运算，都会先转换为字符串，然后在和字符串做拼串的操作转成字符串
—
可以对两个值进行减法运算，并将结果返回
转成number
*
可以进行乘法运算
/
可以进行除法运算
%
%取模运算（取余数）
//加法例子：
var a = 123;
var result = typeof a;
console.log(typeof result); //输出为string
a + 1; //输出为123
result = a + 1; //输出为124
result = 35 + 35; //输出为70
result = true + 35; //输出为36
result = true + false; //输出为1 true为1 false为0
result = 2 + null; //输出为2 null为
result = 2 + NaN; //输出为NaN
result = "123" + "456"; //输出为123456 俩个字符串相加 数字连在一起
result = "锄禾日当午" //如果想把诗写的工整就这样写 也可以这样写"锄禾日当午，汗滴禾下土，谁知盘中餐，粒粒皆辛苦"
+"汗滴禾下土"+
"谁知盘中餐"+
"粒粒皆辛苦";
result = 123 + "hello"; //输出为123hello
//任何值和字符串相加都会转换为字符串，并做拼串操作
console.log(result);
//number转换为string
/*
我们可以利用这一点，来将一个任意的数据类型转换为string
我们只需要为任意的数据类型加一个""即可将其转换为string
这是一种隐式的类型转换，由浏览器自动完成，实际上它也是调用string()函数
*/
var c = 123;
c = c + "h";
console.log(typeof c);
console.log(c);
console.log("c = " +c); //输出为c=123h
//小练习
result = 1 + 2 + "3"; //输出为33 1+2=3 字符串相拼 33
console.log("result="+result); //输出为 result=33
result = "45" + 2 + 3; //输出为4523
console.log(result);
//减法例子：
result = 100 - 5; //输出为result =95
result = 100 - true; //输出为99 true为1
result = 100 - "1"; //输出为99 把"1"转换为number 1 相当于100-1
console.log("result = "+result);
//乘法例子
result = 2 * 2; //输出为result=4
result = 2 * "8"; //输出为result=16
result = 2 * undefined; //输出为result=NaN
result = 2 * null; //输出为result=0 null=0
console.log("result = "+result);
//除法例子
result = 4 / 2; //输出为result=2
result = 3 / 2; //输出为result=1.5
/*
任何值做- * / 运算时都会自动转换为Number
我们可以利用这一特点做隐式的类型转换
可以通过为一个值 —0 *1 /1 来将其转换为Number
*/
console.log("result = "+result);
var d = "123";
d = d - 1; //输出为122
console.log(typeof d);
console.log(d);
//%例子
result = 9 % 3; //9除以3 等于3余0 相除取余数 输出为0
result = 9 % 4; //9除以4 等于2余1 相除取余数 输出为1
console.log("result = "+result);
十五、一元运算符
一元运算符，只需要一个操作数
+ 正号
-正号不会对数字产生任何影响
— 负号
-负号可以对数字进行负号的取反
—对于非number类型的值
它会将先转换为number，然后再运算
可以对一个其他的数据类型使用+，来将其转换为number
它的原理和number()函数一样
var a = 123;
a = +a; //输出为123
a = -a; //输出为-123
console.log("a = "+a);
a = true; // 输出为boolean a = -1
a = -a; // 输出为number a = -1
a = "123"; // 输出为 a = 123 string
a = +a; // 输出为 a = 123 number
console.log("a = "+a);
console.log(typeof a);
var result = 1 + +"2" + 3; //输出为6 +"2"字符串2转换为number2 1+2+3=6
console.log("result = "+result);
十六、自增和自减
自增++
—通过自增可以使变量在自身的基础上增加1
—对于一个变量自增以后，原变量的值会立即自增1
—自增分为俩种：后++（a++），前++（++a）
无论是a++ 还是++a，都会立即使原变量的值自增1
不同的是a++ 和 ++a的值不同
a++的值等于原变量的值 (自增前的值)
++a的值等于新值 (自增后的值)
自增--
—通过自减可以使变量在自身的基础上减1
—自减分为俩种:后--(a--) 和 前--(--a)
无论是a--还是--a都会使原变量的值自减1
不同的是a-- 和 --a的值不同
a--的值等于原变量的值 (自增前的值)
--a的值等于新值 (自增后的值)
//自增例子
var a = 1;
//使a自增1
a++; //输出为a=2
++a; //输出为a=2
console.log("a = "+a);
var a = 1;
console.log(a++); //输出为1
var a = 1;
console.log(++a); //输出为2
var a = 1;
console.log("++a = "+ ++a); //输出为++a=2
console.log("a++ = "+ a++); //输出为++a=1
console.log("a = "+a); //输出为a=2
var c = 10;
//第一次c++ 是在10的基础上自增
c++;
//第二次c++ 是在11的基础上自增
c++;
console.log(c++);
var d = 20;
console.log(++d); //输出为21
console.log(++d); //输出为22
//d++先用后加 ++d先加后用
//d++=20 ++d=22 d=22
var d = 20;
var result = d++ + ++d + d;
console.log("result ="+result); //输出为result =64
var d = 30;
var result = ++d + d++ + d;
//31 32 31
console.log("result ="+result); //输出为result =94
var d = 30;
d = d++;
/*
相当于
d=30
var e = d++;
d = e
*/
console.log("d ="+d); //输出为d =30
//自减例子
var num = 10;
num--; //输出为num=9
--num; //输出为num=9
console.log("num ="+num);
var num = 10;
console.log(num--); //输出为10
console.log(--num); //输出为9
var d = 10;
result = num-- + --num + d;
console.log("result ="+result); //输出为24
十七、自增练习
//d++先用后加 ++d先加后用
var n1 = 10 , n2 = 20;
var n = n1++; //n1 = 11 n1++ = 10
console.log('n='+n); //n=10
console.log('n1='+n1); //n1=11
n = ++n1; //n1=12 ++n1=12
console.log('n='+n); //n=12
console.log('n1='+n1); //n1=12
//d--先减后用 --d返回原值
n = n2--; //n2=19 n2--=20
console.log('n='+n); //n= 20
console.log('n12='+n2); //n2=19
n = --n2; //n2=18 --n2=18
console.log('n='+n); //n=18
console.log('n12='+n2); //n2=18
十八、逻辑运算符
JS中为我们提供了三种逻辑运算法
! 非
— !可以用来对一个值进行非运算
— 所谓非运算就是值对一个布尔值进行取反操作
flas变etrue ， true变flase
— 如果对一个值进行俩次取反，它不会变化
— 如果对非布尔值进行元素，则会将其转换为布尔值，然后在取反
所以我们可以利用该特点，来将一个其他的数据类型转换为布尔值
可以为一个任意数据类型去俩次反，来将其转换为布尔值
原理和boolean()函数一样
$$ 与
— &&可以对符号俩侧的值进行与运算并返回结果
— 运算规则：
— 俩个值中只要有一个值是flase就返回flase
只有俩个值都是true时，才会返回true
— js中的“与”属于短路的与
如果第一个值为flase，则不会看第二个值
|| 或
— ||可以对符号俩侧的值进行或运算并返回结果
— 运算规则：
— 俩个值中只有一个true，就返回true
如果俩个值都是flase，才返回flase
—js中的“或”属于短路的或
如果对一个值为true，则不会检查第二个值
// !
var a = true;
//对a进行非运算
!a; //输出为true
a = !a; //输出为flase 取反一次是flase
a = !!a; // 取反二次是flase
console.log("a ="+a);
var b = 10; //输出为number
b = !b; //输出为boolean b=false
b = !!b; //输出为boolean b=true
console.log("b ="+b);
console.log(typeof b);
// &&
//如果俩个值都是true则返回true
var result = true && true; // 输出为true
//只要有一个false就返回false
var result = true && false; //输出为false
var result = false && true; //输出为false
var result = false && false; //输出为false
console.log("result ="+result);
//第一个值为true，会检查第二个值
// true && alert("看我出不出来!!");
//第一个值为false，不会检查第二个值
// false && alert("看我出不出来!!");
// ||
//如果俩个值都是false则返回false
resule = false || false; //输出为false
//只要有一个true就返回true
resule = true || false; //输出为true
resule = false || true; //输出为true
resule = true || true; //输出为true
console.log("resule ="+resule);
//第一个值为false，则会检查第二个值
false || alert("123"); //会有弹窗
//第一个值为true，则不会检查第二个值
true || alert("123"); //不会有弹窗
十九、非布尔值的非与或运算
&& || 非布尔值的情况
— 对于非布尔值进行与或运算时
会向将其转换为布尔值，然后在运算，并且返回原值
— 与运算&&
— 如果第一个值为true，则必然返回第二个值
— 如果第一个值为false，则直接返回第一个值
— 或运算 ||
— 如果第一个值为true，则直接返回第一个值
— 如果第一个值为false，则返回第二个值
// true && true
// 与运算：如果俩个值都为true，则返回后边的值
var result = 1 && 2; //输出为2
//与运算：如果俩个值中有false，则返回靠前的false
//false && true
var result = 0 && 2; //输出为0
var result = 2 && 0; //输出为0
//false && false
var result = NaN && 0; //输出为NaN
var result = 0 && NaN; //输出为0
// true || true
//如果第一个值为true，则直接返回第一个值
result = 1 || 2; //输出为1
result = 2 || 1; //输出为2
result = 2 || NaN; //输出为2
//如果第一个值为false，则直接返回第二个值
result = NaN || 1; //输出为1
result = NaN || 0; //输出为0
result = "" || "hello"; //输出为hello
result = -1 || "你好"; //输出为-1
console.log("result ="+result);
二十、赋值运算符
=
可以将符号右侧的值赋值给符号左侧的变量
var a = 123; +=
a += 5 等价于 a = a + 5
a -= 5 等价于 a = a - 5
*=
a = 5 等价于 a = a 5
/=
a /= 5 等价于 a = a / 5
%= (余数)
a %= 5 等价于 a = a % 5
var a = 10;
a = a + 5; //15
a += 5; //输出为15 和a = a + 5;是一样的
a -= 5; //输出为5 10-5=5
a *= 5;//输出为50 5*10=50
a %= 3; //输出为1 10除以3等于3余1
console.log("10 ="+10);
二十一、关系运算符
关系运算符
通过关系运算符可以比较俩个值之间的大小关系
如果关系成立它会返回true,如果关系不成立则返回false
大于号
— 判断符号左侧的值是否大于右侧
— 如果关系成立，返回 true，如果关系成立则返回 false
= 大于等于
— 判断符号左侧的值是否大于或等于右侧的值
< 小于号
— 判断符号左侧的值是否小于右侧
— 如果关系成立，返回 true，如果关系成立则返回 false<= 小于等于号
— 判断符号左侧的值是否小于或等于右侧的值
非数值的情况
—对于非数值进行比较时，会将其转换为数字然后在比较
— 特殊情况：
如果符号俩侧的值都是字符串时，不会将其转换为数字进行比较
而会分别比较字符串中字符的Unicode编码
var result = 5 > 10; //输出为false 不成立
result = 5 > 4; //输出为true 成立
resulr = 5 > 5; //输出为false 不成立
resulr = 5 >= 5; //输出为true 成立
result = 5 >= 4; //输出为true 成立
result = 5 < 4; //输出为false不成立
resulr = 4 <= 4; //输出为true 成立
console.log("result ="+result);
//非数值的情况
console.log(1>true); //false
console.log(1>true); //true
console.log(1 > "0"); //true
console.log(10 > null); //true null转换为数字0
//任何值和NaN做任何比较都是false
console.log(10 <= "hello"); //false "hello"转换为数字NaN
console.log(true > false); //
//如果比较的俩个字符串型的数字，可能会得到不可预期的结果
console.log("1" < "5"); //true
console.log("11" < "5"); //true(比较第一位 1和5做比较)
//注意：在比较俩个字符串型的数字时，一定一定一定要转型
console.log("11" < +"5"); //false
//比较俩个字符串时，比较的是字符串的字符编码
console.log("a" < "b"); //true
//比较字符编码时是一位一位的进行比较
console.log("abc" < "a"); //true
//如果俩位一样，则比较下一位，所以借用它来对英文进行排序
console.log("bbc" < "b"); //false
console.log("abd" < "bad") //true
//比较中文时没有意义
console.log("戒" > "我"); //true
二十二、Unicode编码表
<script type="text/javascript">
//使用十六进制计算器
/*
在字符串中使用转义字符输入Unicode编码表
\u四位编码
*/
console.log("\u0031"); //输出为1
console.log("\u2620"); //输出为骷髅头
</script>
</head>
<body>
<!--
在网页中使用Unicode编码表
&#编码;这里的编码需要的是10进制
-->
<!-- 2620是16进制 -->
<!-- 骷髅头 -->
<h1 style="font-size: 200px;">☠</h1>
<!-- 筛子 -->
<h1 style="font-size: 200px;">⚀</h1>
</body>
二十三、相等运算符
相等运算==：
相等运算符用来比较俩个值是否相等
如果相等会返回true，否则会返回false
使用==来做相等运算
—当使用==来比较俩个值时，如果值的类型不同
则会自动进行类型转换，将其转换为相同的类型
然后再比较
不相等运算!=：
不相等用来判断俩个值是否不相等，如果不相等返回true，否则返回false
— 使用!=来做不相等运算
— 不相等也会对变量进行自动的类型转换，如果转换后相等也会返回false
全等运算===：
— 用来判断俩个值是否全等，它和相等类似，不同的是它不会做自动的类型转换
如果来个值得类型不同,直接返回false
不全等!==
— 用来判断俩个值是否不全等，和不等类似，不同的是它不会做自动类型转换
如果来个值得类型不同,直接返回true
//相等运算==
console.log(1 == 1); //输出为true
var a = 10;
console.log(a == 4); //输出为false 10不等于4
console.log("1" == 1); //输出为true 字符串1和数字1相等
console.log(true == "1"); //输出为true
console.log(true == "hello"); //输出为false
console.log(null == 0); //输出为false
console.log(nill == undefined); //输出为true
/*
undefined 衍生自 null
所以这俩个值做相等判断时，会返回true
*/
console.log(unsefined == null); //输出为true
/*
NaN不和任何值相等 包括他本身
*/
console.log(NaN == "1"); //输出为false
var b = NaN;
//NaN不和任何值相等 所以下面的这个方法行不通
// console.log(b == NaN); 输出为false
/*
可以通过isNaN()函数来判断一个值是否是NaN
如果该值是NaN则返回true，否则会返回false
*/
console.log(isNaN(b)); //输出为true
//不相等运算!=
console.log(10 != 5); //输出为true
console.log(10 != 10); //输出为false
console.log("abcd" != "abcd"); //输出为false
console.log("1" != 1); ////输出为false
//全等运算===
console.log("123" === 123); //输出为false
console.log(nill === undefined); //输出为false
//不全等!==
console.log(1 !== "1"); //输出为true
二十四、条件运算符
条件运算符也叫三元运算符
语法：
条件表达式?语句1:语句2;
— 执行的流程：
条件运算符在执行时，首先对条件表达式进行求值，
如果该值为true，则执行语句1，并返回执行结果
如果该值为false，则执行语句2，并返回执行结果
如果条件的表达式的求值结果是一个非布尔值，
会将其转换为布尔值然后在运算
二十五、运算符的优先级
，运算符
使用，可以分割多个语句，一般可以在声明多个变量时使用
//使用，运算符同时声明多个变量
// var a , b ,c;
//可以声明多个变量并赋值
var a=1,b=2,c=3;
alert(b); //弹窗为2
就和数学中一样，在js运算符也有优先级
比如：先乘除 后加减
在js中有一个运算符优先级的表
在表中越靠上优先级越高，优先级越高越优先计算
如果优先级一样，则从左往右计算
但是这个表我们不需要记忆，如果遇到优先级不清楚
可以使用()来改变
var result = 1 + 2 * 3;
console.log("result ="+result); //输出为7
如果||的优先级高，或者俩个一样高，则应该返回3
如果与的优先级高，则应该返回1
var result = 1 || 2 && 3;
console.log("result ="+result); //输出为1
二十六、代码块
我们的语句是由一条一条语句构成的
语句是按照自上向下的顺序一条一条执行的
在js中可以使用{}来为语句进行分组
同在一个{}中的语句我们称为是一组语句
它们要么执行，要么都不执行
一个{}中的语句我们也称为代码块
在代码块的后面不用在编写;了
js中的代码块，只具有分组的作用，没有其他的用途
代码块内部的内容，在外部是完全可见的
{
alert("hello");
console.log("你好");
document.write("语句");
}
console.log("a ="+a); //可以执行二十七、if语句（一）
流程控制语句:
— js中的程序是从上到下一行一行执行的
— 通过流程控制语句可以控制程序执行流程
使流程可以根据一定的条件来选择执行
— 语句分类：
1.条件判断语句
2.条件分支语句
3.循环语句
1.条件判断语句：
— 使用条件判断语句可以在执行某个语句之前进行判断
如果条件成立才会执行语句，条件不成立则语句不会执行
— if语句
— 语法一：
if（条件表达式）{
语句....
}
if语句在执行时，会先对条件表达式进行求值判断
如果条件表达式的值为true，则执行if后的语句
如果条件表达式的值为false，则不会执行if后的语句
if语句只能控制紧随其后的那个语句
如果希望if语句可以控制多条语句
可以将这些语句统一放到代码块中{}
if语句后的代码块不是必须的，但是在开发中尽量写上代码块，即使if后只有一条语句
if(true) alert("你猜我出来吗");
//条件成立都执行
var a = 11;
if(a > 10)
{
alert("a比1大~~~");
alert("谁也管不了我");
}
var a = 15;
if(a > 10 && a <= 20)
{
alert("a大于10，并且a小于等于20"); //成立
}
二十八、if语句（二）
if语句
语法二：
if（条件语句）{
语句.....
} elae{
语句.....
}
if...else...语句...
当该语句执行时，会先对if后的条件表达式进行求值判断
如果该值为true,则执行if后的语句
如果该值为false，则执行else后的语句
语句三：
if(条件语句){
语句....
}else if(条件语句){
语句....
}else if(条件语句){
语句....
}elae{
语句.....
}
if...else if...else
当该语句执行时，会从上到下依次对条件表达式进行求值判断
如果该值为true,则执行当前语句
如果该值为false，则继续向下判断
如果所有的条件都不满足，则执行最后一个else后的语句
该语句中，只会
//方法一
var age = 60;
if(age >= 60){
alert("你已经退休了");
}
else{
alert("你还没有退休");
}
//方法二
var age = 90;
if(age > 100 && age <= 30){
alert("活着挺没意思");
}else if(age > 80){
alert("你也老大不小了");
}else if(age > 60){
alert("你也退休了");
}else if(age > 30){
alert("你已经中年了");
}else if(age > 17){
alert("你已经成年了");
}else{
alert("你还是个孩子");
}
二十九、if练习（一）
从键盘输入小明的期末成绩
当成绩为100时，奖励一俩BMW
当成绩为[80-99]时，奖励一台iphone15s
当成绩为[60-80]时，奖励一本参考书
其他时，什么奖励也没有
prompt()可以弹出一个提示框，该提示框中会带有一个文本框
用户可以在文本框中输入一段内容，该函数需要一个字符串作为参数
该字符串将会作为提示框的提示文字
用户输入的内容将会作为函数的返回值返回，可以定义一个变量来接收该内容
//score就是小明的期末成绩
var score = prompt("请输入小明的期末成绩（0-100）：");
//判断值是否合法 (大于100 或则 小于0 或则 不是数字 都要拉出去毙了 )
if(score > 100 || score < 0 || isNaN(score)){
alert("拉出去毙了");}
else{
//根据score的值来决定小明什么奖励
if(score == 100){
alert("奖励一俩BMW");
}
else if(score >= 80){
alert("奖励一台iphone15s");
}
else if(score >= 60){
alert("奖励一本参考书");
}
else{
alert("什么奖励也没有");
}}
三十、if练习（二）
/*
大家都知道，男大当婚女大当嫁，那么女方家长要嫁女儿，当然要提出一定的条件
高：180cm以上， 富1000万以上， 帅500以上
如果三个条件同事满足，则'我一定要嫁给你'
如果三个条件有为真的情况，则：'嫁吧，比上不足，比下有余'
如果三个条件都不满足，则：'不嫁'
*/
var height = prompt("请输入你的身高（cm）:");
var money = prompt("请输入你的财富（万）:");
var face = prompt("请输入你的颜值（px）:");
// alert(height+","+money+","+face);
//如果三个条件同事满足，则'我一定要嫁给你'（同时满足用于&&）
if(height > 180 && money > 1000 && face > 500){
alert("我一定要嫁给你");
}else if(height > 180 || money > 1000 || face > 500){
//如果三个条件有为真的情况(有一个满足用或||)，则：'嫁吧，比上不足，比下有余'
alert("嫁吧，比上不足，比下有余");
}else{
alert("不嫁");
}
三十一、if练习（三）
编写程序，由键盘输入三个整数分别存入变量num1，num2，num3
对他们进行排序，并且从小到大输出
//获取用户的三个数
//prompt()函数的返回值是string类型的
//在prompt前加+转换为number
var num1 = +prompt("请输入第一个数");
var num2 = +prompt("请输入第二个数");
var num3 = +prompt("请输入第三个数");
alert(typeof num1);
if(num1 < num2 && num1 < num3){
//num1最小 比较num2 和 num3
if(num2 < num3){
//num1 num2 num3
alert(num1+","+num2+","+num3);
}else{
//num1 num3 num2
alert(num1+","+num3+","+num2);
}
}else if(num2 < num1 && num2 < num3){
//num2最小 比较num1 和num3
if(num1 < num3){
//num2 num1 num3
alert(num2+","+num1+","+num3);
}else{
//num2 num3 num1
alert(num2+","+num3+","+num1);
}
}else{
//num3最小 比较num1 和num2
if(num1 < num2){
//num3 num1 num2
alert(num3+","+num1+","+num2);
}else{
//num3 num2 num1
alert(num3+","+num2+","+num1);
}
}
三十二、条件分支语句
条件分支语句也叫switch语句
语法：
switch(条件表达式){
case 表达式：
语句...
break;
case 表达式：
语句...
break;
case 表达式：
语句...
break;
defsult:
语句...
}
执行流程：
switch...case...语句
在执行时会依次将case后的表达式的值和switch后的条件表达式的值进行全等比较
如果比较结果为true，则从当前case处开始执行代码
当前case后的所有代码都会被执行，我们可以在case的后面跟着一个break关键字
这样可以确保只会执行当前case后的语句，而不会执行其他的case
如果比较结果为false，则继续向下比较
如果所有的比较结果都为false，则只执行default后的语句
switch语句和if语句的功能实际上有重复的，使用switch可以实现if的功能
同样使用if也可以实现switch的功能，所以我们使用时，可以根据自己的习惯选择
//根据num的值，输出对应的中文
var num = abc;
/*
if(num == 1){
console.log("壹");
}else if(num == 2){
console.log("贰");
}
*/
// 这俩中方法差不多
switch(num){
case 1:
console.log("壹");
//使用break可以来退出switch语句
break;
case 2:
console.log("贰");
break;
case 3:
console.log("叁");
break;
default :
console.log("非法数字");
break;
}
三十二、条件分支语句练习（二）
从键盘接收整数参数，如果该数为1-7，打印对应的星期，否则打印非法参数
var week = 2;
switch(week){
case 1:
console.log("星期一");
//使用break可以来退出switch语句
break;
case 2:
console.log("星期二");
break;
case 3:
console.log("星期三");
break;
default :
console.log("非法数字");
break;
}三十二、条件分支语句练习（一）
对于成绩大于60分的，输出'合格'。低于60分的，输出'不合格'
//方法一：
var socre = 59;
switch(parseInt(socre/10)){
case 10:
case 9:
case 8:
case 7:
case 6:
console.log("合格");
break;
default:
console.log("不合格");
break;
}//方法二：
var socre = 59;
switch(true){
case score >= 60:
console.log("合格");
break;
default:
console.log("不合格");
break;
}
三十三、while循环
/*
向页面中输出连续的数字
*/
// var n = 1;
// document.write(n++ +"<br />"); //输出1
/*
循环语句：
通过循环语句可以反复的执行一段代码多次
while循环
-语法
while（条件表达式）{
语句...
}
-while语句在执行时，
先对条件表达式进行求值判断
如果值为true,则执行循环体
循环体执行完毕后，继续对表达式进行判断
如果为true，则继续执行循环体，以此类推
如果值为flash，则终止循环
do...while循环
- 语法
do{
语句...
}while(条件表达式)
- 执行流程：
do...while语句在执行时，会先执行循环体
循环体执行完毕以后，在对while后的条件表达式进行判断
如果结果为true,则继续执行循环体，执行完毕继续判断以此类推
如果结果为false,则终止循环
实际上这俩个语句功能类似，不同的是while是先判断后执行
而do...while会先执行后判断
do...while可以保证循环体至少执行一次
而while不能
*/
// 方法一
//向这种将条件表达式写死为true的循环，叫做死循环
//该循环不会停止，除非浏览器关闭，死循环在开发中慎用
//可以使用break，来终止循环
var n = 1;
while(true){
alert(n++);
//判断n是否是10
if(n == 10){
//退出循环
break;
}
}
//方法二
//创建一个循环，往往需要三个步骤
// 1.创建一个初始化的变量
var i = 0;
//2.在循环中设置一个条件表达式
while(i < 10){
alert(i);
//3.定义一个更新表达式，每次更新初始化变量
i++;
}
//方法三
var i = 0;
while(i < 10){
document.write(i++ +"<br />");
} // 输出为换行的数字
//方法四
do{
socument.write(i++ +"<br />");
}while(i < 10);
三十四、while循环练习
/*
假如投资的几年利率为5%，试求从1000块增长到5000块，需要花费多少年
1000 1000*1.05
1050 1050*1.05
*/
//定义一个变量，表示当前的钱数 (代码解析)
var money = 1000;
//定义一个计数器
var count = 0;
//定义一个while循环来计算每年的钱数
while(money < 5000){
money *= 1.05;
//使用count自增
count++;
}
console.log("一共需要"+count+"年");
// money *= 1.05 //money = money * 1.05 它俩一个意思
var money = 1000;
var count = 0;
while(money < 5000){
money *= 1.05;
count++;
}
console.log("一共需要"+count+"年");
三十五、while练习（一） 使用if练习一
//将prompt放入到一个循环中
while(true){
//score就是小明的期末成绩
var score = prompt("请输入小明的期末成绩（0-100）：");
//判断用户输入的值是否合法
if(score >= 0 && score <= 100){
//满足该条件则证明用户的输入合法，退出循环
break;
}
alert("请输入有效的分数");}
//根据score的值来决定小明什么奖励
if(score == 100){
alert("奖励一俩BMW");
}
else if(score >= 80){
alert("奖励一台iphone15s");
}
else if(score >= 60){
alert("奖励一本参考书");
}
else{
alert("什么奖励也没有");
}
三十六、for循环
for语句，也是一个循环语句，也称为for循环
在for循环中，为我们提供了专门的位置用来放三个表达式：
1.初始化表达式
2.条件表达式
3.更新表达式
for（初始化表达式;条件表达式;更新表达式）{
语句...
}
for循环的执行流程：
1.执行初始化表达式，初始化变量（初始化表达式只能则执行一次）
2.执行条件表达式，判断是复执行循环
3.如果为true，则执行循环
如果为false,则终止循环
4.执行更新表达式，更新表达式执行完毕继续重复执行
//方法一：
//创建一个执行10次的while循环
//初始化表达式
var i = 0;
//
while(i < 10){
//设置更新表达式
alert(i++);
}
//方法二：
for(i = 0 ; i < 10 ; i++){
alert(i);
}
//方法三：
/*
for循环中的三个部分都可以省略，也可以写在外部
如果在for循环中不写任何表达式，只写俩个;
此时循环是一个死循环会一直执行下去，慎用
*/
var i = 0;
for(;i<10;){
alert(i++);
}
三十七、for循环练习（一）
打印1-100之间所有奇数之和
//创建一个变量，用来保存奇数之和
var sum = 0;
for(var i = 1 ; i <= 100 ; i++){
//判断i是否是奇数
//不能被2整除的数就是奇数(==是偶数 !=是奇数)
if(i%2 != 0){
//如果i除以2有余数则证明i是奇数
// console.log(i);
sum = sum + i;
}
}
//奇数总和2500
console.log("奇数之和:"+sum);
三十八、for循环练习（二）
打印1-100之间的所有7的倍数的个数及总和
//3.定义一个变量来保存组合
var sum = 0;
//5.定义一个计数器，来记录数量
var count = 0;
for(var i = 1 ; i <= 100 ; i++){
// console.log(i); （1.先打印出1到100）
//2.判断i是否是7的倍数（输出7的倍数）
if(i%7 == 0){
// console.log(i);
sum += i; //（4.求总和）
count++; //(5.使计数器自增1)
}
}
//输出总和
console.log("总和为："+sum); //合为735
//输出总数量
console.log("总数量："+count); //数量为14
三十九、for循环练习（三）
水仙花数
水仙花数是指一个3位数，它的每个位上的数字的3 次幂之和等于它本身
（例如： 1^3 + 5^3 + 3^3 = 153）,请打印所有的水仙花数
//先打印所有的三位数
for(var i = 100 ; i < 1000 ; i++){
//获取i的百位 十位 个位的数字
//获取百位数
var bai = parseInt(i/100);
//获取十位上的数字
var shi = parseInt((i-bai*100)/10);
//获取个位上的数字
var ge = i % 10;
//判断i是否是水仙花数
if(bai*bai*bai+shi*shi*shi+ge*ge*ge == i){
console.log(i); //输出的结果为153 370 371 407
}
}
四十、质数练习
在页面中接收一个用户输入的数字，并判断该数是否是质数
质数：只能被1和它自身整除的数，1不是质数也不是合数，质数必须是大于1的自然数
var num = prompt("请输入一个大于1的整数");
//判断这个值是否合法
if(num <= 1){
alert("该数值不合法");
}else{
//创建一个变量来保存当前的数的状态
//默认当前num是质数
var flag = true;
//判断num是否是质数
//获取2-num之间的数
for(var i=2;i<num;i++){
// console.log(i); //假如输出一个10 控制台显示23456789
//判断num是否能被i整除
if(num % i == 0){
//如果num能被整除，则说明num一定不是质数
alert(num+"不是质数");
//设置flag为false
flag = false;
}
}
//如果 num是质数则输出
if(flag){
alert(num + "是质数");
}else{
alert("这个不是质数");
}
}
四十一、嵌套的for循环
/*
通过程序，在页面中输出如下的图形
1
*****
*****
*****
*****
*****
2
* 1 <1 i=0
** 2 <2 i=1
*** 3 <3 i=2
**** 4 <4 i=3
***** 5 <5 i=4
3
***** 1 j<5(5-0) i=0
**** 2 j<4(5-1) i=1
*** 3 j<3(5-2) i=2
** 4 j<2(5-3) i=3
* 5 J<1(5-4) i=4
*/
/*
1
*****
*****
*****
*****
*****
*/
//向body中输出一个内容
//document.write("***** <br />"); (方法一)
//document.write("***** <br />");
//document.write("***** <br />");
//通过一个for循环来输出图形
//这个for循环执行几次，图形的高度就是多少
//它可以用来控制图形的高度
for (var i=0;i<5;i++){ //高
// document.write("***** <br />"); //方法二
//在循环的内部创建一个循环，用来控制图形的宽度
//目前我们的外部的for循环执行1次，内部的就会执行5次
//内层循环可以来决定图形的宽度，执行几次图从的宽度就是多少
for(var j=0;j<5;j++){ //宽
document.write("* "); // 空格
}
//输出一个换行
document.write("<br />");
//最终输出一个5*5的*矩形
}
/*2
*
**
***
****
*****
*/
for(var i=0;i<5;i++){
for(var j=0 ; j<i+1 ; j++){
document.write("* ");
}
document.write("<br />");
}
//最终输出一个梯形的*
/*
3
*****
****
***
**
*
*/
for(var i=0 ; i<5 ; i++){
for(var j=0 ; j<5-i ; j++){
document.write("* ");
}
document.write("<br />");
}
四十二、for循环练习(一)
1.打印99乘法表
//创建外层循环，用来控制乘法表的高度
for(var i=1; i<=9 ; i++){
//创建一个内层循环来控制图形的宽度
for(var j=1 ; j<=i ; j++){
document.write("<span>"+j+"*"+i+"="+i*j+"</span>");
}
//输出一个换行
document.write("<br />");
}
</script>
<style type="text/css">
/*
加span用来使每列每行对齐
给body加个滚动条
*/
body{
width:2000px;
}
span{
display:inline-block;
width:80px;
}
四十三、for循环练习（二）
打印出1-100之间所有的质数
1不是质数所以直接打印2-100的质数
//创建一个布尔值，用来保存结果，默认i是质数
var flag = true;
for(var i=2;i<=100;i++){ //先输出2-100的所有整数
//创建一个布尔值，用来保存结果，默认i是质数
var flag = true;
//判断i是否是质数
//获取到2-i之间的所有的数
for(var j=2 ; j<i ; j++){
//判断i是否能被j整除
if(i%j == 0){
//如果进去判断则证明i不是质数,修改flag值为false
flag = false;
break;
}
}
//如果是质数则打印i的值
if(flag){
console.log(i);
}
}
四十四、break和continue
break关键字可以用来退出switch或循环语句
不能在if语句中使用break和continue 会报错
break关键字，会立即终止离他最近的那个循环语句
/*
for(var i=0;i<5;i++){
console.log(i);
if(i == 2){
break; //输出为0 1 2
}
}
不能在if语句中使用break和continue 会报错
if(true){
break;
console.log("hello");
}
*/
/*
可以为循环语句创建一个lable,来标识当前的循环
lable语句：循环语句
使用break语句时，可以在break后跟着一个喇叭lable
这样break将会结束指定的循环，而不是最近的
*/
/*
//可以为循环语句创建一个lable（标签），来标识当前的循环
//lable:循环语句
outer:
for(var i=0 ; i<5 ; i++){
console.log("@外层循环"+i);
for(var j=0 ; j<5 ; j++){
break outer; //直接终止外层的循环
console.log("内层循环"+j);
}
}
*/
/*
continue关键字可以用来跳过档次循环
同样continue也是默认只会对离他最近的循环起作用
*/
/*
for(var i=0 ; i<5 ; i++){
if(i==2){
continue;//输出为0 1 3 4
}
console.log(i);
}
*/
for(var i=0 ; i<5 ; i++){
for(var j=0 ; j<5 ; j++) {
continue;
console.log("--->"+j);
}
console.log("@--->"+i);}
四十五、质数练习补充
//测试如下的程序的性能
//在程序执行前，开启计时器
//console.time("计时器的名字")可以用来开启一个计时器
//它需要一个字符串作为参数，这个字符串将会作为计时器的标识
console.time("test");
//打印2-100之间所有的数
for(var i=2;i<=100;i++){ //先输出2-100的所有整数
//创建一个布尔值，用来保存结果，默认i是质数
var flag = true;
//判断i是否是质数
//获取到2-i之间的所有的数
for(var j=2 ; j<=Math.aqrt(i) ; j++){
//判断i是否能被j整除
if(i%j == 0){
//如果进去判断则证明i不是质数,修改flag值为false
flag = false;
//一旦进入判断，则证明i不可能是质数了，此时循环在执行已经没有任何意义了
//使用break来结束循环
break;
//不加break 215ms
//加break 25ms
//修改j<=后 2.6ms
}
}
//如果是质数则打印i的值
if(flag){
// console.log(i);
}
}
//终止计时器
//console.timeEnd()用来停止一个计时器，需要一个计时器的名字作为参数
console.timeEnd("test");
/*
36
1 36
2 18
3 12
4 9
6 6
*/
//可以通过Math.sqrt()对一个数进行开方 （可以进行优化）
var result = Math.sqrt(4);
console.log("result ="+result); //输出为result=2
四十六、对象的简介
/*
JS中数据类型
- String 字符串
- Number 数值
- Boolean 布尔值
- Null 空值
- Underfined 未定义
- 以上五种类型属于基本数据类型，以后我们看到的值
只要不是上边的5种，全都是对象
-Object 对象
基本数据类型都是单一的值"hello" 123 true
值和值之间没有任何的联系
在JS中来表示一个人的信息(name gender age)
var name = "孙悟空";
var gender = "男";
var age = 18;
如果使用基本数据类型的数据，我们所创建的变量都是独立，不能成为一个整体
对象属于一种复合的数据类型，在对象中可以保存多个不同数据类型的属性
对象的分类：
1.内建对象
- 由ES标准中定义的对象，在任何的ES的实现中都可以使用
- 比如：Math String Number Boolean Function Object...
2.宿主对象
- 由JS的运行环境提供的对象，目前来讲主要指由浏览器提供的对象
- 比如 BOM DOM
console.log();
document.write();
3.自定义对象
- 由开发人员自己创建对象
*/
//创建对象
/*
使用new关键字调用函数()，是构造函数constructor(new后面的英文首字母大写)
构造函数是专门用来创建对象的函数
使用typeof检查一个对象时，会返回object
*/
var obj = new Object();
// console.log(typeof obj); //类型为object
/*
在对象中保存的值称为属性
向对象添加属性
对象.属性名=属性值;
*/
//向obj中添加一个name属性
obj.name = "孙悟空";
//向obj中添加一个gender属性
obj.grnder = "男";
//向obj中添加一个age属性
obj.age = 18;
/*
读取对象中的属性
语法：对象，属性名
如果读取对象中没有属性，不会报错而是会返回underfined
*/
console.log(obj.grnder); //想读谁就.谁
console.log(obj.hello); //返回underfined
/*
修改对象的属性值
语法：对象.属性名 = 新值
*/
obj.name = "tom";
/*
删除对象的属性
语法：delete 对象.属性名
*/
delete obj.name; //返回underfined
console.log(obj.name); //将孙悟空改为tom
四十七、属性名和属性值
// var obj = new.object();
/*
向对象中添加属性
属性名：
- 对象的属性名不强制要求遵守标识符的规范
什么乱七八糟的名字都可以使用
- 但是我们使用还是尽量按照标识符的规范去做
*/
/* obj.name = "孙悟空";
obj.var = "hello";
console.log(var);
*/
/*
如果要使用特殊的属性名，不能采用.的方式来操作
需要使用另一种方式：
语法：对象["属性名"] = 属性值
读取时也需要采用这种方式
var obj.123 = 789; 不可以这样写
使用[]这种形式操作方法，更加灵活
在[]中可以直接传递一个变量，这样变量值是多少就会读取那个属性
obj["123"] = 789;
obj["nihao"] = 你好
var n = "nihao"; 输出为你好
var n = "123"; 输出为789
console.log(obj[n]);
*/
/*
属性值
js对象的属性值，可以是任意的数据类型
甚至也可以是一个对象
obj.test = 123;
obj.test = true;
obj.test = null;
obj.test = undefined;
console.log(obj.test);
*/
//创建一个对象
var obj2 = new Object();
obj2.name = "猪八戒";
//将obj2设置为obj的属性
obj.test = obj2;
// console.log(obj.test.name);//输出为"猪八戒"
/*
in 运算符
- 通过该运算符可以检查一个对象中是否含有指定的属性
如果有则返回true,没有则返回false
- 语法：
"属性名" in 对象
*/
//检查obj中是否含有test属性
console.log("test2" in obj); //没有test2所以输出为false
console.log("test" in obj); //有test2所以输出为true
四十八、基本数据类型和引用数据类型
基本数据类型
String Number Boolean Null Underfined
引用数据类型
Object
js中的变量都是保存到栈内存中的
基本数据类型的值直接在栈内存中储存
值与值之间是独立存在，修改一个变量不会影响其他的变量
对象是保存到堆内存中的，没创建一个新的对象，就会在堆内存中开辟出一个新的空间
而变量保存的是对象的内存地址（对象的引用），如果俩个变量保存的是同一个对象引用
当一个通过一个变量修改属性时，另一个也会受到影响
var a = 123;
var b = a;
a++;
console.log("a ="+a); //a = 124
console.log("b ="+b); //b = 123 a自增了 b并没有自增
var obj = new Object();
obj.name = "孙悟空";
var obj2 = obj;
//修改obj的name属性
obj.name = "猪八戒";
// console.log(obj.name); //输出猪八戒
// console.log(obj2.name); //输出猪八戒
//设置obj为null
obj2 = null;
// console.log(obj); //输出为object object
// console.log(obj2); //输出为null
var c = 10;
var d = 10;
// console.log(c == d); //输出为true
var obj3 = new Object();
var obj4 = new Object();
obj3.name = "沙和尚";
obj4.name = "沙和尚";
/*
console.log(obj3); //输出为name="沙和尚"
console.log(obj4); //输出为name="沙和尚"
*/
/*
当比较俩个基本数据类型的值时，就是比较值
而比较俩个引用的数据类型，它是比较的是对象的内存地址
如果俩个对象是一模一样的，但是地址不同，它会返回false
*/
console.log(obj3 == obj4); //输出为false
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用。你还可以使用@来通知其他用户。