荐通俗易懂简单自学javascript基础

程序员文章站 2022-04-14 13:58:55

Javascript基础基本知识：控制浏览器弹出一个警告框alert("帅帅帅")让浏览器在界面中输出一个内容(向body中输出一个内容)document.write("你好！！！")向控制台输出一个内容console.log("控制台你好！！！")可以将js代码写到标签的onclick属性中。不方便维护，不推荐使用。可以将js代码写在超链接...

Javascript基础

基本知识：

控制浏览器弹出一个警告框

alert("帅帅帅")

让浏览器在界面中输出一个内容(向body中输出一个内容)

document.write("你好！！！")

向控制台输出一个内容

console.log("控制台你好！！！")

可以将js代码写到标签的onclick属性中。不方便维护，不推荐使用。

<button onclick="alert('点我干嘛--');">点我点我</button>

可以将js代码写在超链接的href属性中，这样当点击超链接时会执行js代码（前面必须加上JavaScript：）

<a href="javascript:alert('让你点你就点-_-!');">也点我点我</a>

一般是写在js文件中用以下代码连接

<script type="text/javascript" src="./js/index.js"></script>

一但这个script标签用于引入外部js文件，那么这个script标签再编写代码将被浏览器忽略

如果需要则需要再写一个script标签

执行顺序从上到下执行

字面量

都是一些不可改变的量比如：1 2 3 4 5。字面量都是可以直接使用的，如下

alert(2132146489);

字面量都是可以直接使用，但是我们一般都不会直接使用字面量

变量

变量可以用来保存字面量，而且变量的值是可以任意改变的

变量更加方便使用，所以在开发中都是通过变量去保存一个字面量

很少直接使用字面量

**声明变量：**在js中使用var关键字来声明一个变量

var a;

需要给变量赋值

a = 123;

可以声明和赋值同时进行

var b = 846815;

变量声明提前

使用var关键字声明的变量，会在所有的代码执行之前被声明(但是不会赋值)

但是声明变量时不使用var关键字，则变量不会被声明提前
函数的声明提前

使用函数声明形式创建的函数function函数(){}

他会在所有的代码执行之前就被创建，所以这种方式写的函数可以在函数声明前来调用

使用函数表达式创建的函数，不会被声明提前

a = 123;
console.log(a);//输出 a = 123;

console.log(a);//输出 a=undefined  没有报错
var a = 123;

console.log(a);//报错
a = 123;

fun();//输出我是一个fun函数
fun2();//报错
function fun(){
    console.log("我是一个fun函数");
}
var fun2 = function(){
    console.log("我是fun2函数");
}

标识符

在js中所有的可以由我们自主命名的都可以称为是标识符

例如：变量名、函数名、属性名都属于标识符

命名一个标识符时需要遵守如下的规则：

1.标识服中可以含有字母、数字、_、$

2.标识符不能以数字开头

3.标识符不能是ES中的关键字或保留字

4.标识符一般采用驼峰命名法（首字母小写，每个开头字母大写，其余字母小写。不强制要求，但是是个好习惯）

5.JS底层保存标识符时实际上是采用Unicode编码，所以理论上讲，所有的utf-8中含有的内容都可以作为标识符

6.var只在声明变量时使用，在后续需要修改时不需要再重复给一个变量var

var a_1$ = 3;
var var = 3；//不能这样
helloWorld   xxxYyyZzz//驼峰命名法

var 我最帅 = 384;//可以用，但是不推荐这样用，不符合行业规范

var str1 = 1;
str1 = 2;//最后命名的变量值有效

数据类型

数据类型指的就是字面量的类型

在JS中一共有六种数据类型：

String 字符串
Number 数值
Boolean 布尔值
Null 空值
Undefined 未定义
Object 对象

其中String Number boolean Null Undefined属于基本数据类型，而Object属于引用数据类型

用法

String 字符串

在Js中字符串需要使用引号引起来

单引号和双引号都可以用没区别，但是不要混着用

不要在双引号中放双引号

可以在单引号中用双引号

在字符串中我们可以使用\作为转义字符，当表示一些特殊符号时可以使用\转义

var str = "hello";
console.log(str);
var str = 'hello"; //不要混着用
var str = "我说："今天天气真不错！"";//这样不对，会把”我说：“看做一个变量
var str = '我说："今天天气真不错！"';//这样可以
var str = "我说：\"今天天气真不错！\"";//这样也可以，让里面的双引号仅仅代表双引号
\' 表示 ’
\" 表示 "
\n 表示换行
\t 制表符   
\\ 表示\      我转义我自己

