开启掘金成长之旅！这是我参与「掘金日新计划 · 12 月更文挑战」的第5天，点击查看活动详情
一：变量
1. 变量的声明与赋值
1.1 Java中的变量
（1）java中怎么定义/声明变量？
数据类型 变量名;
例如：
int i;
double d;
boolean flag;
（2）java中的变量怎么赋值？
①使用“=”运算符进行赋值运算。②（"="运算符右边先执行，将右边执行的结果赋值给左边的变量。）
③变量名 = 值；例如：
i = 10;
d = 3.14;
flag = false;
（3）java语言是一种****强类型语言 ，强类型怎么理解？
①java语言存在编译阶段，假设有代码：int i；那么在Java中有一个特点是：java程序编译阶段就已经确定了i变量的数据类型，该i变量的数据类型在编译阶段是int类型，那么这个变量到最终内存释放，一直都是int类型，不可能变成其他类型！
②int i = 10; double d = i; 这行代码是说声明一个新的变量d，double类型，把i变量中保存的值传给d；i还是int类型。i = "abc"; 这行代码编译的时候会报错，因为i变量的数据类型是int类型，不能将字符串赋给i！
③java中要求变量声明的时候是什么类型，以后永远都是这种类型，不可变；编译期强行固定变量的数据类型，称为强类型语言！
1.2 JS中的变量
（1）javascript怎么声明变量？ 怎么给变量赋值？
①var 变量名;
②变量名 = 值;
（2）javascript是一种弱类型语言，没有编译阶段，一个变量可以随意赋值，赋什么类型的值都行。
var i = 100;
i = "abc";
i = new Object();
i = 3.14;
（3）在JS当中，当一个变量没有手动赋值的时候，系统默认赋值undefined
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
</head>
<body>
<script>
// 在JS当中,当一个变量没有手动赋值的时候,系统默认赋值undefined
// undefined 在JS中是一个具体存在值
var i;
alert("i = "+i);// i = undefined
// 可以给变量赋值为undefined
var k = undefined;
alert("k = "+k);
// 一个变量没有声明/定义,直接访问
// F12调试显示报错:age is not defined
// alert(age);
var a,b,c=200;
alert("a = "+a); // a = undefined
alert("b = "+b); // b = undefined
alert("c = "+c); // c = 200
// 重新给a进行赋值
a = 3.14;
alert("a = "+a); // a = 3.14
a = false;
alert("a = "+a); // a = false
a = "abc";
alert("a = "+a); // a = abc
</script>
</body>
</html>
2. 函数的定义与调用
（1）JS中的函数：
等同于java语言中的方法，函数也是一段可以被重复利用的代码片段；函数一般都是可以完成某个特定功能的！
（2）回顾java中的方法
[修饰符列表] 返回值类型 方法名(形式参数列表){
方法体;
}
例如：
// 函数的定义
public static boolean login(String username,String password){
...
return true;
}
// 函数的调用
boolean loginSuccess = login("admin","123");
（3）JS中的变量是一种弱类型的，那么函数应该怎么定义呢？
语法格式：
第一种方式：
function 函数名(形式参数列表){
函数体;
}
第二种方式：
函数名 = function(形式参数列表){
函数体;
}
（4）JS中的函数不需要指定返回值类型，返回什么类型都行；参数也不需要写参数类型****
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
</head>
<body>
<script type="text/javascript">
// 定义一个sum函数
function sum(x,y){
// x和y都是局部变量,都是形参(x和y都是变量名，变量名随意)
alert(x+y);
}
// 调用函数
// sum(10,20); // 30
// 定义函数sayHello
sayHello=function(username){
alert("Hello "+username);
}
// 调用函数
// sayHello("zhangsan"); //Hello zhangsan
</script>
<!--在外面定义按钮，点击才调用函数，需要用到事件句柄onclick-->
<!--window.alert()也是一个内置函数，现在只不过换成我们自己写的函数-->
<input type="button" value="Hello" onclick="sayHello('jack')"></input>
</body>
</html>
①Js中的函数没有重载机制，因为是弱类型；JS当中的函数在调用的时候，参数的类型没有限制，并且参数的个数也没有限制；一个函数就相当于很多函数
②在JS当中，函数的名字不能重名，当函数重名的时候，后声明的函数会将之前声明的同名函数覆盖！
③JS中就只通过函数名来区分函数！
④假设定义了两个参数：
（1）就传两个参数属于正常调用；
（2）传一个参数，如果这个参数是非字符串，结果是NaN；如果这个参数是字符串“abc”，默认的另一个参数是undefined，结果是"abcundefined"；
（3）如果传多个参数，多余的参数会被忽略舍去，只保留前两个的参数值；
（4）不传参数也是NaN，表示not a number
（5）如果定义两个函数名相等的两个函数，并且参数不同；调用时不会根据参数来进行调用，无论怎样调用，调用的都是后面的那个函数，后面的函数一定会被前面的函数覆盖！
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
</head>
<body>
<script type="text/javascript">
// 1、定义一个两个参数的sum函数
sum=function(x,y){
return x+y;
}
// 1.1正常调用函数,就传2个参数
var retValue = sum(10,20);
alert(retValue); // 30
// 1.2传一个参数,一个字符串
// abc赋值给a变量,b变量没有赋值系统默认赋值undefined
alert(sum("jack")); //jackundefined
// 1.3传三个参数
// 第三个参数会被舍弃掉
alert(sum(1,2,3)) // 3
// 1.4不传参数
// NaN是一个具体存在的值，该值表示不是数字;Not a Number
alert(sum()); //NaN
// 2、在定义一个重名的函数
function test(username){
alert("test test");
}
function test(){
alert("test"); // 执行这个结果test
}
// 调用,调用的是第二个test()函数
// 因为后声明的函数会将之前声明的同名函数覆盖
test("zhangsan");
</script>
</body>
</html>
3. 局部变量和全局变量
（1）全局变量： 在函数体之外声明的变量属于全局变量，全局变量的生命周期：
浏览器打开时声明，浏览器关闭时销毁，尽量少用。因为全局变量会一直在浏览器的内存当中，耗费内存空间。能使用局部变量尽量使用局部变量。
（2）局部变量： 在函数体当中声明的变量，包括一个函数的形参都属于局部变量，局部变量的生命周期：函数开始执行时局部变量的内存空间开辟，函数执行结束之后，局部变量的内存空间释放。局部变量生命周期较短。
（3）当一个变量声明的时候没有使用var关键字修饰，那么不管这个变量是在哪里声明的，都是全局变量。
（4）当全局变量和局部变量重名，在函数体内访问时，优先访问的是局部变量；就近原则！在函数体外访问，访问的肯定是全局变量，因为局部变量只在函数体内有效！
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
</head>
<body>
<script type="text/javascript">
// 1、定义全局变量
var i = 100;
function accessI(){
// 访问的是全局变量
alert("i = "+i); // i = 100
}
accessI();
// 2、局部变量
var username = "zhangsan"; // 全局变量
function accessUsername(){
// 定义局部变量
var username = "lisi";
// 就近原则:访问的是局部变量
alert("username = "+username); // username = lisi
}
// 调用函数
accessUsername();
// 访问的是全局变量
alert("username = "+username); // username = zhangsan
// 3、 当一个变量声明的时候没有使用var关键字,那么不管这个变量是在哪里声明的,都是全局变量
function myfun(){
// 在函数里面声明的变量,没有用var修饰,实际上是全局变量
myname="wangwu";
}
// 在函数外能访问到,需要先调用这个函数才能够去访问
myfun();
alert("myname = " +myname); // username = wangwu
</script>
</body>
</html>
二：数据类型
（1）虽然JS中的变量在声明的时候不需要指定数据类型，但是在赋值，每一个数据还是有类型的，所以我们也需要学习一下JS包括哪些数据类型
JS中数据类型分为：原始类型、引用类型
原始类型： Undefined、Number、String、Boolean、Null
引用类型： Object以及Object的子类
（2）ES规范(ECMAScript规范)，在ES6之后，又基于以上的6种类型之外添加了一种新的类型：Symbol
（3）JS中有一个运算符typeof，可以在程序的运行阶段动态的获取变量的数据类型。
typeof运算符的语法格式：typeof 变量名
typeof运算符的运算结果是以下6个字符串之一：注意字符串都是全部小写！
"undefined"、"number"、"string"、"boolean"、"object"、"function"这样传参就可以用typeof运算符来增加限制条件，如果不满足条件，就输出打印提示；如果是带有返回值的函数，返回的是undefined！
（4）在JS当中比较字符串是否相等使用“==”完成！没有equals方法。
（5）对于未赋值的变量，默认是undefined类型，对于赋上值的，根据参数分为：number、string、boolean、object、function(函数类型)；
值得注意的是：null属于NULL类型，但是typeof的结果是object类型
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
</head>
<body>
<script type="text/javascript">
// 求和,要求a变量和b变量将来的数据类型必须是数字,不能是其他类型
function sum(x,y){
// 相当于限制条件
if(typeof x == "number" && typeof y == "number"){
return x+y;
}
alert(x+","+ y +"必须都是数字!");
}
var retValue = sum(false,"abc");
// 传参不传数字,会执行alert,没有返回值,系统默认会给retValue赋一个unfined
alert(retValue); // "undefined"
alert(sum(1,2)); // 3
// 其它值类型
var i;
alert(typeof i); // "undefined"
var k = 10;
alert(typeof k); // "number"
var f = "abc";
alert(typeof f); // "string"
var d = null;
// null属于Null类型,但是typeof运算符的结果是"object"
alert(typeof d); // "object"
var flag = false;
alert(typeof flag); // "boolean"
var obj = new Object();
alert(typeof obj); // "Object"
function sayHello(){
}
alert(typeof sayHello) // "function"
</script>
</body>
</html>
1. Undefined数据类型
Undefined类型只有一个值，这个值就是 undefined，
当一个变量没有手动赋值，系统默认赋值undefined或者也可以给一个变量手动赋undefined
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
</head>
<body>
<script type="text/javascript">
var i;
alert(typeof i); // undefined
var k = undefined;
alert(typeof k); // undefined
alert(i==k); // true
var y = "undefined"; // string
alert(typeof y);
alert(k==y); // false
</script>
</body>
</html>
2. Number数据类型
①Number类型包括哪些值？
-1 0 1 2 2.3 3.14 100 .... NaN Infinity
整数、小数、正数、负数、不是数字、无穷大都属于Number类型。NaN (表示Not a Number，不是一个数字，但属于Number类型）；
运算结果本来应该是一个数字,最后算完不是一个数字的时候,结果是NaN
Infinity (当除数为0的时候，结果为无穷大)
②isNaN()函数 : 结果是true表示不是一个数字，结果是false表示是一个数字。
③parseInt()函数，可以将字符串自动转换成数字，并且取整数位
④parseFloat()函数，可以将字符串自动转换成数字
⑤Math.ceil() 函数（Math是数学类，数学类当中有一个函数叫做ceil()，作用是向上取整）
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
</head>
<body>
<script type="text/javascript">
var v1 = 1;
var v2 = 3.14;
var v3 = -100;
var v4 = NaN;
var v5 = Infinity;
// 运行结果都是"number"
alert(typeof v1);
alert(typeof v2);
alert(typeof v3);
alert(typeof v4);
alert(typeof v5);
// 什么情况下结果是一个NaN呢？
// 运算结果本来应该是一个数字,最后算完不是一个数字的时候,结果是NaN.
var a = 10;
var b = "abc";
// 除号显然最后结果应该是一个数字,但是运算的过程中导致最后不是一个数字,那么最后的结果是NaN
alert(a / b); // NaN
// + 运行结果不一定是一个数字,也有可能是字符串拼接
alert(a + b); // 10abc
// Infinity (当除数为0的时候，结果为无穷大)
alert(10 / 0); // Infinity
// 在JS中 10 / 3结果会保留小数,不会取整是3
alert(10 / 3); // 3.3333333333333
// 几个函数讲解
//1. isNaN: is Not a Number
// 用法：isNaN(数据) ,结果是true表示不是一个数字, 结果是false表示是一个数字
// 求和,要求a变量和b变量将来的数据类型必须是数字,不能是其他类型
function sum(x,y){
// 方法1
if(typeof x == "number" && typeof y == "number"){
alert(x+y);
}
alert("两个参数必须都是数字！")
// 方法2:使用isNaN函数
if(isNaN(x) || isNaN(y)){
alert("两个参数必须都是数字！");
return;
}
alert(x+y);
}
sum(10,"abc");
//2. parseInt():可以将字符串自动转换成数字,并且取整数位
alert(parseInt("3.9999")); // 3
alert(parseInt(2.9999)); // 2
//3. parseFloat():可以将字符串自动转换成数字,并还可以进行运算
alert(parseFloat("3.14"+1)); // 4.14
//4. Math.ceil()向上取整
alert(Math.ceil(2.2)); // 3
</script>
</body>
</html>
3. Boolean数据类型
（1）JS中的布尔类型永远都只有两个值：true和false （这一点和java相同）
（2）在Boolean类型中有一个函数叫做：Boolean()
语法格式： Boolean(数据)
Boolean()函数的作用是将非布尔类型转换成布尔类型。但是使用if,wile等里面传数据，会自动调用Boolean()h函数进行转换！
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
</head>
<body>
<script type="text/javascript">
var username="jack";
// 会自动调用Boolean(username)转换为boolean类型
// 因为if语句后面只能跟true或false
if(username){
alert("欢迎回来"+username); // 欢迎回来jack
}else{
alert("用户名不能为空！");
}
// 探究那些转换为true,那些转换为false
alert(Boolean(1)); // true
alert(Boolean(0)); // false
alert(Boolean("")); // false
alert(Boolean("abc")); // true
alert(Boolean(null)); // false
alert(Boolean(NaN)); // false
alert(Boolean(undefined)); // false
alert(Boolean(Infinity)); // true
while(10 / 3){
// Boolean函数转换为true,是一个死循环
alert("hehe");
}
</script>
</body>
</html>
4. Null数据类型
Null类型只有一个值: null, 但是typeof的值是一个object
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
</head>
<body>
<script type="text/javascript">
alert(typeof null); // object
</script>
</body>
</html>
5. String数据类型
（1）在JS当中字符串可以使用单引号，也可以使用双引号。
var s1 = 'abcdef';
var s2 = "test";
（2）在JS当中，怎么创建字符串对象的两种方式：
第一种：var s = "abc";是string类型，小string(属于原始类型String)
第二种（使用JS内置的支持类String）： var s2 = new String("abc");是Object类型，大String(属于Object引用类型)
需要注意的是：String是一个内置的类，可以直接用，String的父类是Object。
（3）无论小string还是大String，他们的属性和函数都是通用的！
（4）关于String类型的常用属性和函数？
常用属性：
length 获取字符串长度
常用函数：
indexOf 获取指定字符串在当前字符串中第一次出现处的索引
lastIndexOf 获取指定字符串在当前字符串中最后一次出现处的索引
replace 替换
substr 截取子字符串
substring 截取子字符串
toLowerCase 转换小写
toUpperCase 转换大写
split 拆分字符串
（5）重点：substr(2,4)和substring(2,4)的区别？
①substr(startIndex, length) 第一个参数是下标；第二个参数是长度，往后面数几个元素
② substring(startIndex, endIndex) 第一个参数是起始下标；第二个参数是结束下标；不包含结束下标endIndex；左闭右开！
③所以substr(2,4)是4个元素，substring(2,4)是2个元素
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
</head>
<body>
<script type="text/javascript">
// 小string(属于原始类型String)
var x = "abcd";
alert(typeof x); // "string"
// 大String(属于Object引用类型)
var y = new String("abc");
alert(typeof y); // "Object"
// 获取字符串的长度
alert(x.length); // 4
alert(y.length); // 3
// indexOf 获取指定字符串在当前字符串
alert("http://www.baidu.com".indexOf("http")); // 0
alert("http://www.baidu.com".indexOf("https")); // -1
// lastIndexOf 获取指定字符串在当前字符串中最后一次出现处的索引
alert("http://www.baidu.www.com".lastIndexOf("www")); // 17
// replace 替换(注意：只替换了第一个); 想全部替换需要使用正则表达式
// name=value&name=value#name=value
alert("name=value#name=value#name=value".replace("#","&"));
// substr 截取子字符串
// substr(startIndex, length)
alert("abcdef".substr(2,4)); // cdef
// substring 截取子字符串
// substring(startIndex, endIndex) 注意:不包含endIndex
alert("abcdef".substring(2,4)); // cd
// toLowerCase 转换小写
alert("AaBc".toLowerCase()); //aabb
// toUpperCase 转换大写
alert("AaBc".toUpperCase()); // AABB
// split 拆分字符串
alert("192.168.2.128".split(".")); // 192,168,2,128
</script>
</body>
</html>
6. Object数据类型
（1）Object类型是所有类型的超类，自定义的任何类型，默认继承Object。
（2）Object类包括哪些属性？
****prototype属性（很重要）：作用是给类动态的扩展属性和函数。
constructor属性
（3）Object类包括哪些函数？
toString()
valueOf()
toLocaleString()
（4）在JS当中定义的类默认继承Object，会继承Object类中所有的属性以及函数。
（5）在JS当中怎么定义类（和函数一样）？怎么new对象？
第一种方式：
function 类名(形参){
}
第二种方式：
类名 = function(形参){
}
创建对象的语法：
new 构造方法名(实参); 构造方法名和类名一致
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
</head>
<body>
<script type="text/javascript">
function sum(x,y){
alert(x+y);
}
// 当做普通函数调用
sum(10,20); // 30
// 当做类类创建对象
var obj = new sum(10,10); //20
// obj是一个引用,保存内存地址指向堆中的对象
alert(obj); // [object Object]
// JS中的类的定义,同时又是一个构造函数的定义
// 在JS中类的定义和构造函数的定义是放在一起来完成的
function User(sno, sname, sage){ // a b c是形参,属于局部变量
// 声明属性 (this表示当前对象)
// User类中有三个属性:sno/sname/sage
this.sno = sno;
this.sname = sname;
this.sage = sage;
}
// 创建对象
var u1 = new User(111,"zhangsan",30);
// 访问对象的属性
alert(u1.sno);
alert(u1.sname);
alert(u1.sage);
// 访问一个对象的属性,还可以使用这种语法
alert(u1["sno"]);
alert(u1["sname"]);
alert(u1["sage"]);
Product = function(pno,pname,price){
// 属性
this.pno = pno;
this.pname=pname;
this.price=price;
// 在类中定义函数
this.getPrice = function(){
return this.price;
}
}
// 创建对象,并调用
var pro = new Product(111,"香蕉",3.0);
var price = pro.getPrice();
alert(price); // 3.0
// 可以通过prototype这个属性来给类动态扩展属性以及函数
// 函数
Product.prototype.getPname = function(){
return this.pname;
}
// 调用后期扩展的getPname()函数
var pname = pro.getPname();
alert(pname); // 香蕉
// 给String扩展一个函数
String.prototype.zl = function(){
alert("这是给String类型扩展的一个函数");
}
// 随便一个字符串都能调用
"abc".zl(); // 这是给String类型扩展的一个函数
</script>
</body>
</html>
补充：Java和JS创建对象对比
**java语言怎么定义类，怎么创建对象？（强类型） **
public class User{
private String username;
private String password;
public User(){
}
public User(String username,String password){
this.username = username;
this.password = password;
}
}
User user = new User();
User user = new User("lisi","123");
JS语言怎么定义类，怎么创建对象？（弱类型）
User = function(username,password){
this.username = username;
this.password = password;
}
var u = new User();
var u = new User("zhangsan");
var u = new User("zhangsan","123");
7. null NaN undefined三者的区别
（1）null NaN undefined使用typeof运算符后的结果分别是：object、number、undefined
（2）null和undefined可以等同，使用"=="运算符判断后的结果是true；“==”只判断值是否相等！
（3）“===”全等运算符，即判断值是否相等，又判断数据类型是否相等；三者都不相等！
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
</head>
<body>
<script type = "text/javascript">
// null NaN undefined三者的区别
alert(typeof null); // "object"
alert(typeof NaN); // "number"
alert(typeof undefined); // "undefined"
// null和undefined可以等同
// ==(等同运算符，只判断值是否相等)
alert(null == NaN); // false
alert(null == undefined); // true
alert(NaN == undefined); // false
// ===(全等运算符，即判断值是否相等，又判断数据类型是否相等)
alert(null === NaN); // false
alert(null === undefined); // false
alert(NaN === undefined); // false
// 思考
alert(1 == true); // true
alert(1 === true); //false
</script>
</body>
</html>
