js-操作符-条件分支语句-循环语句-对象object

一、操作符

1、算数操作符：

**= ：*赋值操作符 从右向左赋值
var a=10;
+ +=
- -=
** * =
/ /=
+:
a+b:
1、如果两个变量均为number类型，直接相加
2、如果两个变量均为非number类型，并且均不为string类型，也不为object类型
null undefined boolean
直接转换为number类型进行相加（Number())
3、如果其中一个值为string类型，另一个不为object类型，（null,undefined,string,boolean）,直接进行字符串拼接
4、如果其中一个值为object类型，
另一个值不为string类型：
10+{} ->10[object Object]
默认调用{}的toString()
另一个值为string类型：
“10”+{} =10[object Object]
如果只重写了toString():
调用toString()
如果只重写了valueof()
调用valueof
如果既重写了toString()又valueof():
valueof()

2、比较操作符（返回值为boolean)

> :
a>b:
num和num比较:->直接比较
非number和num比较：将非number转换为number进行比较
非number和非number比较：转换为number
string和string比较：比较字符编码
number和object比较：
默认情况下调用toString()
如果只重写了toString():调用toString()
如果只重写了valueof()调用valueof
如果既重写了toString()又valueof():valueof()
<
>=
<=
==:
undefined==undefined:true

			null==null:true
			
			undefined==null:true
			
			NaN==NaN:false
			
			先进行数值类型转换，再进行比较
			“10”==10：true

===
全等操作符
先进行数值类型的比较，数据类型相同，再比较值
如果数据类型不同，直接返回false
null===undefined:false

“10”===10:false

obj===obj:比较引用地址

3、逻辑操作符

1、&&：逻辑与

a&&b
转为boolean的结论：同真才真，有假则假
1、如果第一个数为false，“”，null、undfined、NaN能够转换为false的值，则返回第一个数
2、如果第一个数不返回，则返回第二个数

2、 ||逻辑或

结论：有真则真，同假才假
1、如果有第一个数为null/undefined/false/""/NaN->返回第二个数
2、如果第一个数不为上述值，返回第一个数

3、逻辑非

！null
1、将null转换为boolean
Boolean()
2、取反
结果一定为boolean类型
对一个变量，连用两次逻辑非，相当于当前变量转换为boolean类型
!!null:false

4、三目运算符

a>b?console.log(a):console.log(b)

表达式？成立：不成立
if（a>b){
//成立
}else{
//不成立
}

5、一元运算符

+：
+a:相当于调用了Number(a)
-：
++：
–：

6、位运算

js种32位2进制
原码->反码->补码
正数：原码=反码=补码
负数：
反码=原码的符号位不变，其他未取反
补码=反码+1

二、条件分支语句

if（表达式boolean）{
//true
}
…

if(a>b){
//true
}else{
//false
}

if(){
}else if(){
}else if(){
}else if(){
}else{
}

switch case
awitch(变量/表达式){
case key:
//break;
case key:
//break;
default:
如果写在第一行，一定要+break
}
break:跳出循环体
continue:跳出本次循环，继续下一次循环

三、循环语句

循环三要素：
初始条件；结束条件；迭代条件

1、前置条件循环语句

for(初始条件；结束条件；迭代条件）{
//循环体
}
死循环
for( ; ; ){}
label语句：
表示循环的名称
初始条件：
while（结束条件）{
循环体；
迭代条件；
}

2、后置条件循环语句

循环体至少执行一次
初始条件；
do{
//循环体
//迭代条件
}while（结束条件）

3、增强for循环

for in循环
主要用来循环对象

var obj={
name:'lisi',
age:20,
gender:'men'
}
for(var key in obj){
key:属性名
obj[key]:属性值
}

with(){}

var obj={
		name:'lisi',
		age:20,
		gender:'men'
}
console.log(obj.name);
console.log(obj.age);
console.log(obj.gender);

with(obj){
		console.log(name);//obj.name
		console.log(age);
}

四、对象

Object{}
一组属性和方法的集合

1、创建实例对象

1、>对象字面量

var obj={//new
name:‘lisi’,
age:20
}

2、>构造函数方式

var obj=new Object();
obj.name=‘lisi’;
obj.age=20;

2、访问属性

1、>点操作符

var obj={//new
name:‘lisi’,
age:20
}
obj.name=‘terry’;
console.log(obj.name);

2、>obj[“key”]

1、变量
2、obj{
name-first:‘lisi’
}
obj[‘name-first’]=‘lisi’;

3、删除属性

delete obj.name
delete obj[‘name’]

4、检测属性

in：
“name” in obj
继承属性或者私有属性：true
hasOwnProperty():
obj.hasOwnProperty(‘name’);
私有属性：true
继承属性：false

5、对象序列化

object->json:
JSON.stringify(obj)
json->object
JSON.parse(json)

6、方法

每一个函数都有一个构造者（constructor)
每一个函数都有一个原型对象（prototype)

静态方法：

	声明在函数内部，只能函数本身调用的方法
	assign(obj1,obj2):将对象合并到第一个对象参数中
	Object.assign(obj1,obj2);
	keys(obj):获取所有属性名
	values(obj):获取所有属性值
	definedProperty(obj,'key',{}):定义属性
	     1》
	         {   
	              value：20，
	              writable:是否可修改
	              enumerable:是否可遍历
	              configurable:是否可删除/配置
	            }
	         2》set/get方法
	              不能和第一种方式同时使用
	              {
	                    set:function(v){
	                         //设置过程
	                         this._age=v;
	                         },
	                         get:function(){
	                         //获取属性过程
	                         return this._age
	                         }
	                   }

var o={}
o.name=‘lisi’->set(lisi)
console.log(o.name);->get

非静态方法

声明在函数的原型对象中，函数原型对象和实例对象均可调用
constructor:
toString()
valueOf()

var obj={}
obj.nameOf()