Number 数值

在JS中所有数值都是Number类型，包括整数和浮点数（小数）

数字123和字符123完全不同

可以使用一个typeof来检查一个变量类型 typeof+变量

JS中可以表示数字的最大值：Number.MAX_VALUE

可以用Number.MAX_VALUE*Number.MAX_VALUE，取最大值的平方

如果超过了最大值则会输出Infinity，表示正无穷；-Infinity表示负无穷

用两个字符串相乘：abc*bcd会输出NaN；NaN是一个特殊的数字，表示Not a number（不是数字）

使用typeof检查NaN会返回number

Number.MIN_VALUE的值为0以上的最小值0.000000…

在Js中整数的运算基本可以保证精确

如果使用JS进行浮点元素的计算，可能的到一个不精确的解果；因为二进制无法精确1/10;

可以把后面的数字给省略掉，但前提是不能涉及到钱，所以不要用JS计算精确度要求比较高的运算

var a = 123;//数字123
var b = "123";//字符123
console.log(typeof a)//检查字符串时，会返回string；检查数值时，会返回number
console.log(Number.MAX_VALUE);
a = Number.MAX_VALUE*Number.MAX_VALUE;//会输出Infinity，

a = "abc"*"bcd"//输出NaN
console.log(typeof a)//会输出number

a = Number.MIN_VALUE
console.log(a)//输出5e-324

var c = 1234456 + 4894894;//输出结果正确
var c = 0.1 + 0.2;//输出结果为0.30000000000000000004

Boolean 布尔值

布尔值只有两个：true、false；真、假。主要用来做逻辑判断

true：表示真

false：表示假

使用typeof检查会输出boolean

var bool = ture;
console.log(bool);//输出为true
console.log(typeof bool)//输出为boolean

Null类型的值只有一个，就是Null

null（空值）专门用来表示为空的对象

使用typeof检查null会返回Object

Undefined（未定义）类型的值只有一个，就是Undefined

当声明一个变量，但是不给变量赋值时，他的值就是Undefined

var a = null;
console.log(a);//输出就是null
console.log(typeof a);//输出是Object
var b = undefined;
console.log(typeof b);//输出是undefined

其他进制数字

在js中如果需要表示16进制的数字，则需要以0x开头
如果要表示8进制的数字，则需要以0开头
如果要表示2进制的数字，则需要以0b开头，但是不是所有的浏览器都支持
输出的时候会转换为10进制输出

//16进制
var a = 0x10;
console.log(a);//输出为16

//8进制
var a = 070;
console.log(a);//输出为56

强制类型转换

指讲一个数据类型强制转换为其他的数据类型
类型转换主要指，将其他的数据类型，转换为：String、Number、Boolean

将其他的数据类型转换为String

方式一

调用被转换数据类型的toString()方法

该方法不会影响到原变量，会将转换的结果返回

但是要注意Null和Undefined这两个值没有toString方法，如果用这个方法调用会报错

方式二

调用String()函数，并将被转换的数据作为参数传递给函数

String（）函数做强制类型转换时对于Number和Boolean实际上就是调用toString()方法

但对于Null和Undefined，就不会和toString（）一样，他会将Null和Undefined直接转换为字符串“Null”和“Undefined”

将其他数据类型转换为Number

没有toNumber方式

方式一

使用Number()函数

1.如果是纯数字的字符串，则将其转换为数字

2.如果字符串中有非数字的内容，则转换为NaN

3.如果字符串为空串或者是一个全空格的字符串，则转换为数字0

4.true转换成数字1，false转换成数字0，Null转换成数字0，Undefined转换为NaN

方式二

这种方式专门用来对付字符串

parseInt（）把一个字符串转换为一个整数

可以将一个字符串中有效的整数内容取出来然后转换为Number，只读到从左到右第一个不为数字的地方

parseFloat（）把一个字符串转换为一个浮点数（小数）

可以将一个字符串的有效的小数取出，如果有两个小数点，则读到第二个小数点前

如果对String使用parseFloat（）、parseInt（），他会将其先转换为string，然后再操作

将其他数据类型转换为Boolean类型

方式

使用Boolean（）函数

数字转Boolean，除了0和NaN其余的都是true

字符串转Boolean，除了空串其余的都是true

Null与Undefined转换为Boolean，都是false

//将其他的数据类型转换为String
//方式一：
var a = 123;
console.log(typeof a);//输出为Number
console.log(a);//输出为123

