3.JS语言
有些网站的参数是密文，有些时候返回的是密文，
这些时候你拿明文去请求他网站是不知道的，
所以我们叫模拟请求。
有时候是在头部的参数做的加密
有的时候是在载荷里做的参数加密
有的时候是在cookie里做的加密
所以学习JS的目的就是去模拟它的算法生成的请求
有些网站他返回的是密文，那为什么在浏览器上能看到明文呢，因为他在前端有解密。
所以就要用JS逆向去分析它。
OK，开始学习~
在网页页面右键点击显示网页源代码
这些<script>的标签，在这个标签里面的代码，就是JS代码，
这是可以从网页上直接执行的
所以这个js是什么？
全程Javascript
是一种具有函数优先的轻量级解释型
这个语言呢，他可以去操作操作这个网页上的标签，去去做一些脚本的逻辑，和一些网页动画这种，
但是咱们只涉及用js去模拟他的算法,
然后他有几种
运行方法
一种是在命令行输入node
然后也可以在vscode中编辑.js文件运行
console.log("123")注释
在想要注释的那一行摁Ctrl + /
macOS中是command + /
取消注释就是再摁一遍command + /
多行注释
多行注释
/*
console.log("123")
console.log("123")
console.log("123")
console.log("123")
console.log("123")
*/注释的作用不光用于注释代码，
还能帮助别人更清晰的读懂你写的代码
规范
规范的书写代码是要有分号的。
变量
js有三种变量声明(赋值)的方式
全局变量var
声明一个变量，但是没给他赋值
var name ;
console.log(name)
运行
/usr/local/bin/node ./.idea/111.js
undefined结果是未定义
现在给name赋值'ABC'
var name = 'ABC'
console.log(name)
运行
/usr/local/bin/node ./.idea/111.js
ABC可以多个变量名用一个变量值
var name1,name2,name3 = '李大爷';
console.log(name1,name2,name3)
运行
/usr/local/bin/node ./.idea/111.js
undefined undefined 李大爷这种结果肯定不是想要的，
如果想要输出3个李大爷
var name1 = '李大爷',name2 = '李大爷',name3 = '李大爷';
console.log(name1,name2,name3)
运行
/usr/local/bin/node ./.idea/111.js
李大爷 李大爷 李大爷作用域
它的作用域是函函数作用域里边，或者是全局作用域
var优先级是最高的
let 块级作用域，只作用在他的块里面！
什么是块，{}这个就是块，
在这个花括号里面就是块
function example() {
var x = 1;
let y = 2;
if (true) {
var x = 3; // 在函数作用域内,覆盖了之前的变量x
let y = 4; // 在块级作用域内,创建了一个新的变量y
console.log(x); // 输出 3
console.log(y); // 输出 4
}
console.log(x); // 输出 3,因为var声明的变量x被要盖了
console.log(y); // 输出 2,因为let声明的变量y的作用域仅在if语句块内
}
example();运行
/usr/local/bin/node ./.idea/111.js
3
4
3
2var 可以直接name
而let是声明后才可以访问，而且不可以重复声明。
let x = 1;
let x = 2;
console.log(x)
运行
报错!!! 无法重复声明想要修改的话只能这么写
let x = 1;
x = 2;
console.log(x)
运行
/usr/local/bin/node ./.idea/111.js
2常量const
他也是作用域，跟let一样在{}内
他声明的是常量，就是不可以改的
常量变量名字一般用大写！！!
const NAME = '李大爷';
NAME = '王大爷';
console.log(NAME)
运行
报错！！！ 常量是不可以改的！！！也不能重新定义。
====================================
全局就用var,局部就用let,常量就用const。
这就是三种变量的声明方式。
====================================
不能使用他语言中保留的关键字
当然声明的时候不能使用他语言中保留的关键字
1.通用保留关键字
break delete function return typeof
case do if switch var
catch else in this void
continue false instanceof throw while
debugger finally new true with
default for null try
2.ECMAScript 5 增加保留
class const enum export extends
import super
3.普通下合法，但严格模式下是保留的
implements let private public yield
interface package protected static
4.严格模式下做了严格限制，并不完全是保留字，但不能用作变量名，函数名或参数名
arguments eval
5.ECMAScript3关键字
abstract double goto native static
boolean enum implements package super
byte export import private synchronized
char extends int protected throws
class final interface public transient
const float long short volatile
6.Javascript预定义了很多全局变量和函数，应当避免把它们的名字用做变量名和函数名:
arguments encodeURI Infinity Number RegExp
Array encodeURIComponent isFinite Object String
Boolean Error isNaN parseFloat SyntaxError
Date eval JSON parseInt TypeError
decodeURI EvalError Math RangeError undefined
decodeURIComponent Function NaN ReferenceError URIError就比如
var if = '2333';
console.log(if)
运行
/usr/local/bin/node ./.idea/111.js
Process exited with code 1
Uncaught SyntaxError /Users/Desktop/Javascript/.idea/111.js:41
var if = '2333';
^^
报错了！！！如果你换一份关键字if换成If就可以
var If = '2333';
console.log(If)
运行
/usr/local/bin/node ./.idea/111.js
2333变量命名规则
构造变量名称（唯一标识符）的通用规则是：
名称可包含字母、数字、下划线和美元符号
名称必须以字母开头
名称也可以
$和_开头名称对大小写敏感（y 和 Y 是不同的变量）
保留字（比如 JavaScript 的关键词）无法用作变量名称
提示：JavaScript 标识符对大小写敏感。
// 变量命名规则
var asd = "aaa"
var ASD = "bbb" 大小写敏感
var _0x123='123'
var 名字='李大爷'
var $sadadsa = "1"
var 1asd = "2" 这种不行！！！（数字开头）基本数据类型
var name = '李大爷';
var age = 80;
//int类型在js里它叫number类型
var sbssb = true;
//布尔类型 true or false
var aaaa = null;
//null 空类型
var lll;
//未定义类型
var work = {'city':'beijing','zhiye':'baoan'}
//JS叫对象类型,在Python中叫字典
var ccc = function(){
return 123;
}
//function类型怎么查看类型呢，用typeof查看
console.log('name', typeof name)
console.log('age', typeof age)
console.log('sbssb', typeof sbssb)
console.log('aaaa', typeof aaaa)
console.log('lll', typeof lll)
console.log('work', typeof work)
console.log('ccc', typeof ccc)
运行
/usr/local/bin/node ./.idea/111.js
name string
age number
sbssb boolean
aaaa object
lll undefined
work object
ccc function数组
相当于Python中的列表
var xxx = ['1','a','b'];
console.log(xxx, typeof xxx)
运行
/usr/local/bin/node ./.idea/111.js
(3) ['1', 'a', 'b'] object
这是数组，但是JS他会说是对象类型。。。运算符
逻辑运算符
运算符 | 描述 |
|---|---|
&& | 逻辑与 |
|| | 逻辑或 |
! | 逻辑非 |
逻辑与
与要在所有条件都为真结果才为真，
var a=1,b = 5,c = 10;
res = a > b && b > c;
// 假 假
console.log(res)
输出false
逻辑或
或是多个条件中只要有一个是真就为真，
res = a > b || b > c;
// 真 假
输出true
逻辑非
假假为真
res = !(a > b); //!感叹号是反义词
console.log(res)
输出true比较运算符
运算符 | 描述 |
|---|---|
== | 等值，不判断类型 |
=== | 等值同时等类型 |
!= | 不相等 |
!== | 不等值或不等型 |
> | 大于 |
< | 小于 |
>= | 大于或等于 |
<= | 小于或等于 |
? | 三元运算符 |
==等于是判断值，===等于是判断值和类型都要相同
同理!=和!==
三元运算
res = x > 9 ? x = 1 : x = 2;
判断?前面的语句x > 9如果为真，
他就会执行后面:左边x = 1的内容，
如果为假就执行:右边x = 2的内容赋值运算符
赋值运算符向 JavaScript 变量赋值。
运算符 | 例子 | 等同于 |
|---|---|---|
= | x = y | x = y |
+= | x += y | x = x + y |
-= | x -= y | x = x - y |
*= | x *= y | x = x * y |
/= | x /= y | x = x / y |
%= | x %= y | x = x % y |
算数运算符
算数运算符用于对数字执行算数运算：
运算符 | 描述 |
|---|---|
+ | 加法 |
- | 减法 |
* | 乘法 |
/ | 除法 |
% | 取模（余数） |
++ | 递加 |
-- | 递减 |
取整是
aaa = Math.ceil(3/2)
console.log(aaa)
结果是2
输出是1.5取整变成2运算符的补充
var a;
var b=3;
console.log(a=++b,b) ++b是先运算再赋值
console.log(a=b++,b) b++是先赋值再运算
运行
4 4
4 5
这段代码的执行过程如下：
var a;：声明了变量 a，但没有给它赋值，所以此时 a 的值为 undefined。
var b=3;：声明了变量 b 并赋值为 3。
console.log(a=++b,b);在这里，++b 先执行自增操作，将 b 的值增加为 4，然后将结果赋给 a。所以此时 a 的值为 4，b 的值也为 4。
因此，最后输出的结果为 4 4。
console.log(a=b++,b);在这里，b++ 先将 b 的值（初始为 4）赋给 a，然后再自增。所以此时 a 的值为 4，b 的值为 5。
因此，最后输出的结果为 4 5。同样的
var a;
var b=3;
console.log(a=--b,b)
console.log(a=b--,b)
运行
2 2
2 1
console.log(a=--b,b);在这里，--b 先执行自减操作，将 b 的值减少为 2，然后将结果赋给 a。所以此时 a 的值为 2，b 的值也为 2。
因此，第一个 console.log 输出的结果为 2 2。
console.log(a=b--,b);在这里，b-- 先将 b 的值（初始为 2）赋给 a，然后再自减。所以此时 a 的值为 2，b 的值为 1。
因此，第二个 console.log 输出的结果为 2 1。类型运算符
运算符 | 描述 |
|---|---|
typeof | 返回变量的类型。 |
instanceof | 返回 true，如果对象是对象类型的实例。 |
位运算符
位运算符处理 32 位数。
该运算中的任何数值运算数都会被转换为 32 位的数。结果会被转换回 JavaScript 数。
运算符 | 描述 | 例子 | 等同于 | 结果 | 十进制 |
|---|---|---|---|---|---|
& | 与 | 5 & 1 | 0101 & 0001 | 0001 | 1 |
| | 或 | 5 | 1 | 0101 | 0001 | 0101 | 5 |
~ | 非 | ~ 5 | ~0101 | 1010 | 10 |
^ | 异或 | 5 ^ 1 | 0101 ^ 0001 | 0100 | 4 |
<< | 零填充左位移 | 5 << 1 | 0101 << 1 | 1010 | 10 |
>> | 有符号右位移 | 5 >> 1 | 0101 >> 1 | 0010 | 2 |
>>> | 零填充右位移 | 5 >>> 1 | 0101 >>> 1 | 0010 | 2 |
上例使用 4 位无符号的例子。但是 JavaScript 使用 32 位有符号数。
因此，在 JavaScript 中，~ 5 不会返回 10，而是返回 -6。
~00000000000000000000000000000101 将返回 11111111111111111111111111111010。
字符串操作
字符串的拼接，
+号拼接
var a = 'hello'
var b = 'world'
console.log(a+' '+b)
运行
hello world模版`${a} ${b}`
var a = 'hello'
var b = 'world'
var c = '${a} ${b}'
console.log(c)
运行
${a} ${b}
因为''号不对,要使用这个``
var c = `${a} ${b}`
运行
hello world使用concat方法拼接字符串
var a = 'hello'
var b = 'world'
var c = a.concat(" ",b) //这里使用,b或者+b都可以
console.log(c)
运行
hello world字符串的操作方法
这些都是方法，还有很多，
求字符串的长度。
var a = '王大爷'
console.log(a.length)
运行
3字符串小写变大写
var a = 'abcd'
console.log(a.toUpperCase()) //变大写
console.log(a.toLowerCase()) //变小写
运行
ABCD
abcd索引
a: a b c d
索引: 0 1 2 3var a = 'abcd'
console.log(a.charAt(0)) //按照索引位输出
console.log(a.charAt(1))
console.log(a.charAt(2))
运行
a
b
c截取
var a = 'abcd'
// 0123
console.log(a.slice(1,3)) //跟Python一样，顾头不顾尾,
运行
bc 只管第一个截取的位，不管最后一个截取的位分割
var a = 'abcd'
console.log(a.split('b'))
//以b作为分割，输出被分割前面的部分和后面的部分
运行
(2) ['a', 'cd']查找指定字符串的位置
var a = 'abcd'
// 0123
console.log(a.indexOf('c'))
//首先知道这个值是在这个字符串中，然后查看它的位置。
运行
2替换字符串
单个
var a = 'abcdbbb'
console.log(a.replace('b','z'))
//它只会替换第一个匹配上的字符
运行
azcdbbb都替换
var a = 'abcdbbb'
console.log(a.replace(/b/g,'z'))
//它只会替换第一个匹配上的字符
运行
azcdzzz去除两端的空格
(字符串中间的空格不进行操作)
trim() 方法用于去除字符串两端的空格
var a = ' abc dbb b '
console.log(a.trim())
运行
abc dbb b
发现两端的空格被去除了，但是中间的空格并没有被去除。去除所有空格
var a = ' abc dbb b ';
console.log(a.replace(/\s+/g, ''));
正则匹配/\s+/g然后替换成''空/\s+/g 是一个正则表达式，用来匹配所有的空格字符（包括空格、制表符、换行符等），g 表示全局匹配。replace() 方法将所有匹配的空格字符替换为空字符串，从而去除了字符串中间的空格。
把其他类型转成String格式，
用toString()方法
然后
JS切片
var a = 'abcd'
// 0123
console.log(a[1])
运行
bPython方法
a = 'abcd'
// 0123
print(a[1:2])
//也是顾头不顾尾的特性
运行
bvar a = 'abcd'
// 0123
console.log(a[1,3])
运行
d在JS中使用中括号索引访问字符串，只能提供单个索引的值，
如果要是尝试使用这个逗号，分割多个值，它将被视为逗号操作符，
只返回最后一个值。
函数
JS中，函数是一段被封装好的代码，可以被反复调用的，函数可以是一个值，一个对象，一类数据，还可以是一个表达式，
因此，函数也可以赋值，运算，可以拥有属性和方法，甚至可以临时存储值，构造实例等等。
关键字function
function name(){
//执行的js代码
console.log('aaaaaa')
}
name() //调用函数，要不然没效果function是关键字，name是方法(函数)名，后接的()中是可以穿参数的，然后花括号中是块区域
箭头函数
箭头函数是ES6引入的一种新的函数定义语法
//箭头函数
()=>{}可以更简洁的去定义一个匿名函数
(arg) => {
//写代码逻辑
}箭头函数写法
const p = (arg) => {
console.log(arg*2)
}
p(10)
运行
20正常函数写法
function p(arg){
console.log(arg*2)
}
p(10)
运行
20或者这样
const p = function p(arg){
console.log(arg*2)
}
p(10)
运行
20案例
var nb = (x,y) => {
return x-y;
}
var res = nb(2,5);
//如果函数内部使用了 return 语句，
//它会立即返回一个值，并且结束函数的执行。
console.log(res)
运行
-3也可以这样写
var nb = function(x, y) {
return x - y;
};
console.log(nb(2, 5));案例2
这里面使用的是模版所使用的符号``
在 JavaScript 中，箭头函数具有词法作用域，它们继承父作用域的 this 值，并且不会创建自己的 this。这意味着在箭头函数内部，this 的值是在它被创建时的外部函数的 this 值。
箭头函数能继承它上面函数中的参数
const bbb = {
name : 'sss',
say : function (){
setTimeout(()=>{
console.log(`wowowo,${this.name}`)
},200)
}
}
bbb.say()
运行
wowowo,sss
或者
const bbb = {
name: 'sss',
say: function () {
this.name;
const a = () => {
console.log(this.name);
};
return { a: a };
}
};
bbb.say().a();
运行
sss
当执行 bbb.say() 时，它会执行 say 方法内的代码。让我们逐行解释：
this.name;：这一行代码似乎是一个无操作的语句，它没有任何效果。它访问了bbb对象的name属性，但并没有做任何事情来使用它。const a = () => { console.log(this.name); };：这里定义了一个箭头函数a，箭头函数通过() => {}的形式来定义。箭头函数的主体是一个console.log()调用，打印了当前的this.name。箭头函数的特性是它会捕获定义时的上下文的this值，而不是创建自己的this上下文。所以在这里，箭头函数a中的this将指向外部的say方法的this，也就是指向bbb对象。return { a: a };：在say方法中返回了一个包含箭头函数a的对象。这个对象具有一个属性a，它的值就是箭头函数a。这样做的目的是为了能够在bbb.say()的返回值上链式调用a方法。
当你执行 bbb.say().a() 时，首先调用 bbb.say() 方法，它返回了一个对象 { a: a }，然后通过 .a() 调用了这个对象的 a 方法，从而执行了箭头函数 a，并在控制台打印了 bbb 对象的 name 属性。
也可以这样写
const bbb = {
name: 'sss',
say: function () {
const a = () => {
console.log(this.name)
}
return {a:a};
}
};
bbb.say().a();
运行
sss流程控制
if for while switch
流程控制就是控制代码的执行
if
在 JavaScript 中，条件语句 if 会将任何非零、非空、非 undefined、非 null 或非 NaN 的值视为真，
否则视为假。在你的例子中，aa 的值为 3，这是一个非零的数字，因此条件为真，所以会执行 if 代码块中的内容。
因此，输出结果为 '真'。
var aa = 0;
if (aa){
//真 就执行这里
console.log('真')
}else{
//假 就执行这里
console.log('假')
}
运行
假拓展
var aa = 3;
if (!aa){ //!aa表达式会求取aa的相反值
//真 就执行这里
console.log('真')
}else{
//假 就执行这里
console.log('假')
}
运行
真for
for(a=1;a<=10;a++){
//首先a的初始值=1，然后判断，1是否小于等于10，然后a++就是a自增
//这样a的值在小于10之前都会执行，直到值到10就不会循环了
console.log(a)
}
运行
1
2
3
4
5
6
7
8
9
10拓展
var a = [1,3,4,5,6,7,'a']
//0,1,2,3,4,5,6
for (var b=0;b<a.length;b++){
console.log(b+" "+a[b])
}
运行
左边一列是判断b的值是否符合小于a的数组长度，小于就自增然后继续循环，直到不小于了
右边一列是a数组中b的值
0 1
1 3
2 4
3 5
4 6
5 7
6 a
拓展案例详解
在这个例子中，a[b] 表示数组 a 中索引为 b 的元素。在每次迭代中，b 的值从 0 开始逐步增加，直到 a 数组的长度为止。
在第一次迭代中，b 的值为 0，所以 a[b] 表示数组 a 中索引为 0 的元素，即 1。在第二次迭代中，b 的值为 1，所以 a[b] 表示数组 a 中索引为 1 的元素，即 3。依此类推，直到最后一次迭代，b 的值为 6，a[b] 表示数组 a 中索引为 6 的元素，即 'a'。
所以，console.log(b + " " + a[b]) 的输出结果会显示每个索引 b 对应的元素值，以及其在数组中的索引位置。
对象循环
var person = {
name : 'w',
age : 30,
city : 'bj'
};
for (var key in person){
console.log(key + ':'+ person[key] )
}
运行
name: w
age: 30
city: bj在 for...in 循环中，key 变量会依次被赋值为对象 person 的每个属性的键。然后，通过 person[key] 来获取每个键对应的值。
循环字符串
var str = "hello";
for (var i=0; i<str.length; i++){
console.log(str[i])
}
运行
h
e
(2)l //l有两个
owhile
如果为真就死循环，
不暂停就一直循环
var y = 1;
while (y){
console.log(666)
}
运行
(99999次)666在while 中使用break
var y = 0;
while (1){
y++;
console.log(y);
if (y==3)break;
}
运行
1
2
3在while 中使用continue
var y = 0;
while (1){
y++;
if (y==3)continue;
console.log(y);
if (y==5)break;
}
运行
1
2 /没有3
4 /
5switch
判断值，符合那个case就执行那个case，都不符合就执行默认的。
let number = 1;
switch (number) {
case 1:
console.log('1');
break;
case 2:
console.log('2');
break;
case 3:
console.log('3');
break;
default:
console.log('其他');
break;
}
运行
1另外
let number = 1;
switch (number) {
case 1:
console.log('1');
//break;
case 2:
console.log('2');
break;
case 3:
console.log('3');
break;
default:
console.log('其他');
break;
}
运行
因为case1没加break，所以执行完case1后会继续执行case2
1
2流程控制补充
break
break 语句用于终止循环。当循环执行到 break 语句时，会立即退出循环，不再执行后续的循环迭代或循环体内的代码。
在break前和break的区别
前
for (i = 0; i < 10; i++) {
console.log(i); // 第一次循环执行前输出 i 的值
if (i == 5) break; // 当 i 等于 5 时，中断当前循环并跳出循环
}
运行
0
1
2
3
4
5后
for (i = 0; i < 10; i++) {
if (i == 5) break; // 当 i 等于 5 时，中断当前循环并跳出循环
console.log(i); // 每次循环除了在 i 等于 5 时都会输出 i 的值
}
运行
0
1
2
3
4if (i == 5) break; // 当 i 等于 5 时，
中断当前循环并跳出循环
console.log(i); // 每次循环除了在 i 等于 5 时都会输出 i 的值，
但是当条件满足后就不会再执行后面的语句，包括 console.log(i);。
continue
通过 continue 关键字跳过本次循环，直接进入下一次循环
for (i = 0; i < 10; i++) {
if (i == 5) continue; // 当 i 等于 5 时，跳过本次循环
console.log(i); // 每次循环除了在 i 等于 5 时都会输出 i 的值
}
运行
0
1
2
3
4 /4和6中间缺了一个5
6 /
7
8
9通过 continue 关键字跳过本次循环，直接进入下一次循环。这意味着在 i 等于 5 时，不会执行 console.log(i)。因此，循环输出的结果将不包括数字 5。
try
JavaScript 的 try 语句是用于实现错误处理的机制。它允许你编写一段代码块，然后尝试在这段代码中执行可能会引发错误的操作。如果错误确实发生了，你可以使用 catch 块来捕获这个错误，并对其进行处理。基本的语法如下：
try {
// 可能会引发错误的代码
} catch (error) {
// 错误发生时的处理代码
} finally {
// 不论是否发生错误都会执行的代码
}try块：在这个块中放置你需要监视错误的代码。如果在这段代码中发生了错误，JavaScript 引擎就会跳到catch块去执行，并提供一个错误对象作为参数。catch块：这里放置处理错误的代码。当try块中的代码引发了一个异常时，JavaScript 引擎会跳转到catch块，其中的代码会被执行。catch块的参数error是一个表示错误的对象，你可以使用它来访问错误的相关信息，比如错误消息、堆栈轨迹等。finally块（可选的）：不论try块中是否发生了错误，finally块中的代码都会被执行。这通常用于清理工作，比如释放资源、关闭文件等。
案例
try {
console.log(a())
} catch(error){
console.log(error)
}
运行
ReferenceError: a is not defined
at Object.<anonymous> (/Users/Javascript/.idea/a.js:2:13)
报错显示a is not defined
也可以只输出报错的信息error.message
try {
console.log(a())
} catch(error){
console.log(error.message)
}
运行
a is not defined案例
try {
console.log(a())
} catch(error){
console.log(error.message)
}finally{
console.log('不管报不报错都执行这里的代码')
}
运行
a is not defined
不管报不报错都执行这里的代码案例（不报错）
try {
// console.log(a())
console.log('123')
} catch(error){
console.log(error.message)
}finally{
console.log('不管报不报错都执行这里的代码')
}
运行
123
不管报不报错都执行这里的代码逆向扣代码的时候怎么处理这里呢
就是把没用的都删了
只留他必须要执行的
看下面案例
这段代码
try {
// console.log(a())
console.log('123')
} catch(error){
console.log(error.message)
}finally{
console.log('不管报不报错都执行这里的代码')
}
扣下来就是只留他必须要执行的
console.log('123')
console.log('不管报不报错都执行这里的代码')
只执行的就只有这两段
ok对象
没对象怎么办😰？
咱自己new一个Object呗~
创建一个对象
var car = new Object(); //定义一个空对象名字是car
car.color = 'red' //给刚刚定义的对象添加属性
car.name = 'BMW'
console.log(car)
运行
{color: 'red', name: 'BMW'}var car = new Object(); //定义一个空对象名字是car
car.color = 'red' //给刚刚定义的对象添加属性
car.name = 'BMW'
car['xxx'] = 'aaa' //也可以这样给对象添加属性
console.log(car)
运行
{color: 'red', name: 'BMW', xxx: 'aaa'}对象中属性的两种输出方法
var person = {
name : '李大爷',
age : 80,
city : 'bj'
};
//调用对象内部的属性，两种方法
console.log(person.name)
console.log(person['name'])
运行
李大爷
李大爷对象中的属性也可以是函数
var car = new Object();
car.color = 'red'
car.name = 'BMW'
car['xxx'] = 'aaa'
car['run'] = function(){
return '这是一个run方法'
}
console.log(car.run) //调用car.run
运行
ƒ (){
return '这是一个run方法'
}搞错了少了()
console.log(car.run())
运行
这是一个run方法这样是调用
对象和字符串互转
JSON.parse是字符串转对象
JSON.stringify是对象转字符串
var person = {
name : '李大爷',
age : 80,
city : 'bj'
};
res = JSON.stringify(person)
console.log(res,typeof res)
运行
{"name":"李大爷","age":80,"city":"bj"} string把string再转回去
var person = {
name : '李大爷',
age : 80,
city : 'bj'
};
res = JSON.stringify(person)
console.log(res,typeof res)
res2 = JSON.parse(res)
console.log(res2,typeof res2)
运行
{"name":"李大爷","age":80,"city":"bj"} string
a.js:48
{name: '李大爷', age: 80, city: 'bj'} object对象内部方法
var person = {
name : '李大爷',
age : 80,
city : 'bj',
newage : function(){
return this.age += 20;
},
};
console.log(person.newage())
运行
100导出与导入
CommonJS
在 Node.js 等环境中，通常使用 CommonJS 规范来实现模块化。在 CommonJS 中，使用 require() 函数导入模块，使用 module.exports 导出模块。
ES Modules
在现代的浏览器和一些 JavaScript 运行时环境中，通常使用 ES Modules 来实现模块化。在 ES Modules 中，使用 import 关键字导入模块，使用 export 关键字导出模块。
区别
CommonJS 是动态加载模块的，而 ES Modules 是静态加载的，这意味着在 ES Modules 中，模块的依赖关系在代码执行之前就被确定了，而在 CommonJS 中，模块的依赖关系可以在运行时改变。
ES Modules 支持异步加载模块，而 CommonJS 不支持。
ES Modules 支持在浏览器中直接使用，而 CommonJS 主要用于服务器端的 Node.js 等环境。
导出
先将一个小知识
每个项目中的package.json中都存放着这个项目中所需要的包和版本，如果要迁移项目的话，有这个package.json文件就可以在另一个机器上执行npm install 把所需的依赖全部安装上。
拿一个小案例
因为此代码使用了crypto-js库来计算MD5，所以确保项目中已经安装了 Crypto.js 包
安装命令
sudo npm install crypto-js//daochu.js
const crypt = require('crypto-js')
// pwd = crypto.MD5('123').toString()
function md5(t){
return crypt.MD5(t).toString()
}
console.log(md5('123'))
//module.exports = md5 //导出功能语句
运行
202cb962ac59075b964b07152d234b70这里是我写好的算法，我想再其他文件中调用怎么办。
在代码结尾添加
module.exports = md5导出谁就写谁的名字不用加（）
node_modules封装库
在node_modules封装库中的aes.js中可以看到已经封装好的
导入
//daoru.js
const md5 = require('./daochu')
aaa = md5('123')
console.log(aaa);
运行
202cb962ac59075b964b07152d234b70
202cb962ac59075b964b07152d234b70
为什么会有两个结果，
因为在另一个daochu.js中也有一个console.log(md5('123'))也执行了导出导入集合小案例
daochu.js
const crypt = require('crypto-js')
function md5(t){
return crypt.MD5(t).toString()
}
module.exports = md5daochu2.js
const crypt = require('crypto-js')
function sha1(t){
return crypt.SHA1(t).toString()
}
module.exports = sha1daoru.js
// 导入模块
const md5 = require('./daochu');
const sha1 = require('./daochu2');
// 导出模块
module.exports = {
md5, // 导出名为 md5 的函数
sha1, // 导出名为 sha1 的函数
};
daoru2.js
//现在，其他模块可以通过导入这个模块来访问 md5 和 sha1 函数，例如：
const crypto = require('./daoru')
//这里导入的是daoru.js那个文件，因为那个文件写了
//然后crypto是自定义的
a = crypto.md5('123')
b = crypto.sha1('123')
console.log(a)
console.log(b)
运行
202cb962ac59075b964b07152d234b70
40bd001563085fc35165329ea1ff5c5ecbdbbeef逻辑图就是这样
当你写了多个算法，然后导出到一个文件中，然后用的时候直接去那个集合中拿
OK~JavaScript已经到此结束了，
撒花~~~
-.-
评论区