JavaScript课堂笔记
ECMAScript
JavaScript是什么?
是一门脚本语言:不需要编译,直接运行
是一门解释性的语言:遇到一样代码就解释一行代码
是一门动态类型的语言---不解析
是一门基于对象的语言---不解释
是一门弱类型的语言,声明变量的时候都使用var
强类型的语言:C#就是----->C#语言是一门面向对象的语言,也是编译语言,是.net技术使用的
js代码的注意问题：
1.在一对script的标签中有错误的js代码,那么该错误的代码后面的js代码不会执行
2.如果第一对的script标签中有错误,不会影响后面的script标签中的js代码执行
3.script的标签中可以写什么内容 type="text/javascript"是标准写法或者写language="JavaScript"都可以
但是,目前在我们的html页面中,type和language都可以省略,原因:html是遵循h5的标准
4.有可能会出现这种情况:script标签中可能同时出现type和language的写法.
5.script标签在页面中可以出现多对
6.script标签一般是放在body的标签的最后的,有的时候会在head标签中,目前讲课的时候都在body标签的后面(body中的最后)
7.如果script标签是引入外部js文件的作用,那么这对标签中不要写任何的js代码,如果要写,重新写一对script标签,里面写代码
变量
* 操作的数据都是在内存中操作
* js中存储数据使用变量的方式(名字,值--->数据)
* js中声明变量都用var---->存储数据,数据应该有对应的数据类型
* js中的字符串类型的值都用双引号或者单引号
* 变量作用:用来操作数据的(可以存储,可以读取)
* 注意的基本的代码的规范
* js中声明变量都用var
* js中的每一行代码结束都应该有分号;(写代码有分号的习惯)
* js中的大小写是区分的: var N=10;
* js中的字符串可以使用单引号,也可以使用双引号,目前我们暂时使用双引号
* 变量名的注意问题---变量名的命名规范,要遵循驼峰命名法
* 1.变量的名字要有意义,
* 2.变量名有一定的规范:一般以字母,$符号,下划线开头,中间或者后面可以有$符号,字母,数字
* 3.变量名一般都是小写的
* 4.变量名如果是多个单词,第一个单词的首字母是小写的,后面的所有的单词的首字母都是大写的,这种命名方式称为:驼峰命名法
* 5.不能使用关键字(系统自带的一些单词,不能使用)
* 6.不会单词用拼音,拼音也要遵循驼峰命名法
注释
注释:是解释代码的含义,给其他的程序员看的
代码中如果没有注释,不规范,天天会被骂醒
//单行注释:一般用在一行代码的上面
/*
* 多行注释:一般是用在函数或者是一段代码的上面
**/
数据类型
js中的原始数据类型:number,string,boolean,null,undefined,object
* number:数字类型(整数和小数)
* string:字符串类型(的值一般都是用单引号或者是双引号括起来) "34"
* boolean:布尔类型(值只有两个,true(真1),false(假0))
* null:空类型,值只有一个:null,一个对象指向为空了,此时可以赋值为null
* undefined:未定义,值只有一个:undefined
* 什么情况下的结果是undefined???
* 变量声明了,没有赋值,结果是undefined
* 函数没有明确返回值,如果接收了,结果也是undefined
* 如果一个变量的结果是undefined和一个数字进行计算,结果:NaN不是一个数字,也没有意义
* object:对象---->
如何获取这个变量的数据类型是什么? 使用typeof 来获取？？
typeof 变量名
typeof(变量名)
数据类型之数字类型
* 数字类型:number类型
* 无论是整数还是小数都是数字类型
* 不要用小数验证小数 0.1 + 0.2 == 0.3（是不成立的）
* 不要使用NaN判断是不是NaN，应该使用isNaN(值或者是变量) 是不是不是一个数字----->不是一个数字吗？
判断结果不是一个数字可以使用isNaN(变量名)
* 想要表示十进制:就是正常的数字
* 想要表示八进制:以0开头
* 想要表示十六进制:0x开头
数据类型之字符串类型
//字符串可以使用单引号,也可以使用双引号
var str="10";//字符串
var str2='20';//字符串
字符串的长度如何获取? 变量名.length length属性
var str="what are you no sha lei";
//字符串的个数有多少个?这个字符串的长度是多少
console.log(str.length);
var str1="fdshfjworwoijpfskj;akjfpojfiwnmoiwajdoiwajiwaewowj";
console.log(str1.length);
html中的转义符: js中的字符串里也有转义符
< < > > 空格:
//tab键----水平制表符
console.log("哈哈\\嘎嘎");
console.log("哈哈\t嘎嘎");
console.log("哈哈\"嘎嘎");
console.log('哈哈\'嘎嘎');
字符串的拼接: 使用+可以把多个字符串放在一起形成一个字符串
//只要有一个是字符串,其他的就算是数字,那么结果也是拼接,不是相加
var str1="您好";
var str2="我好";
console.log(str1+str2);
console.log("哈哈"+"嘎嘎"+"嘿嘿");
var str1="10";
var str2="20";
console.log(str1+str2);
var str1="10";
var str2=20;
console.log(str1+str2);
//如果有一个是字符串,另一个不是字符串,使用- 号,此时会发生计算
var str1 = "10";
var str2 = 5;
//浏览器帮助我们自动的把字符串类型转成了数字类型,这种方式叫:隐式转换
console.log(str1-str2);
var str1 = "呵呵呵";
var str2 = 5;
console.log(str1-str2);
打印---> NaN
//如果有一个是字母字符串，另一个不是字符串是数字，用 - 或者* 结果是什么？
var str1="10";
var str2=5;
console.log(str1*str2);
数据类型转换
其他类型转数字类型:三种方式:
parseInt();//转整数
console.log(parseInt("10"));//10
console.log(parseInt("10afrswfdsf"));//10
console.log(parseInt("g10"));//NaN
console.log(parseInt("1fds0"));//1
console.log(parseInt("10.98"));//10
console.log(parseInt("10.98fdsfd"));//10
parseFloat()//转小数
console.log(parseFloat("10"));//10
console.log(parseFloat("10afrswfdsf"));//10
console.log(parseFloat("g10"));//NaN
console.log(parseFloat("1fds0"));//1
console.log(parseFloat("10.98"));//10.98
console.log(parseFloat("10.98fdsfd"));//10.98
//想要转数字:Number();要比上面的两种方式严格
Number();//转数字
console.log(Number("10"));//10
console.log(Number("10afrswfdsf"));//NaN
console.log(Number("g10"));//NaN
console.log(Number("1fds0"));//NaN
console.log(Number("10.98"));//10.98
console.log(Number("10.98fdsfd"));//NaN
其他类型转字符串类型
//如果变量有意义调用 .toString()使用转换
//如果变量没有意义使用 String()转换
var num2;
console.log(num2.toString());
var num3 = null;
console.log(num3.toString());
//这个可以
var num2;
console.log(String(num2));
var num3 = null;
console.log(String(num3));
其他类型转布尔类型
//转布尔类型的时候是遵循1是true,0是false 的原则吗 ？不是的
Boolean(值);
console.log(Boolean(1));//true
console.log(Boolean(0));//false
console.log(Boolean(11));//true
console.log(Boolean(-10));//true
console.log(Boolean("哈哈"));//true
console.log(Boolean(""));//false
console.log(Boolean(null));//false
console.log(Boolean(undefined));//false
转换总结
* parseInt();---->自己写内容转换---测试多次
* parseFloat()--->
* Number()
* .toString()
* String()
* Boolean()
流程控制语句
//弹框---并且有输入
var number=parseInt(prompt("请输入一个数字"));
if(number%2==0){
console.log("偶数");
}else{
console.log("奇数");
}
调试
调试:是为了找代码的错误和问题所在,
断点,不加断点,就不方便调试
数组定义的几种方式
1、通过构造函数创建数组
//语法:
var 数组名=new Array();
var array=new Array();//定义了一个数组
//数组的名字如果直接输出,那么直接就可以把数组中的数据显示出来,如果没有数据,就看不到数据
var 数组名=new Array(长度);
/*如果数组中没有数据,但是有长度---,数组中的每个值就是undefined
构造函数的方式创建数组的时候,如果在Array(一个数字)--->数组的长度(数组元素的个数)
如果在Array(多个值);这个数组中就有数据了,数组的长度就是这些数据的个数*/
2、通过字面量的方式创建数组
//语法
var 数组名=[];//空数组
var array=[];
//字面量的方式更简单
var arr=[10,20,30,40,50,60,70,80,10,20,3043,5];//空数组
console.log(arr.length);
数组的注意问题
//数组中存储的数据类型一定是一样的吗? 类型可以不一样
var arr=[10,"哈哈",true,null,undefined,new Object()];
console.log(arr);
//数组的长度是不是可以改变呢?
var arr=[];
//通过索引来设置数组中的元素的值
arr[0]=10;
arr[1]=20;
console.log(arr.length);
//获取元素的值,通过索引的方式
console.log(arr[2]);
函数
什么是函数
//函数:把一坨重复的代码封装,在需要的时候直接调用即可
//函数的作用:代码的重用
//函数需要先定义,然后才能使用
//函数名字:要遵循驼峰命名法
//函数一旦重名,后面的会把前面的函数覆盖
函数里面可以调用其他的函数
function f1() {
console.log("我是一个函数");
f2();//函数的调用
}
function f2() {
console.log("我也是一个函数");
}
f1();
函数的参数
* 函数参数:
* 在函数定义的时候,函数名字后面的小括号里的变量就是参数,目的是函数在调用的时候,用户传进来的值操作
* 此时函数定义的时候后面的小括号里的变量叫参数;写了两个变量,就有两个参数,
* 在函数调用的时候,按照提示的方式,给变量赋值--->就叫传值,把这个值就传到了变量(参数)中
* 形参:函数在定义的时候小括号里的变量叫形参
* 实参:函数在调用的时候小括号里传入的值叫实参,实参可以是变量也可以是值
- 形参和实参
- 形式参数：在声明一个函数的时候，为了函数的功能更加灵活，有些值是固定不了的，对于这些固定不了的值。我们可以给函数设置参数。这个参数没有具体的值，仅仅起到一个占位置的作用，我们通常称之为形式参数，也叫形参。
- 实际参数：如果函数在声明时，设置了形参，那么在函数调用的时候就需要传入对应的参数，我们把传入的参数叫做实际参数，也叫实参。
- 形参的个数和实参的个数可以不一致
函数的返回值
当函数执行完的时候，并不是所有时候都要把结果打印。我们期望函数给我一些反馈（比如计算的结果返回进行后续的运算），这个时候可以让函数返回一些东西。也就是返回值。函数通过return返回一个返回值。
返回值详解：
如果一个函数中有return ,那么这个函数就有返回值
如果一个函数中没有return,那么这个函数就没有返回值
如果一个函数中没有明确的返回值,那么调用的时候接收了,结果就是undefined(没有明确返回值:函数中没有return，函数中有return、但是return后面没有任何内容)
变量声明了,没有赋值,结果也是undefined
return 下面的代码是不会执行的。
arguments对象
JavaScript中，arguments对象是比较特别的一个对象，实际上是当前函数的一个内置属性。也就是说所有函数都内置了一个arguments对象，arguments对象中存储了传递的所有的实参。arguments是一个伪数组，因此及可以进行遍历
为什么存在arguments：定义一个函数,如果不确定用户是否传入了参数,或者说不知道用户传了几个参数,没办法计算,但是如果在函数中知道了参数的个数,也知道了，每个参数的值.可以进行计算。
//定义
function f1() {
//获取的是函数在调用的时候,传入了几个参数
console.log(arguments.length);
//使用arguments对象可以获取传入的每个参数的值
console.log(arguments);
}
f1(10,20,30,40,100,200); //调用
function f1() {
//arguments--->数组使用 --->伪数组
var sum=0;
for(var i=0;i<arguments.length;i++){
sum+=arguments[i];
}
return sum;
}
console.log(f1(10,20,30));
函数的其他定义方式
命名函数:
函数如果有名字,就是命名函数
匿名函数:
函数如果没有名字,就是匿名函数
函数的另一种定义方式—>函数表达式:
把一个函数给一个变量,此时形成了函数表达式
//例子:
var f1=function (){
};
f1();
// 如果是函数表达式,那么此时前面的变量中存储的就是一个函数,而这个变量就相当于是一个函数,就可以直接加小括号调用了。
//注意: 函数表达式后面,赋值结束后,要加分号。
-
调用函数的语法：
函数名();
函数的自调用
函数的自调用,没有名字,调用—声明的同时,直接调用
//函数自调用例子:
(function () {
console.log("阿涅哈斯诶呦");
})();
(function () {
console.log("嘎嘎")
})();
函数也是一种数据类型
function f1() {
console.log("我是函数");
}
//如何获取某个变量的类型? typeof
console.log(typeof f1);
//函数是有数据类型,数据类型:是function 类型的
-
函数作为参数
因为函数也是一种类型，可以把函数作为函数的参数，在函数中调用
函数可以作为参数使用,如果一个函数作为参数,那么我们说这个参数(函数)可以叫回调函数
只要是看到一个函数作为参数使用了,那就是回调函数
function sayHi(fn) {
console.log("您好啊");
fn(); //这一行的fn()此时应该是一个函数 或者说 函数调用---说明fn这个变量中存储的是一个函数
}
function suSay() {
console.log("我猥琐,我邪恶,我龌龊,小苏说");
}
sayHi(suSay);
-
函数作为返回值使用
因为函数是一种类型，所以可以把函数作为返回值从函数内部返回，这种用法在后面很常见。
function f1() {
console.log("f1函数调用了");
return function () {
console.log("这是一个函数");
};
}
var ff=f1(); //调用
ff(); //ff就是一个函数了
作用域
全局变量和局部变量
全局变量:声明的变量是使用var声明的,那么这个变量就是全局变量,全局变量可以在页面的任何位置使用
除了函数以外,其他的任何位置定义的变量都是全局变量
全局变量,如果页面不关闭,那么就不会释放,就会占空间,消耗内存局部变量:在函数内部定义的变量,是局部变量,外面不能使用
隐式全局变量:声明的变量没有var,就叫隐式全局变量
function f1() {
number=1000;//是隐式全局变量
}
f1();
console.log(number); //---1000
//全局变量是不能被删除的,隐式全局变量是可以被删除的
//定义变量使用var是不会被删除的,没有var是可以删除的
var num1=10;
num2=20;
delete num1;//把num1删除了
delete num2;//把num2删除了
console.log(typeof num1); //---number
console.log(num1+10); //---20
console.log(typeof num2); //---undefined
块级作用域
一对大括号就可以看成是一块,在这块区域中定义的变量,只能在这个区域中使用,但是在js中在这个块级作用域中定义的变量,外面也能使用;
说明:js没有块级作用域,只有函数除外
{
var num=10;
console.log(num); //---10
}
console.log(num); //---10
if(true){
var num=10;
}
console.log(num); //---10
for(var i=0;i<5;i++){
var number=20;
}
console.log(number); //---20
使用var声明的变量会自动添加到最接近的环境中。在函数内部，最接近的环境就是函数的局部环境；在with语句中，最接近的环境就是函数环境。如果初始化变量时没有使用var声明，该变量会自动添加到全局环境。
function add (num1,num2) {
var sum=num1+num2;
return sum;
}
var result=add(10,20); //30
alert(result); //30
alert(sum); //由于sum不是有效的变量，因此会导致错误
如果去掉sum去掉var的声明，则不会报错，因为改sum已添加到全局环境中了。
预解析
JavaScript代码的执行是由浏览器中的JavaScript解析器来执行的。JavaScript解析器执行JavaScript代码的时候，分为两个过程：预解析过程和代码执行过程
/*
预解析中,变量的提升,只会在当前的作用域中提升,提前到当前的作用域的最上面
函数中的变量只会提前到函数的作用域中的最前面,不会出去
预解析会分段(多对的script标签中函数重名,预解析的时候不会冲突)
*/
编程思想
编程思想:把一些生活中做事的经验融入到程序中
面向过程:凡事都要亲力亲为,每件事的具体过程都要知道,注重的是过程
面向对象:根据需求找对象,所有的事都用对象来做,注重的是结果
面向对象特性:封装,继承,多态 (抽象性)
js不是面向对象的语言,但是可以模拟面向对象的思想
js是一门基于对象的语言:
万物皆对象:---------->程序猿 程序媛
//什么是对象?
//看的见,摸得到,具体特指的某个东西
/*
分析对象有什么特点:特征和行为
对象:有特征和行为,具体特指的某一个事物 对象:有属性和方法,具体特指的某个事物
没有对象--->创建对象
*/
创建对象三种方式:
-
1.调用系统的构造函数创建对象
//实例化对象 var 变量名= new Object(); Object 是系统的构造函数 Array -
2.自定义构造函数创建对象(结合第一种和需求通过工厂模式创建对象)
-
3.字面量的方式创建对象
调用系统的构造函数创建对象
//第一种创建对象的方式
//小苏举例子:
//实例化对象
var obj = new Object();
//对象有特征---属性和行为---方法
//添加属性-----如何添加属性? 对象.名字=值;
obj.name = "小苏";
obj.age = 38;
obj.sex = "女";
//添加方法----如何添加方法? 对象.名字=函数;
obj.eat = function () {
console.log("我喜欢吃油炸榴莲凉拌臭豆腐和大蒜");
};
obj.play = function () {
console.log("我喜欢玩飞机模型");
};
obj.cook = function () {
console.log("切菜");
console.log("洗菜");
console.log("把菜放进去");
console.log("大火5分钟");
console.log("出锅");
console.log("凉水过一下");
console.log("放料,吃");
};
console.log(obj.name);//获取--输出了
console.log(obj.age);
console.log(obj.sex);
//方法的调用
obj.eat();
obj.play();
obj.cook();
如何获取该变量(对象)是不是属于什么类型的?
* 语法:
* 变量 instanceof 类型的名字----->返回布尔类型,true就是这种类型,false不是这种类型
* 在当前的对象的方法中,可以使用this关键字代表当前的对象
//实例化学生的对象
var person=new Object();
person.name="小芳";
person.age=18;
person.study=function () {
console.log("学习,敲代码,今天作业四遍,我今年"+this.age+"岁了");
};
//输出人是不是人的类型
console.log(person instanceof Object);
工厂模式创建对象、自定义构造函数创建对象
调用系统的构造函数要写很多的代码？如何一次性创建多个对象？把创建对象的代码封装在一个函数中
//工厂模式创建对象
function createObject(name,age) {
var obj = new Object();//创建对象
//添加属性
obj.name = name;
obj.age = age;
//添加方法
obj.sayHi = function () {
console.log("阿涅哈斯诶呦,我叫:" + this.name + "我今年:" + this.age);
};
return obj;
}
//创建人的对象
var per1 = createObject("小芳",20);
per1.sayHi();
//创建一个人的对象
var per2 = createObject("小红",30);
per2.sayHi();
new 的执行过程：new的时候，系统做了什么事?
回头学其他面向对象的语言也是这么几件事
/*
* 1. 在内存中申请一块空闲的空间空间,存储创建的新的对象 （不能说开辟）
* 2. 把this设置为当前的对象
* 3. 设置对象的属性和方法的值
* 4. 把this这个对象返回
*/
构造函数创建对象,我要自己定义一个构造函数,自定义构造函数,创建对象
函数和构造函数的区别；名字是不是大写(构造函数首字母是大写)自定义构造函数创建对象与工厂模式类似:先自定义一个构造函数,创建对象
//自定义狗的构造函数,创建对象
function Dog(name,age,sex) {
this.name=name;
this.age=age;
this.sex=sex;
}
var dog=new Dog("大黄",20,"男");
console.log(dog instanceof Person);//false
console.log(dog instanceof Dog);
图解，
字面量方式创建对象
//字面量创建对象的缺陷: 一次性的对象
var obj = {
name: "小明",
age: 38,
sex: "女"
};
obj.name = "小三";
console.log(obj.name);
总结对象
//点语法: 对象.名字=值; 对象.名字=函数;
//没有什么点,就有了
* 1. 代码(变量)只有执行到这个位置的时候,才知道这个变量中到底存储的是什么,如果是对象,就有对象的属性和方法,如果是变量就是变量的作用
* 2. 对象没有什么,只要点了,通过点语法,那么就可以为对象添加属性或者方法
JSON格式的数据
JSON格式的数据:一般都是成对的,是键值对
JSON也是一个对象,数据都是成对的,一般JSON格式的数据无论是键还是值都是用双引号括起来的
遍历对象
//遍历对象,是不能通过for循环遍历的 可以通过for-in循环
删除、添加对象属性
var json = {
"name": "小明",
"age": "10",
"sex": "男"
};
var key = "hello", key1 = "hello";
var value = "张三丰", value = "张无忌"
json[key] = value; //添加
for (var key in json) { //key是一个变量,这个变量中存储的是该对象的所有的属性的名字
console.info(key + "===========" + json[key]);
}
var json = {
"name": "小明",
"age": "10",
"sex": "男"
};
delete json.name; //删除
for (var key in json) {
console.info(key + "===========" + json[key]);
}
js对象的使用
查文档学习 MDN:Math
js学习中三种对象:
1.内置对象----js系统自带的对象
2.自定义对象---自己定义的构造函数创建的对象
3.浏览器对象---浏览器的（BOM的时候讲）
// 内置对象:Math、Date、String、Array、Object
实例对象:通过构造函数创建出来,实例化的对象 (Date对象)
静态对象:不需要创建,直接就是一个对象,方法(静态方法)直接通过这个对象名字调用, （Math对象 ）
实例方法必须通过实例对象调用
静态方法必须通过大写的对象调用
Math对象
Math对象不是构造函数，它具有数学常数和函数的属性和方法，都是以静态成员的方式提供
Math.PI---π
Math.E----常数的底数
Math.abs()-----绝对值
Math.ceil()----向上取整
Math.floor()---向下取整
Math.random()--随机数范围[0，1)，不包括1
Math.sqrt()----开平方
Math.pow()-----一个数字的多少次幂
Math.max()
Math.min()-----找一坨数字中的最大/小值
Date对象
创建Date实例用来处理日期和时间。
//创建实例对象
var dt = new Date();
console.log(dt); //当前的时间：当前的服务器--Sun Oct 21 2018 16:16:44 GMT+0800 (中国标准时间)
dt.getFullYear() //获取年份---2018
dt.getMonth()+1 //是0开始的 真实的月份是需要加1的---10
dt.getDate() //获取日期---21
dt.getHours() //获取小时---16
dt.getMinutes() //获取分钟---16
dt.getSeconds() //获取秒---44
dt.getDay() //获取星期--星期从0开始的---0（星期日）
dt.toDateString(); //英文的日期---"Sun Oct 21 2018"
dt.toLocaleDateString(); //小时分钟秒---"2018/10/21"
dt.toTimeString(); //小时分钟秒---"16:16:44 GMT+0800 (中国标准时间)"
dt.toLocaleTimeString(); //时间---"下午4:16:44"
dt.valueOf(); //毫秒值----1540108562181(时间戳)
String对象
- 字符串可以看成是字符组成的数组,但是js中没有字符类型
字符是一个一个的,在别的语言中字符用一对单引号括起来。
在js中字符串可以使用单引号也可以使用双引号。
因为字符串可以看成是数组,所以,可以通过for循环进行遍历。
- 字符串特性:不可变性,字符串的值是不能改变
字符串的值之所以看起来是改变的,那是因为指向改变了,并不是真的值改变了。
//字符串的常用属性:
.length //字符串的长度
.charAt(索引) //返回值是指定索引位置的字符串,超出索引,结果是空字符串
.fromCharCode(数字值,可以是多个参数) //返回的是ASCII码对应的值
.concat(字符串1,字符串2,...) //返回的是拼接之后的新的字符串
.indexOf(要找的字符串,从某个位置开始的索引);//返回的是这个字符串的索引值,没找到则返回-1
.lastIndexOf(要找的字符串) //从后向前找,但是索引仍然是从左向右的方式,找不到则返回-1
.replace("原来的字符串","新的字符串") //用来替换字符串的
.slice(开始的索引,结束的索引) //从索引5的位置开始提取,到索引为10的前一个结束,没有10，并返回这个提取后的字符串
.split("要干掉的字符串",切割后留下的个数) //切割字符串
.substr(开始的位置,个数) //返回的是截取后的新的字符串
.substring(开始的索引,结束的索引) //返回截取后的字符串,不包含结束的索引的字符串
.toLocaleLowerCase() //转小写
.toLowerCase() //转小写
.toLocaleUpperCase() //转大写
.toUpperCase() //转大写
.trim() //干掉字符串两端的空格
Array对象
看笔记、以及代码，不再赘述
ECMAScript重点部分
js基础的重点内容:
第一天:js的介绍及基本语法变量、数据类型、运算符
第二天:js的流程控制:分支语句、循环、顺序结构
第三天:数组、冒泡排序、
第四天:函数
第五天:内置对象
第六天:内置对象及一些方法
* 第一天课程内容:
* js的介绍,历史,什么是js?---故事
* 变量-----重点
* 数据类型---重点
* 运算符----重点
* 第二天课程内容:
* 一元运算符: ++ --
* 流程控制:----三个部分
* 下面的都是重点
* 分支结构:if ,if-else ,if-else if-else if-else, switch-case,三元表达式
* 循环结构:while, do-while ,for, 后期还有一个for-in循环
* 第三天课程内容:
* 1.关键字的使用: break,continue
* 2.数组---重点-----
* 冒泡排序-----重点---------3分钟之内必须全部写完
* 3.函数--重点
* 第四天重点内容:
* 函数---案例-----重点
* 函数的注意问题---常见的一些错误---自己写代码,自己犯错,指点一二
* 作用域----重点的----写代码要注意变量的在哪声明和使用的问题---
* 预解析---重点----什么叫预解析, 什么东西发生了什么事
* arguments---对象----伪数组
* 对象---js后面就轻松---什么是对象-找对象---重点
* 第五天重点内容:
* 理解的----面向过程、面向对象、对象
* 理解的----简单的类型和复杂类型：画图理解数据的值在哪个空间中存储
*
* 重点-----需要写出代码能够说出来
* 创建对象的不同的方式
* 重点-----自定义对象能够写出来
* 数据类型深入:
* 重点：------每个对象下的常见的方法的使用
* 第六天重点内容:
* 内置对象
* Math------>
* Math的两个例子-----写一遍
* Date---一个案例----格式化时间
* Array
* String
* 所有介绍的常见的方法---熟练的时候,需求---该用什么方法
注意的点、自己总结：
1、使用内置对象的时候考虑到Date对象的特殊性，