a.toString();//调用a的toString()方法
console.log(typeof a);//输出仍为Number

var b = a.toString();
console.log(typeof b);//输出为String
console.log(b);//输出为123

a = a.toString();//可以赋值给自己
console.log(typeof a);//输出为String
console.log(a);//输出为123

a = true;
a = toString();
console.log(typeof a);//输出为String
console.log(a);//输出为true

a = Null;
a = toString();//报错

a = Undefined;
a = toString();//报错


//方式二：
var a = 123;
String(a);
console.log(typeof a);//输出为Number
console.log(a);//输出为123

a = 123;
a = String(a);
console.log(typeof a);//输出为String
console.log(a);//输出为123

a = Null;
a = String(a);
console.log(typeof a);//输出为String
console.log(a);//输出为Null

a = Undefined;
a = String(a);
console.log(typeof a);//输出为String
console.log(a);//输出为Undefined


//将其他数据类型转换为Number：
//方式1：
var a = "123";
Number(a);
console.log(typeof a);//输出为Number
console.log(a);//输出为123

var a = "abc";
Number(a);
console.log(typeof a);//输出为Number
console.log(a);//输出为NaN

var a = "";
Number(a);
console.log(typeof a);//输出为Number
console.log(a);//输出为0

var a = true;
Number(a);
console.log(typeof a);//输出为Number
console.log(a);//输出为1

var a = false;
Number(a);
console.log(typeof a);//输出为Number
console.log(a);//输出为0

var a = Null;
Number(a);
console.log(typeof a);//输出为Number
console.log(a);//输出为0

var a = Undefined;
Number(a);
console.log(typeof a);//输出为Number
console.log(a);//输出为NaN

//方式二：parseInt();
var a = "123px";
Number(a);
console.log(typeof a);//输出为Number
console.log(a);//输出为NaN

var a = "123px";
parseInt(a);
console.log(typeof a);//输出为Number
console.log(a);//输出为123

var a = "123a564px";
parseInt(a);
console.log(typeof a);//输出为Number
console.log(a);//输出为123

var a = "a123px";
parseInt(a);
console.log(typeof a);//输出为Number
console.log(a);//输出为NaN

var a = "123.456px";
parseInt(a);
console.log(typeof a);//输出为Number
console.log(a);//输出为123

var a = 123.456;
parseInt(a);
console.log(typeof a);//输出为Number
console.log(a);//输出为123,可以用来取整

//parseFloat();
var a = "123.456px";
parseFloat(a);
console.log(typeof a);//输出为Number
console.log(a);//输出为123.456

var a = "123.456.789px";
parseFloat(a);
console.log(typeof a);//输出为Number
console.log(a);//输出为123.456

var a = "true";
parseFloat(a);
console.log(typeof a);//输出为Number
console.log(a);//输出为NaN

//转换其他进制时
//转换8进制，这种字符串，有些浏览器（IE）会当成8进制解析，有些浏览器会当成10进制解析
var a = 070;
a = parseInt(a);
console.log(typeof a);//输出为Number
console.log(a);//输出为56（或70）

//可以在parseInt（）中传递第二个参数，来制定数字的进制
var a = 070;
a = parseInt(a,10);//把070当做10进制看
console.log(typeof a);//输出为Number
console.log(a);//输出为70

var a = 070;
a = parseInt(a,8);//把070当做8进制看
console.log(typeof a);//输出为Number
console.log(a);//输出为56

//将其他数据类型转换为Boolean类型
//数字转换为Boolean：
var a = 123;
a = Boolean(a)
console.log(typeof a);//输出为Boolean
console.log(a);//输出为true

var a = 0;
a = Boolean(a)
console.log(typeof a);//输出为Boolean
console.log(a);//输出为false

a = -123;//true
a = Infinity;//true
a = NaN;//false
a = "true"


//字符串转换为Boolean：
var a = "";
a = Boolean(a)
console.log(typeof a);//输出为Boolean
console.log(a);//输出为false


//Null与Undefined转换为Boolean：
var a = Null;
a = Boolean(a)
console.log(typeof a);//输出为Boolean
console.log(a);//输出为false

var a = Undefined;
a = Boolean(a)
console.log(typeof a);//输出为Boolean
console.log(a);//输出为false

运算符

运算符也叫作操作符
通过运算符可以对一个或多个值进行运算
比如：typeof就是运算符，可以用来获得一个值的类型，他会将该值的类型以字符串的形式返回

