✅作者简介：一位材料转码农的选手，希望一起努力，一起进步！
📃个人主页：@每天都要敲代码的个人主页
🔥系列专栏：Web前端
💬推荐一款模拟面试、刷题神器，从基础到大厂面试题👉点击跳转刷题网站进行注册学习
一：变量
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>
（1）Js中的函数没有重载机制，因为是弱类型；JS当中的函数在调用的时候，参数的类型没有限制，并且参数的个数也没有限制；一个函数就相当于很多函数
（2）在JS当中，函数的名字不能重名，当函数重名的时候，后声明的函数会将之前声明的同名函数覆盖！
（3）JS中就只通过函数名来区分函数！
<!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关键字，那么不管这个变量是在哪里声明的，都是全局变量
<!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"
（4）在JS当中比较字符串是否相等使用“==”完成！没有equals方法。
<!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数据类型
（1）Number类型包括哪些值？
-1 0 1 2 2.3 3.14 100 .... NaN Infinity
整数、小数、正数、负数、不是数字、无穷大都属于Number类型。NaN (表示Not a Number，不是一个数字，但属于Number类型 Infinity (当除数为0的时候，结果为无穷大)（2）isNaN()函数 : 结果是true表示不是一个数字，结果是false表示是一个数字。
（3）parseInt()函数，可以将字符串自动转换成数字，并且取整数位
（4）parseFloat()函数，可以将字符串自动转换成数字
（5）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,while等里面传数据，会自动调用Boolean()函数进行转换！
<!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三者的区别
<!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>
结束语
今天的分享就到这里啦！快快通过下方链接注册加入刷题大军吧！
各种大厂面试真题在等你哦！
💬刷题神器，从基础到大厂面试题👉点击跳转刷题网站进行注册学习
版权归原作者 @每天都要敲代码 所有， 如有侵权，请联系我们删除。