1.数据类型
①数值类型（number）:123,10e10;
合法的数值范围：2；
十六进制：OX表示；
1e2=100=1x10x10；
最大值：Number.MAX_VALUE//某些浏览器是可以超过这个值的；
NaN:not a number;//非数字值是数字类型。
NaN === NaN//为false；//三个等号比较类型和值；
②布尔类型（bolean）:true,false;
③字符串类型（string）:‘dags2’;tostring()将其他类型转换成字符串；
var a = “sss"sssss”,//转义符："=>";
④未定义类型（undifined）:undifined;var m/m就是undefined;
当声明了一个变量但是没有赋值则为undefined；函数没有返回值的时候；
⑤null类型（本质上是一个特殊的object，object类型的一个值）;表示空对象。对象类型的一个值；
//null == undefined 为 true; null === undefined 为false因为数值类型不一样；
⑥object类型(引用类型)；
⑦function类型（函数类型）；
⑧获取变量的数据类型：typeof();
2.运算符
①如果一个操作数是NaN则结果是NaN；
②333*‘sss’得NaN；
③222*‘99’会先把’99’转换成99再进行相乘；
④Infinity0 =>NaN;Infinity非零数值得Infinity或-Infinity取决于有符号数的操作符号；
⑤InfinityInfinity =>Infinity;
⑥Infinity/Infinity=>NaN;
⑦0%任何数得0；Infinity % 0 = NaN;等
自增自减运算符：a = 1;++a后 a = 2,++a = 2;a++后 a = 2，a++ =1;
⑧条件运算符：语法：表达式1？表达式2：表达式3；1true返回2，false返回3；
3.运算符的优先级
第一级：（）；
第二级：a++，b–；
第三极：逻辑！，一元±，typeof；
第四级： / %
第五级：二元±；
第六级：< > >= <=;
第七级：&& ||；
第八级：？ ： 条件运算符；
第九级：赋值运算符 = += *= -= /= %=；
第十级：逗号；
练习:①var a = ‘1’,b = 3, c=true;
求下面的值：a>b:false;
a>=c:false,因为a转化为数字1，而c的f的ascii值为90+，所以c>a;
！b:flase;!!(b)：将b转换成boolen类型；
a+b :‘13’//优先字符串操作;b+c:4;//true转化成1；
b-a：2；b&&a:true;!(a||b):false;
②：var a = ‘1’,b=‘3’,c=‘true’;
求：a>b&&c<a:false；
+c:1;
++a+c:3;
++b+‘sss’:4sss;
6/0:infinity;
NaN0:NaN；//只要有NaN的都是NaN；
b>c?++a:c 得2；
4.显示类型的转换
转换为数值类型：Number（mix）//undefined返回NaN；
ParseInt(string,radix）//转换成整数;
parseFloat(String）//转换为字符串类型： String(mix);//a+" " == string(a);
Boolean(mix)//false,’’ ‘’ ,0,NaN,null,undefined,其余任何值都转换成true；
两次取反跟Boolean方法效果一致；var a = 3,b = 0,c = " ";
!!a:true;!!b:false;!!c:false;
5.隐式类型的转换：
就是当表达式进行运算时，如果类型不一致，JS引擎会自动根据规则把类型进行转换再进行运输.
6.循环分支语句
①if语句:
Math.random():随机返回0–1之间的小数；若想要得到一个随机数则可以：parseInt(Math.random()*10)//转换成整数;
//如果是字符串将其转化成数值类型并返回结果，否则直接把变量转化成boolean类型输出：var t = '1sss'; if(typeof(t) == "string"){ console.log(Number(t)); }else{ console.log(!!t) }
②while语句；
//计算1-100的和；
var n = 0;
var i = 1; // 循环的索引
while(i<=100){
n += i;
i++;
}
//输出10个（0--100）间的随机数
var t ;
var i = 0;
while(i<10){
t = parseInt(Math.random()*100);
console.log(t);
i++;
}
//实现1-10的阶乘
var m = 1;//阶乘的索引
var result = 1;//阶乘的结果
while(m<10){
result *= m;
m++
}
console.log(result);
③for循环
//输出十个0--100随机数
for(var i = 0;i<=10;i++){
console.log(Math.random()*100);
}
④for each:
let arr = ['a','b','c','d']
arr.forEach(function(val,idx,arr){
console.log(val+',index'+idx)//val是当前元素，index当前元素索引，arr数组
console.log(arr)
})a
⑤for in
伪循环enumerable对象而设计的；
可枚举性（enumerable）用来控制所描述的属性，（是否可以被遍历出来）是否将被包括在for…in循环之中。具体来说，如果一个属性的enumerable为false，下面三个操作不会取到该属性。
- for…in循环
- Object.keys方法
- JSON.stringify方法
let obj = {a:'1',b:'2',c:'3',d:'4'}
for(let o in obj){
// console.log(o);//遍历实际上是对象的属性名称abcd
console.log(obj[o]);//属性对应的值1，2，3，4
}
//for in
var t = {};
t.name = '123';
t.age = 19;
t.run = function(){
console.log('ss');
}
for(var k in t){
//k相当于属性的名字的变量
//第一次循环k相当于t变量的第一个属性名，以此类推；
console.log(k);
if(typeof(t[k]) == 'number'){
console.log(t[k]);
}
}
⑥for…of
let arr = ['china','america','korea']
for(let o of arr){
console.log(o)//china,america,korea;
}
不能循环一个普通对象，但可以循环一个拥有enumerable属性的对象；
按照对象拥有的属性进行循环，可以用内置的Object.values()方法；
let obj = {a: '1',b: '2',c:'3',d:'4' }
for(let o of Object.keys(obj)){
console.log(o)//a,b,c,d
}
如果我们按照对象所拥有的属性值进行循环，使用内置的Object.values()方法；
let obj = {a:'1',b:'2',c:'3',d:'4'}
for(let o of Object.values(obj)){
console.log(o);//1,2,3,4
}
循环一个字符串
let str = 'love'
for(let o of str){
console.log(o)//l,o,v,e
}
循环一个map
let iterable = new Map([["a",1],["b",2],["c",3]]);
for(let [key,value] of iterable){
console.log(value);//1 2 3
}
for(let entry of iterable){
console.log(entry);
}
//[a,1] [a,2] [c,3]
⑦with语句
7.创建对象
//对象字面量
var t = {
age:19,
run:function(){
console.log('嗯');
}
};
t.color = 'yellow';
console.log(t.age);
t.run();
△进程之间是相互隔离的，不相互影响，有些特殊情况可以进行相互干预；
线程是执行代码的最小单位，我们所有的代码都在线程里面执行；
线程的内存分为：栈内存（放简单数据类型、/数值类型，布尔类型，undefined），堆内存(对象类型，string是一个特殊引用类型)
；
8.构造函数及其原型
object原型属性和方法：
原型属性：toString（）；//转换成字符串；
toLocalString（）；//转化成本地化对应的字符串；
ValueOf（）；//获取他的值；
hasOwnProperty（）；//判断属性是否是自己添加的；
方法：
var cat = {
color:'red',
weight:20,
name:'karry',
ID:23,
run:function(){
console.log(this.name + '奔跑方法');
},
jump:function(){
}
};
//跑步方法的调用
cat.run();
//输出猫所有子定义属性；
for(var k in cat){
console.log(k);
}
//数学对象封装
var myMath = {
PI:3.1415926,
sum:function(n){
var result = 0;
//实现1--n的和
for(var i = 0;i<=n;i++){
result += i;
}
return result;
},
fatorial: function(n){
//求1--n的阶乘
var result = 1;
for(var i = 1;i<=n;i++){
result *= i;
}
return result;
}
};
console.log(myMath.PI);
console.log(myMath.sum(100));
console.log(myMath.fatorial(10));
9.Array类型
var arr = [1,2,4,"fd"];
console.log('length ='+ arr.length);
//遍历
for(var i = 0;i<arr.length;i++){
console.log(arr[i]);
}
for(var k in arr){
console.log(arr[k]);
}
注意：从原型上继承来的属性也会被for in遍历，所以如果需要去掉这一部分属性，可以通过hasOwnProperty（）进行过滤；
for(var k in t){
if(t.hasOwnProperty(k)){
console.log(k);
}
}
//或者
for(var k in t){
if(!t.hasOwnProperty(k)){
continue;
}
console.log(k);
}
//要求此函数接收两个参数，要求返回值为负数，0，正数，
//如果范回负数代表第一个参数小于第二个参数，0为相等，正则大于；
var compareFun = function (a,b){
return a-b;
};
var m = [3,20,10,9,11,12];
console.log(m);
// m.sort();
// console.log(m);
// m.sort(compareFun);
// console.log(m);
//由于匿名函数只用一次，没有必要创建一个变量，直接可以把匿名函数的表达式，、
//传递到sort函数里就行；
m.sort(function(a,b){
return a-b;
});
console.log(m);
10数组的方法-连接方法
①concat();连接原数组和传递参数形成一个新数组并返回，不影响原来的数组；如果传入的参数是数组，会把数组中的元素跟原数组的元素进行合并成一新数组；
var t = [1,2,3];
//调用数组的连接方法
var arr = t.concat('ss',true,222);
console.log(t);
console.log(arr);
var arr1 = t.concat('luoma','beijing',000);
console.log (arr1);
//结果
demo.js:4 (3) [1, 2, 3]
demo.js:5 (6) [1, 2, 3, "ss", true, 222]
demo.js:7 (6) [1, 2, 3, "luoma", "beijing", 0]
②join();
javascript
var t = [1,2,3];
//转换成字符串，用，隔开
console.log(t.toString());
//join也可以转换成字符串
console.log(t.join());
// join方法可以传递一个参数；用来分割数组中的元素；
console.log(t.join('-'));
console.log(t.join('+'));
//结果
demo.js:3 1,2,3
demo.js:5 1,2,3
demo.js:7 1-2-3
demo.js:8 1+2+3
9.数组的方法-切片方法
①slice:截取数组的一个片段或子数组，接受一到两个参数截取数组起始索引结束索引；
var t = [0,1,2,3,4,5];
console.log(t);
//slice复制数组的一部分；
//传一个参数的时候，是从参数的索引位置开始截取到数组的最后；
var a1 = t.slice(2);
console.log("a1 = "+a1);
// 传两个参数，从第一个参数索引开始第二个索引结束；
var a2 = t.slice(2,4);
console.log("a2="+a2);
//如果传递的是负数，从结尾开始计算一般不要用；
//只能往后截取，如果往前截取返回空数组；
var a3 = t.slice(-3,-1);
console.log("a3 ="+a3);
//结果
demo.js:2 (6) [0, 1, 2, 3, 4, 5]
demo.js:6 a1 = 2,3,4,5
demo.js:9 a2=2,3
demo.js:13 a3 =3,4
②splice();在原数组上进行插入或者删除，返回的结果是删除的元素或者数组；
// 对原数组有影响
var arr = [0,1,2,3,4,5,6];
var a1 = arr.splice(3);
console.log(arr);
console.log(a1);
// 两个参数；第一个是删除的起始索引，第二个是删除的
var a2 = arr.splice(3,1);
console.log(arr);//[0,1,2,4,5,6]
console.log(a2);//[3]
// 传递 两个以上的参数，第一个开始，第二个删除数据的个数，
// 第三个及后面的要插入start索引后面的参数；
var a3 = arr.splice(3,2,'ss','fd');
console.log(a3);
console.log(arr);
//demo.js:13 (2) [3, 4]
// demo.js:14 (7) [0, 1, 2, "ss", "fd", 5, 6]
// splice给数组任意元素插入数据；
arr.splice(3,0,'a');
console.log(arr);
// 替换元素
arr.splice(3,1,'q');
console.log(arr);
③数组案例
// 将数组内容进行反序
var t = [12,32,425,235,33,5];
console.log(t);
//js提供的reverse方法
// t.reverse();
// console.log(t);
// 用循环做
// var arr = new Array(t.length);
// 倒着遍历数组
// for(var i = t.length-1,k=0;i>=0;i--,k++){
// arr[k] = t[i];
// }
// console.log(arr);
// 优化上述
// for(var i = 0;i<t.length;i++){
// arr[t.length-i-1] = t[i];//直接把元数组中数据赋值给新数组对应位置
// }
// console.log(arr);
//第三种方法，不增加数组的情况下，直接修改
for(var i = 0;i<t.length/2;i++){
var temp = t[i];
t[i] = t[t.length-1-i];
t[t.length-1-i] = temp;
}
console.log(t);
// 求数组的最小值和其索引练习；
var t = [12,44,3,56,76];
var min,minIndex;
min = t[0];
minIndex = 0;
//循环数组中的每个值比较
for(var i = 0;i<t.length;i++){
if(t[i]<min){
min = t[i];
minIndex = i;
}
}
console.log(min);
console.log(minIndex);
// 求数组中数据的平均值，和
var t = [1,23,56,44,2];
var sum = 0,average = 0;
for(var i = 0;i<t.length;i++){
sum += t[i];
}
console.log('和是'+sum);
console.log('平均值'+sum/t.length);
// 对数组的数据进行排序
var t = [2,44,34,54,66,765];
console.log(t);
t.sort(function(a,b){
return b - a;
});
console.log(t);
// 给定一个数组去掉重复数据
var t = [11,23,435,54,22,11,22,23];
console.log(t);
var arr = [];
// 把原数组中的第一个数组插入到数组中
arr.push(t[0]);
// 判断并插入；
for(var i = 1;i<t.length;i++){ //遍历原数组
// if(arr.indexOf(t[i] == -1)){//indexof(),存在返回索引，不存在返回-1；
// arr.push(t[i]);//不支持IE8；
// }
//遍历新数组，看当前t[i],是否在新数组中；
for(var k = 0;k<arr.length;k++){
if(t[i] === arr[k]){
//如果相等已经存在不能插；
break;
}
}
if(k === arr.length){//判断循环是否到最后到最后；
arr.push(t[i]);
}
}
console.log(arr);
// 给定一个数组去掉重复数据 哈希对象属性去重
var t = [11,23,435,54,22,11,22,23];
console.log(t);
var h = {};
for(var k in t){
var str = t[k].toString();//把数组中的元素赋值给str；
h[str] = t[k];//把数组中的元素值设置给对象的属性，并且给属性值赋值；
//利用对象的属性不能重复；如果重复定义后面的会覆盖；
}
var arr = [];
for(var m in h){
arr.push(h[m]);
}
console.log(arr);
10.值类型和引用类型
①如果实参是值类型，会复制一个值类型的副本给函数，不会影响原来的传递参数的值类型变量；
②如果实参是引用类型，传递只是引用类型的一个地址值，在函数内部操作参数对应的引用对象会影响到传递的参数。
引用类型的赋值操作：是将引用类型的堆上的内存地址进行了赋值。
函数的参数：
形参：函数定义的参数；实参：实际传递的参数；
function max(a,b){
console.log(arguments);
//没一个函数都有可以直接访问的Arguments；里面存放着传递给函数的参数；
if(a>b){
return a;
}
else{
return b;
}
}
var t = max(9,10);
console.log(t);
var m = max(9,10,20,30);
// 返回最大值
function myMax(){
if(arguments.length <=0 ){
return NaN;
}
var max = arguments[0];
for(var i = 0;i<arguments.length;i++){
if(arguments[i] > max){
max = arguments[i];
}
}
return max;
}
var m = myMax(10,2,3,44,33,18);
console.log(m);
// 返回最大值
function myMax(){
if(arguments.length <=0 ){
return NaN;
}
var max = arguments[0];
for(var i = 0;i<arguments.length;i++){
if(arguments[i] > max){
max = arguments[i];
}
}
return max;
}
var m = myMax(10,2,3,44,33,18);
console.log(m);
function rect(rectobject){
console.log(rectobject.x+' '+rectobject.y);
}
var rectobject = {
x:19,
y:20,
width:200,
height:300,
bgcolor:black
};
rect(rectobject);