var a = 123;
var result = typeof a;
console.log(result);//输出number
console.log(typeof result);//输出string

算数运算符

+可以对两个值进行加法运算，并将值返回，如果对字符串进行加法操作则会对两个字符串做拼接处理，任何值和字符串做加法运算都是要将其转换成字符串然后再拼串处理；可以利用这一特点可以将任意类型的数据加一空串""就可以将这个数据类型变为字符串类型
-可以对两个值进行减法运算，并将值返回
*可以对两个值进行乘法运算，并将值返回
/可以对两个值进行除法运算，并将值返回
%取模运算（取余数）
对于非Number类型的值进行运算时，会将这些值转换成Number然后运算(除了加法)，可以通过给一个值-0，*1，/1,都可以转换为number类型
任何值和NaN做运算都得NaN

var a = 1;
var result;
result = a + 1;//输出2
result = true + 1;//输出2
result = true + false;//输出1
result = null + 1;//输出1
result = NaN + 1;//输出NaN
result = "123" + "456";//输出123456；string类型
result = "你好" + "帅哥";//输出你好帅哥；string类型
var str = "锄禾日当午，" +    //双引号必须在一行
          "汗滴禾下土。" +
          "谁知盘中餐，" +
          "粒粒皆辛苦。";
console.log(str);//输出锄禾日当午，汗滴禾下土。谁知盘中餐，粒粒皆辛苦。
var c = 123;
c = c + "";
console.log(typeof c);//输出为string
console.log(c);//输出为123

//减法：
var result;
result = 100 - "1";//输出99
result = 2 * "8";//输出16


var c = 123;
c = c - 0;
console.log(typeof c);//输出为number
console.log(c);//输出为123

//取模：
var a = 9 % 3;
console.log(a);//输出为0

var a = 9 % 4;
console.log(a);//输出为1

一元运算符

一元运算符只需要一个操作数
- +：正号
- - 正号不会对数字产生任何影响，可以将其他类型转换为number类型
- -：负号
- - 负号可以对数字进行数字取反,对于非number值，先转换成number再进行取反

var a = 123;
a = +a;
console.log(a);//输出为123

var a = 123;
a = -a;
console.log(a);//输出为-123

var a = true;
a = -a;
console.log(a);//输出为-1
console.log(typeof a);//输出为number

var a = "123";
a = +a;
console.log(a);//输出为123
console.log(typeof a);//输出为number

var a;
a = 1 + "2" + 3;
console.log(a);//输出为123
console.log(typeof a);//输出为string

var a;
a = 1 + +"2" + 3;
console.log(a);//输出为6
console.log(typeof a);//输出为number

自增自减

自增：++
- 通过自增可以使变量在自身的基础上增加1
- 对一个变量自增后，原变量会立即加1
- 自增分为两种:后++（a++）和前++（++a）
- - 无论是a++还是++a都立即使原变量的值自增1
  - 不同的是a++和++a的值不同
  - - a++的值等于原变量的值（自增前的值）
    - ++a的值等于原变量自增后的值
自减："–"
- 通过自减可以使变量在自身的基础上减1
- 对一个变量自减后，原变量会立即减1
- 自减分为两种:后"–"（a"–"）和前"–"（"–"a）
- - 无论是a"–“还是”–"a都立即使原变量的值自减1
  - 不同的是a"–“和”–"a的值不同
  - - a"–"的值等于原变量的值（自减前的值）
    - "–"a的值等于原变量自减后的值

//自增：
var a = 1;
a++;
console.log(a);//输出为2

var a = 1;
console.log(a++);//输出为1
console.log(a);//输出为2

var a = 1;
++a;
console.log(a);//输出为2

var a = 1;
console.log(++a);//输出为2
console.log(a);//输出为2

var a = 20;
a = a++ + ++a +a;//20+22+22
console.log(a);//输出为2

//自减：与自加一样
var b = 10;
b--;
console.log(b);//输出为9

var b = 10;
--b;
console.log(a);//输出为9

逻辑运算符

js中为我们提供了3种逻辑运算符

&&与
- 可以对符号两侧的值进行与运算，并返回结果
- 两个值中只要有一个值为false就返回false，两个都是true才能返回true
- JS中的“与“属于短路的与，如果第一个值为false就不再看后面的值
||或
- 可以对符号两侧的值进行或运算，并返回结果
- 只要有一个true就返回true
- JS中的“或“属于短路的或，如果第一个值为true就不再看后面的值
！非
- 可以对一个值进行非运算
- - 就是对一个布尔值进行取反操作
  - 如果对一个非布尔值进行运算，则会将其转换为布尔值然后取反
  - 可以利用这个特点将其他类型转换为布尔值

//&&与
var result = true && true;
console.log(result);//输出为true
console.log(typeof result);//输出为Boolean

var result = true && false;
console.log(result);//输出为false
console.log(typeof result);//输出为Boolean

var result = false && false;
console.log(result);//输出为false
console.log(typeof result);//输出为Boolean

var result = true && alert("你看我出不出来！！");//运行弹出"你看我出不出来！！"

var result = false && alert("你看我出不出来！！");//运行没有弹出"你看我出不出来！！"

//||或
var result = false || false;
console.log(result);//输出为false
console.log(typeof result);//输出为Boolean

var result = true || false;
console.log(result);//输出为true
console.log(typeof result);//输出为Boolean

var result = true || true;
console.log(result);//输出为true
console.log(typeof result);//输出为Boolean

var result = true && alert("你看我出不出来！！");//运行没有弹出"你看我出不出来！！"

var result = false && alert("你看我出不出来！！");//运行弹出"你看我出不出来！！"

//!非
var a = true;
a = !a;
console.log(a);//输出为false

var a = true;
a = !!a;
console.log(a);//输出为true

var a = 10;
a = !a;
console.log(a);//输出为false
console.log(typeof a);//输出为Boolean

var a = 10;
a = !!a;
console.log(a);//输出为true
console.log(typeof a);//输出为Boolean

对于非布尔值进行与或运算时，会将其转换为布尔值，然后再运算，并且返回原值
- 与运算：如果第一个值为true，则直接返回第二个值，如果第一个值为false，则直接返回第一个值（找false）
- 或运算：如果第一个值为true，则直接返回第一个值，如果第一个值为false，则直接返回第二个值（找true）

//与：
var a = 1 && 2;
console.log(a);//输出为2

var a = 2 && 1;
console.log(a);//输出为1

var a = 0 && 1;
console.log(a);//输出为0

var a = 1 && 0;
console.log(a);//输出为0

var a = NaN && 0;
console.log(a);//输出为NaN

var a = 0 && NaN;
console.log(a);//输出为NaN

//或：
var a = 2 || 1;
console.log(a);//输出为2

var a = 1 || 0;
console.log(a);//输出为1

var a = 1 || NaN;
console.log(a);//输出为1

var a = NaN || 1;
console.log(a);//输出为1

var a = NaN || 0;
console.log(a);//输出为1

赋值运算符

=：可以将符号右侧的值赋值给符号左侧的变量
+=:a = a + 5等价于a = a + 5（+=不能分开写成+ =）
-=:a = a - 5等价于a = a - 5（-=不能分开写成- =）
=:a = a * 5等价于a = a * 5（=不能分开写成 * =）
/=:a = a / 5等价于a = a / 5（/=不能分开写成/ =）
%=:a = a % 5等价于a = a % 5（%=不能分开写成% =）

var a = 123;
console.log(a);//输出为123

var a = 10;
a = a + 5;
console.log(a);//输出为15

var a = 10;
a += 5;
console.log(a);//输出为15

var a = 10;
a -= 5;
console.log(a);//输出为5

var a = 10;
a *= 5;
console.log(a);//输出为50

var a = 10;
a /= 5;
console.log(a);//输出为2

var a = 10;
a %= 5;
console.log(a);//输出为0

关系运算符

通过关系运算符可以比较两个值之间的关系，如果关系成立则返回true，不成立则返回false
">"判断左侧关系是否大于右侧，若大于则立即返回true，如果关系不成立则返回false
">="判断左侧关系是否大于或等于右侧，若大于或等于则立即返回true，如果关系不成立则返回false
"=="判断左右是否相等，相等返回true，不相等返回false，NaN不和任何值比较包括他本身，可以用函数isNaN()来判断一个值是否是NaN
"==="全等和相等类似，但是他不会做自动转换，如果两个值类型不同直接返回false
"！=="不全等和不等类似，但是他不会做自动转换，如果两个值类型不同直接返回true
"!="判断左右是否相等，不相等返回true，相等返回false
"<="判断左侧关系是否小于或等于右侧，若小于或等于则立即返回true，如果关系不成立则返回false
"<"判断左侧关系是否小于右侧，若小于则立即返回true，如果关系不成立则返回false
对于非数值类型判断，则先将其转化为数值类型再判断
任何数和NaN比都是false
如果符号两侧的值都是字符串时，不会将其转换为数字进行比较，而是比较的Unicode编码，一位一位的对位比较，所以可以借用这个方法对英文进行排序，比较中文没有意义，对于两个字符串的数字比较一定要转型

var a = 5 > 10;
console.log(a);//输出为false

var a = 5 > 4;
console.log(a);//输出为true

var a = 5 > 5;
console.log(a);//输出为false

var a = 5 >= 5;
console.log(a);//输出为true

var a = 1 > true;
console.log(a);//输出为false

var a = 1 >= true;
console.log(a);//输出为false

var a = 1 > "0";
console.log(a);//输出为true

var a = 1 > NaN;
console.log(a);//输出为false，任何数和NaN比都是false

var a = true > false;
console.log(a);//输出为true

var a = "5" < "11";
console.log(a);//输出为true

var a = "11" < "5";
console.log(a);//输出还是true

var a = "11" < +"5";
console.log(a);//输出还是false

var a = "a" < "b";
console.log(a);//输出是true

var a = "b" < "a";
console.log(a);//输出是false

var a = "abc" < "b";
console.log(a);//输出是true，一位一位进行比较

var a = "bbc" < "b";
console.log(a);//输出是false，一位一位进行比较

var a = "b" < "a";
console.log(a);//输出是false

var a = NaN == NaN;
console.log(a);//输出是false

var a = NaN;
console.log(isNaN(a));//输出是true

条件运算符

条件运算符又叫三元运算符：“条件表达式?语句1:语句2”
条件运算符在执行时，首先对条件表达式进行求值
- 如果该值为true则执行语句1，并返回执行结果0
- 如果该值为false则执行语句2，并返回执行结果
如果条件表达式的求值结果是一个非布尔值，会将其转化为布尔值，然后再运算

true?alert("语句1"):alert("语句2");//执行语句1
false?alert("语句1"):alert("语句2");//执行语句2

var a = 10;
var b = 20;
a > b ? alert("a大"):alert("b大");//b大

//获取a和b中的最大值
var a = 10;
var b = 20;
var max = a > b ? a : b; 
console.log(max)//输出b

//获取a和b、c中的最大值
var a = 10;
var b = 20;
var c = 50;
var max = a > b ? a : b; 
max = max >c ? max : c;
console.log(max)//输出c

var a = 10;
var b = 20;
var c = 50;
var max = a > b ? a > c ? a : c : b > c ? b : c; 
//a > b ? (a > c ? a : c) : (b > c ? b : c);     不推荐使用，不方便阅读
console.log(max)//输出50



"hello"?alert("语句1"):alert("语句2");//执行语句1
""?alert("语句1"):alert("语句2");//执行语句2

运算符的优先级

, 运算符：使用，可以分割多个语句，一般可以在声明多个变量时使用（用的最多）

var a , b , c;
var a = 1 , b = 2 , c = 3;

和数学中一样，JS中运算符也有优先级
先乘除后加减

var result = 1 + 2 * 3;
console.log(result)//输出7

&&的优先级比||高
在Js中有一个运算优先级的表，在表中越靠上优先级越高，优先级高的优先计算，如果优先级一样高，则从左到右计算，这个表不需要硬记，如果遇到优先级不清楚的，用（）分开

var result = 1 || 2 && 3;
console.log(result)//输出1

Unicode编码

在字符串中使用转义字符输入unicode编码，\u+四位编码

console.log("\u0031");//输出1
console.log("\u2620");//输出☠（骷髅头）

要在网页中使用Unicode编码

<h1>
    &#编码<!--这里的编码需要的是10进制-->
</h1>

代码块（语句）

我们的程序就是由一条条语句构成的
执行的时候从上到下执行
用{}为语句分组
同一个{}我们称为一组语句，要么都执行要么都不执行。也叫作代码块，在}=后不用加；
Js中的代码块只有分组的作用没有其他的作用

elert("hello");//这就是语句

注意

js中严格区分达小写
js中每一条语句以分号结尾（如果不写分号，浏览器会自动添加，但是会消耗一些系统资源，有些时候浏览器会加错分号，所以在开发中必须加分号）
js会忽略多个空格和换行，所以我们可以利用空格和换行对代码进行格式化

注释

多行注释/**/

单行注释//

本文地址：https://blog.csdn.net/xing_kai_kai/article/details/107265531

上一篇：搭建Istio基础环境

下一篇：关于学习方法的思考