int main()
{
00D71D90  push        ebp  
00D71D91  mov         ebp,esp  
00D71D93  sub         esp,0C0h  
00D71D99  push        ebx  
00D71D9A  push        esi  
00D71D9B  push        edi  
00D71D9C  lea         edi,[ebp+FFFFFF40h]  
00D71DA2  mov         ecx,30h  
00D71DA7  mov         eax,0CCCCCCCCh  
00D71DAC  rep stos    dword ptr es:[edi]  
__asm mov eax, 1;
00D71DAE  mov         eax,1  
00D71DB3  push        2  
00D71DB5  push        1  
00D71DB7  call        00D71370  
00D71DBC  add         esp,8  
add(1, 2);

return 0;
00D71DBF  xor         eax,eax  
}
00D71DC1  pop         edi  
}
00D71DC2  pop         esi  
00D71DC3  pop         ebx  
00D71DC4  add         esp,0C0h  
00D71DCA  cmp         ebp,esp  
00D71DCC  call        00D7120D  
00D71DD1  mov         esp,ebp  
00D71DD3  pop         ebp  
00D71DD4  ret  





int add(int a, int b)
{
00D724B0  push        ebp  
00D724B1  mov         ebp,esp  
00D724B3  sub         esp,0C0h  
00D724B9  push        ebx  
00D724BA  push        esi  
00D724BB  push        edi  
00D724BC  lea         edi,[ebp+FFFFFF40h]  
00D724C2  mov         ecx,30h  
00D724C7  mov         eax,0CCCCCCCCh  
00D724CC  rep stos    dword ptr es:[edi]  
00D724CE  mov         ecx,0D7B003h  
00D724D3  call        00D71203  


return a + b;;
00D724D8  mov         eax,dword ptr [ebp+8]  
00D724DB  add         eax,dword ptr [ebp+0Ch]  
}
00D724DE  pop         edi  
00D724DF  pop         esi  
00D724E0  pop         ebx  
00D724E1  add         esp,0C0h  
00D724E7  cmp         ebp,esp  
00D724E9  call        00D7120D  
00D724EE  mov         esp,ebp  
00D724F0  pop         ebp  
00D724F1  ret

add(1, 2);

int add(int a, int b)
{


return a + b;;
}

//将2,1入栈,调用add函数,最后堆栈平衡
00B21DB3  push        2  
00B21DB5  push        1  
00B21DB7  call        _add (0B21370h)  
00B21DBC  add         esp,8  


//将a的值放入eax中
return a + b;;
00B224D8  mov         eax,dword ptr [a]  


将a的值和b 的值相加,并且存入eax中
return a + b;;
00B224DB  add         eax,dword ptr [b]

拓展:
有符号拓展
char c = 1;//c=00000001
int b = c; //b = 00000000 00000000 00000000 00000001

char  c = -1;//c = 11111111
b本来是 00000000 00000000 00000000 00000000
赋值后 00000000 00000000 00000000 11111111
因为c是有符号类型且最高位是1,所以前面的0都用c的符号位去填充
int b = c;b = 11111111 11111111 11111111 11111111


无符号拓展

unsigned char c = -1;//c = 11111111
无符号号数扩展直接填充0,不需要看符号位填充
int b = c;// b = 00000000 00000000 00000000 11111111

unsigned char i = -1;
unsigned char j = 1;

if(i>j)
{
printf("i>j");
}
else
{
printf("i<j");
}

i = -1 = FFFFFFFF

j = 1 = 00000001

因为都是无符号类型,所以i>j

比如 8.25
先将整数部分转换为二进制
8 == 1000

0.25转换小数部分
0.25 == 0.01(二进制)
0  1
0.25*2 = 0.5
0.5 * 2 = 1

小数部分0.4 == 0.1100转成二进制：
0.4 == 0.1100(二进制)
0.4*2 = 0.8
0.8*2 = 1.6
0.6*2 = 1.2
0.2*2 = 0.4
0.4*2 = 0.8
...

8.25 == 1000.01(二进制)
转换为科学计数法 1000.01 == 1.00001 * 2^3

符号位是0 (正数是0,负数是1)
指数符号位是1 (小数点向左移就填1,向右移就填0)
指数位是 3 所以3-1 = 2 == 10 ==0000010(10二进制写后面,前面部分用0 补)
尾数部分是 1 从左往右写入内存不够用0补(10000000000000000000000)

8.25的内存存储形式:
符号位  指数符号位指数移动数二进制小数部分
0 1      00001010000000000000000000000
0100 0001 0000 0100 0000 0000 0000
转换为16进制
4     1    0    4   0     0    0
小数转换到二进制是不完全精确的


0.25转换为二进制小数
整数部分 0
小数部分 01
0.25 == 0.01
0.01转换为科学计数法 == 1 * 2^-2

实数是正数所以是0
指数符号 0(因为是向右移动得到的)
指数位 1111101
步骤:
2 == 0000010
按位取反==1111101
尾数部分是0(因为1 *2%-2,1后面没有小数)

0.25的内存存储形式:
符号位指数符号位指数移动数二进制小数部分
0 0  1111101  00000000000000000000000
0011 1110 1000 0000 0000 0000 0000 0000
3  E    8    0    0    0    0    0

movss xmm1, xmm2/m32  ; 从另一个 XMM 寄存器或内存中复制一个 float 到 xmm1
movss xmm2/m32, xmm1  ; 把 xmm1 中的 float 值写到另一个 xmm 或内存中

//编译器会将'a'拿去ASCII表中查找对应'a'的数值
char c = 'a';
//因为c存放的是'a'的数值所以putchar会用c的数值去ASCII表中查找,最后输'a'
putchar(c);

//str存放的是"abcd"中的第一个字符的地址(指针)

char str[] = "abcd"

int main()
{
char str[] = "我";

return 0;
}

指令含义条件通常用于比较（cmp）后
setgSet if GreaterZF=0 且 SF=OF有符号大于（>）

setlSet if LessSF≠OF有符号小于（<）

setg  reg/mem8   ; 如果比较结果为 "greater"，则设置为 1，否则为 0

setl  reg/mem8   ; 如果比较结果为 "less"，则设置为 1，否则为 0


mov eax, 10
mov ebx, 5
cmp eax, ebx    ; 相当于 10 - 5
setg al         ; 因为 10 > 5，al = 1
setl bl         ; 因为 10 < 5 不成立，bl = 0

setg / setl 是 有符号数比较

指令有符号/无符号等价条件说明
seta无符号(CF = 0) && (ZF = 0)无符号 a > b
setb无符号CF = 1无符号 a < b

指令条件有符号含义
seteZF == 1无关相等（==）
setneZF == 0无关不等（!=）
setgZF == 0 && SF == OF✅大于（>）
setgeSF == OF✅大于等于（>=）
setlSF != OF✅小于（<）
setle小于或等于(ZF = 1) or (SF ≠ OF)a <= b
setaCF == 0 && ZF == 0❌无符号大于
setbCF == 1❌无符号小于

#include<stdio.h>



int add(int a, int b)
{


return a + b;;
}

int main()
{
int x, y;
x = 10;
y = 20;

if (x > y)
{
printf("x > y");
}
else
{
printf("x < y");
}

return 0;
}

int x, y;
x = 10;
00194F18  mov         dword ptr [ebp-8],0Ah  
y = 20;
00194F1F  mov         dword ptr [ebp-14h],14h  

if (x > y)
00194F26  mov         eax,dword ptr [ebp-8]  
00194F29  cmp         eax,dword ptr [ebp-14h]  
00194F2C  jle         00194F3D  //如果x<=y就会跳转
{
printf("x > y");
00194F2E  push        197B30h  
00194F33  call        0019104B  
00194F38  add         esp,4  
}
00194F3B  jmp         00194F4A  
else
{
printf("x < y");
00194F3D  push        197BD4h  
00194F42  call        0019104B  
00194F47  add         esp,4  
}

return 0;
00194F4A  xor         eax,eax  
}

movzx destination_reg, source_reg/mem
movsx destination_reg, source_reg/mem

mov al, 0xFF        ; al = 11111111b = 255
movzx eax, al       ; eax = 000000FFh = 255（32位）

#include<stdio.h>



int add(int a, int b)
{


return a + b;;
}

int main()
{
int x = 5;

switch (2)
{

case 3:

printf("1111");
break;
case 1:

printf("1111");
break;
case 2:

printf("1111");
break;

case 4:

printf("1111");
break;
case 100:
printf("1111");
break;
default:
printf("1111");
break;
}

return 0;
}

006A189E  sub         ecx,1

006A18B6  jmp         dword ptr [edx*4+006A192Ch]

movzx       edx,byte ptr [ecx+00C34FDCh]//查找对应的索引值
jmp         dword ptr [edx*4+00C34FC4h]  //通过索引值*4+00C34FC4h找到具体跳转的位置

int x = 5;
00C34F18  mov         dword ptr [ebp-8],5  

switch (2)
00C34F1F  mov         dword ptr [ebp+FFFFFF30h],2  
00C34F29  mov         eax,dword ptr [ebp+FFFFFF30h]  
00C34F2F  sub         eax,1  
00C34F32  mov         dword ptr [ebp+FFFFFF30h],eax  
00C34F38  cmp         dword ptr [ebp+FFFFFF30h],63h  
00C34F3F  ja          00C34FA0  
00C34F41  mov         ecx,dword ptr [ebp+FFFFFF30h]  
00C34F47  movzx       edx,byte ptr [ecx+00C34FDCh]  
00C34F4E  jmp         dword ptr [edx*4+00C34FC4h]  
{

case 3:

printf("1111");
00C34F55  push        0C37B30h  
00C34F5A  call        00C3104B  
00C34F5F  add         esp,4  
break;
00C34F62  jmp         00C34FAD  
case 1:

printf("1111");
00C34F64  push        0C37B30h  
00C34F69  call        00C3104B  
00C34F6E  add         esp,4  
break;
00C34F71  jmp         00C34FAD  
case 2:

printf("1111");
00C34F73  push        0C37B30h  
case 2:

printf("1111");
00C34F78  call        00C3104B  
00C34F7D  add         esp,4  
break;
00C34F80  jmp         00C34FAD  

case 4:

printf("1111");
00C34F82  push        0C37B30h  
00C34F87  call        00C3104B  
00C34F8C  add         esp,4  
break;
00C34F8F  jmp         00C34FAD  
case 100:
printf("1111");
00C34F91  push        0C37B30h  
00C34F96  call        00C3104B  
00C34F9B  add         esp,4  
break;
00C34F9E  jmp         00C34FAD  
default:
printf("1111");
00C34FA0  push        0C37B30h  
00C34FA5  call        00C3104B  
00C34FAA  add         esp,4  
break;
}

#include<stdio.h>
#include<windows.h>



int main()
{
char c[10] = { '1' };

printf("%d",sizeof c);


return 0;
}

#include<stdio.h>
#include<windows.h>

void Fun()
{
while (1) {
printf("111\n");
}
}

int yichu() {

int a[8] = { 1,2 };

a[9] = (int)Fun;

return 0;

}

int main()
{
yichu();

return 0;
}

a[9] = (int)Fun;

mov eax, 3
imul dword ptr [ebx] ; eax * [ebx]，结果在 edx:eax

imul eax, ebx ; eax = eax * ebx

imul eax, ebx, 100 ; eax = ebx * 100

#include<stdio.h>
#include<windows.h>

struct MY {
char a;
char b;
int c;
};

int main()
{
struct MY m = { 'a','b',123 };

return 0;
}

#pragma pack(1)
struct MY {
char a;
char b;
int c;
};
#pragma pack()

#include<stdio.h>
#include<windows.h>
#pragma pack(1)
struct MY {
char a;
char b;
int c;
};
#pragma pack()

int main()
{
struct MY m[3] = {
{'a','b',123},
{'a','b',123},
{'a','b',123}
};

return 0;
}

*加指针类型的类型是指针类型减去一个*

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">

/*
 * , 运算符
 * 使用,可以分割多个语句，一般可以在声明多个变量时使用,
 */
//使用,运算符同时声明多个变量
//var a , b , c;

//可以同时声明多个变量并赋值
//var a=1 , b=2 , c=3;
//alert(b);

/*
 * 就和数学中一样，在JS中运算符也有优先级，
 * 比如：先乘除 后加减
 * 在JS中有一个运算符优先级的表，
 * 在表中越靠上优先级越高，优先级越高越优先计算，
 * 如果优先级一样，则从左往右计算。
 * 但是这个表我们并不需要记忆，如果遇到优先级不清楚
 * 可以使用()来改变优先级
 */

//var result = 1 + 2 * 3;

/*
 * 如果||的优先级高，或者两个一样高，则应该返回3
 * 如果与的优先级高，则应该返回1
 * 
 */
var result = 1 || 2 && 3;

console.log("result = "+result);

</script>
</head>
<body>
</body>
</html>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">

/*
 * 我们的程序是由一条一条语句构成的
 * 语句是按照自上向下的顺序一条一条执行的
 * 在JS中可以使用{}来为语句进行分组,
 * 同一个{}中的语句我们称为是一组语句，
 * 它们要么都执行，要么都不执行，
 * 一个{}中的语句我们也称为叫一个代码块
 * 在代码块的后边就不用再编写;了
 * 
 * JS中的代码块，只具有分组的的作用，没有其他的用途
 * 代码块内容的内容，在外部是完全可见的
 */
{
var a = 10;
alert("hello");
console.log("你好");
document.write("语句");
}


console.log("a = "+a);




</script>
</head>
<body>
</body>
</html>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">

/*
 * 流程控制语句
 * - JS中的程序是从上到下一行一行执行的
 * - 通过流程控制语句可以控制程序执行流程，
 * 使程序可以根据一定的条件来选择执行
 *  - 语句的分类：
 * 1.条件判断语句
 * 2.条件分支语句
 * 3.循环语句
 * 
 * 
 * 条件判断语句：
 * - 使用条件判断语句可以在执行某个语句之前进行判断，
 * 如果条件成立才会执行语句，条件不成立则语句不执行。
 *  - if语句
 * - 语法一：
 * if(条件表达式){
 * 语句...
 * }
 * 
 * if语句在执行时，会先对条件表达式进行求值判断，
 * 如果条件表达式的值为true，则执行if后的语句，
 * 如果条件表达式的值为false，则不会执行if后的语句。
 * if语句只能控制紧随其后的那个语句,
 * 如果希望if语句可以控制多条语句，
 * 可以将这些语句统一放到代码块中
 * if语句后的代码块不是必须的，但是在开发中尽量写上代码块，即使if后只有一条语句
 * 
 */

var a = 25;

if(a > 10 && a <= 20){
alert("a大于10，并且 a小于等于20");
}


</script>
</head>
<body>
</body>
</html>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">

/*
 * if语句
 * 语法二:
 * if(条件表达式){
 * 语句...
 * }else{
 * 语句...
 * }
 * 
 * if...else...语句
 * 当该语句执行时，会先对if后的条件表达式进行求值判断，
 * 如果该值为true，则执行if后的语句
 * 如果该值为false，则执行else后的语句
 * 
 * 语法三：
 * if(条件表达式){
 * 语句...
 * }else if(条件表达式){
 * 语句...
 * }else if(条件表达式){
 * 语句...
 * }else{
 * 语句...
 * }
 * 
 * if...else if...else
 * 当该语句执行时，会从上到下依次对条件表达式进行求值判断
 * 如果值为true，则执行当前语句。
 * 如果值为false，则继续向下判断。
 * 如果所有的条件都不满足，则执行最后一个else后的语句
 * 该语句中，只会有一个代码块被执行，一旦代码块执行了，则直接结束语句
 */

var age = 50;

/*if(age >= 60){
alert("你已经退休了~~");
}else{
alert("你还没退休~~~");
}*/

age = 200;

/*if(age > 100){
alert("活着挺没意思的~~");
}else if(age > 80){
alert("你也老大不小的了~~");
}else if(age > 60){
alert("你也退休了~~");
}else if(age > 30){
alert("你已经中年了~~");
}else if(age > 17){
alert("你已经成年了");
}else{
alert("你还是个小孩子~~");
}*/

age = 90;

if(age > 17 && age <= 30){
alert("你已经成年了");
}else if(age > 30 && age <= 60){
alert("你已经中年了");
}else if(age > 60 && age <= 80){
alert("你已经退休了");
}else{
alert("你岁数挺大的了~~");
}


</script>
</head>
<body>
</body>
</html>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">
/*
 * 条件分支语句也叫switch语句
 * 语法：
 * switch(条件表达式){
 * case 表达式:
 * 语句...
 * break;
 *  case 表达式:
 * 语句...
 * break;
 * default:
 * 语句...
 * break;
 * }
 * 
 * 执行流程：
 * switch...case..语句
 * 在执行时会依次将case后的表达式的值和switch后的条件表达式的值进行全等比较，
 * 如果比较结果为true，则从当前case处开始执行代码。
 * 当前case后的所有的代码都会执行，我们可以在case的后边跟着一个break关键字，
 * 这样可以确保只会执行当前case后的语句，而不会执行其他的case
 * 如果比较结果为false，则继续向下比较
 * 如果所有的比较结果都为false，则只执行default后的语句
 * 
 * switch语句和if语句的功能实际上有重复的，使用switch可以实现if的功能，
 * 同样使用if也可以实现switch的功能，所以我们使用时，可以根据自己的习惯选择。
 */

//根据num的值，输出对应的中文

var num = 3;

/*if(num == 1){
console.log("壹");
}else if(num == 2){
console.log("贰");
}else if(num == 3){
console.log("叁");
}*/

num = "hello";

switch(num){
case 1:
console.log("壹");
//使用break可以来退出switch语句
break;
case 2:
console.log("贰");
break;
case 3:
console.log("叁");
break;
default:
console.log("非法数字~~");
break;
}

</script>
</head>
<body>
</body>
</html>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">


/*
 * 向页面中输出连续的数字
 */
/*var n = 1;
document.write(n++ +"<br />");*/

/*
 * 循环语句：
 * 通过循环语句可以反复的执行一段代码多次
 * 
 * while循环
 * - 语法：
 * while(条件表达式){
 * 语句...
 * }
 * 
 * - while语句在执行时，
 * 先对条件表达式进行求值判断，
 * 如果值为true，则执行循环体，
 * 循环体执行完毕以后，继续对表达式进行判断
 * 如果为true，则继续执行循环体，以此类推
 * 如果值为false，则终止循环
 * 
 * do...while循环
 * - 语法：
 * do{
 * 语句...
 * }while(条件表达式)
 * 
 * - 执行流程：
 * do...while语句在执行时，会先执行循环体，
 * 循环体执行完毕以后，在对while后的条件表达式进行判断，
 * 如果结果为true，则继续执行循环体，执行完毕继续判断以此类推
 * 如果结果为false，则终止循环
 * 
 * 实际上这两个语句功能类似，不同的是while是先判断后执行，
 * 而do...while会先执行后判断，
 * do...while可以保证循环体至少执行一次，
 * 而while不能
 */
var n = 1;

//向这种将条件表达式写死为true的循环，叫做死循环
//该循环不会停止，除非浏览器关闭，死循环在开发中慎用
//可以使用break，来终止循环
/*while(true){
alert(n++);

//判断n是否是10
if(n == 10){
//退出循环
break;
}

}*/

//创建一个循环，往往需要三个步骤

//1.创初始化一个变量
var i = 11;

//2.在循环中设置一个条件表达式
/*while(i <= 10){
//3.定义一个更新表达式，每次更新初始化变量
document.write(i++ +"<br />")

}*/

/*do{
document.write(i++ +"<br />");
}while(i <= 10);*/

/*while(true){
alert(1);
}*/

</script>
</head>
<body>
</body>
</html>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">

/*
 * 假如投资的年利率为5%，试求从1000块增长到5000块，需要花费多少年
 * 
 * 1000 1000*1.05
 * 1050 1050*1.05
 */

//定义一个变量，表示当前的钱数
var money = 1000;

//定义一个计数器
var count = 0;

//定义一个while循环来计算每年的钱数
while(money < 5000){
money *= 1.05;

//使count自增
count++;
}


//console.log(money);
console.log("一共需要"+count+"年");



</script>
</head>
<body>
</body>
</html>

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title>if练习1</title>
<script type="text/javascript">
/*
 * 从键盘输入小明的期末成绩:
 *当成绩为100时，'奖励一辆BMW'
 *当成绩为[80-99]时，'奖励一台iphone15s'
 *当成绩为[60-80]时，'奖励一本参考书'
 *其他时，什么奖励也没有
 */

/*
 * prompt()可以弹出一个提示框，该提示框中会带有一个文本框，
 * 用户可以在文本框中输入一段内容，该函数需要一个字符串作为参数，
 * 该字符串将会作为提示框的提示文字
 * 
 * 用户输入的内容将会作为函数的返回值返回，可以定义一个变量来接收该内容
 */
//将prompt放入到一个循环中
while(true){
//score就是小明的期末成绩
var score = prompt("请输入小明的期末成绩(0-100):");
//判断用户输入的值是否合法
if(score >= 0 && score <= 100){
//满足该条件则证明用户的输入合法，退出循环
break;
}

alert("请输入有效的分数！！！");
}



//判断值是否合法
if(score > 100 || score < 0 || isNaN(score)){
alert("拉出去毙了~~~");
}else{
//根据score的值来决定给小明什么奖励
if(score == 100){
//奖励一台宝马
alert("宝马，拿去~~~");
}else if(score >= 80){
//奖励一个手机
alert("手机，拿去玩~~~");
}else if(score >= 60){
//奖励一本参考书
alert("参考书，拿去看~~~");
}else{
alert("棍子一根~~");
}
}






</script>
</head>
<body>

</body>
</html>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">

/*
 * for语句，也是一个循环语句，也称为for循环
 * 在for循环中，为我们提供了专门的位置用来放三个表达式：
 * 1.初始化表达式
 * 2.条件表达式
 * 3.更新表达式
 * 
 *  for循环的语法：
 * for(①初始化表达式;②条件表达式;④更新表达式){
 * ③语句...
 * }
 * 
 * for循环的执行流程：
 * ①执行初始化表达式，初始化变量（初始化表达式只会执行一次）
 * ②执行条件表达式，判断是否执行循环。
 * 如果为true，则执行循环③
 * 如果为false，终止循环
 * ④执行更新表达式，更新表达式执行完毕继续重复②
 */

//创建一个执行10次的while循环
//初始化表达式
/*var i = 0;

//创建一个循环，定义条件表达式
while(i < 10){
//设置更新表达式
alert(i++);
}*/

for(var i = 0 ; i < 10 ; i++ ){
alert(i);
}

/*
 * for循环中的三个部分都可以省略，也可以写在外部
 * 如果在for循环中不写任何的表达式，只写两个;
 * 此时循环是一个死循环会一直执行下去，慎用
 * for(;;){
alert("hello");
}
 */







</script>
</head>
<body>
</body>
</html>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">

/*
 * 打印1-100之间所有奇数之和
 */

//创建一个变量，用来保存奇数之和
//var sum = 0;

//打印1-100之间的数
for(var i=1 , sum=0 ; i<=100 ; i++){

//判断i是否是奇数
//不能被2整除的数就是奇数
if(i%2 != 0){
//如果i除以2有余数则证明i是奇数
//console.log(i);
sum = sum+i;
}
}

console.log("奇数之和为 : "+sum);

</script>
</head>
<body>
</body>
</html>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">

/*
 * 打印1-100之间所有7的倍数的个数及总和
 */
//定义一个变量，来保存总和
var sum = 0;
//定义一个计数器，来记录数量
var count = 0;

//打印1-100之间所有的数
for(var i=1 ; i<=100 ; i++){

//判断i是否是7的倍数
if(i % 7 == 0){
//console.log(i);
sum += i;
//使计数器自增1
count++;

}

}

//输出总和
console.log("总和为:"+sum);
//输出总数
console.log("总数量为:"+count);



</script>
</head>
<body>
</body>
</html>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">

/*
 * 水仙花数是指一个3位数，它的每个位上的数字的3 次幂之和等于它本身。
（例如：1^3 + 5^3 + 3^3 = 153）,请打印所有的水仙花数。
 */

//打印所有的三位数
for(var i=100 ; i<1000 ; i++){

//获取i的百位 十位 个位的数字
//获取百位数字
var bai = parseInt(i/100);

//获取十位的数字
var shi = parseInt((i-bai*100)/10);

//获取个位数字
var ge = i % 10;

//判断i是否是水仙花数
if(bai*bai*bai + shi*shi*shi + ge*ge*ge == i){
console.log(i);
}


}


</script>
</head>
<body>
</body>
</html>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">
/*
 * 在页面中接收一个用户输入的数字，并判断该数是否是质数。
质数：只能被1和它自身整除的数，1不是质数也不是合数，质数必须是大于1的自然数。
 */

var num = prompt("请输入一个大于1的整数:");


//判断这个值是否合法
if(num <= 1){
alert("该值不合法！");
}else{

//创建一个变量来保存当前的数的状态
//默认当前num是质数
var flag = true;

//判断num是否是质数
//获取2-num之间的数
for(var i=2 ; i<num ; i++){
//console.log(i);
//判断num是否能被i整除
if(num % i == 0){
//如果num能被i整除，则说明num一定不是质数
//设置flag为false
flag = false;
}
}

//如果num是质数则输出
if(flag){
alert(num + "是质数！！！");
}else{
alert("这个不是质数")
}


}


</script>
</head>
<body>
</body>
</html>

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title></title>
<script type="text/javascript">

/*
 
 通过程序，在页面中输出如下的图形：
 
 *      1   <1   i=0
 **     2   <2   i=1
 ***    3   <3   i=2
 ****   4   <4   i=3
 *****  5   <5   i=4
 
 *****
 *****
 *****
 *****
 *****
 
 ***** 1   j<5(5-0)  i=0
 ****  2  j<4(5-1)  i=1
 ***   3   j<3(5-2)  i=2
 **    4   j<2(5-3)  i=3
 *     5   j<1(5-4)  i=4
 
 
 */

//向body中输出一个内容
//document.write("*****<br />");

//通过一个for循环来输出图形
//这个for循环执行几次，图形的高度就是多少
//它可以用来控制图形的高度
for(var i=0 ; i<5 ; i++){

/*
 * 在循环的内部再创建一个循环，用来控制图形的宽度
 * 目前我们的外部的for循环执行1次，内部的就会执行5次
 * 内层循环可以来决定图形的宽度，执行几次图形的宽度就是多少
 */
/*for(var j=0 ; j<i+1 ; j++){
document.write("*&nbsp;&nbsp;&nbsp;");
}*/
for(var j=0 ; j<5-i ; j++){
document.write("*&nbsp;&nbsp;&nbsp;");
}

//输出一个换行
document.write("<br />");


}



</script>
</head>
<body>

</body>
</html>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">

/*
 * 1.打印99乘法表
 *  1*1=1
 *  1*2=2 2*2=4
 *  1*3=3 2*3=6 3*3=9
 *  1*4=4 2*4=8 3*4=12 4*4=16
 * ....9*9=81
 * 
 * 2.打印出1-100之间所有的质数
 */

//创建外层循环，用来控制乘法表的高度
for(var i=1 ; i<=9 ; i++ ){
//创建一个内层循环来控制图形的宽度
for(var j=1 ; j<=i ; j++){
document.write("<span>"+j+"*"+i+"="+i*j+"</span>");
}

//输出一个换行
document.write("<br />");

}


</script>
<style type="text/css">

body{
width: 2000px;
}

span{
display: inline-block;
width: 80px;
}

</style>
</head>
<body>
</body>
</html>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">

/*
 * 打印出1-100之间所有的质数
 */

//打印2-100之间所有的数
for(var i=2 ; i<=100 ; i++){

//创建一个布尔值，用来保存结果，默认i是质数
var flag = true;

//判断i是否是质数
//获取到2-i之间的所有的数
for(var j=2 ; j<i ; j++){

//判断i是否能被j整除
if(i%j == 0){
//如果进入判断则证明i不是质数,修改flag值为false
flag = false;

}

}

//如果是质数，则打印i的值
if(flag){
console.log(i);
}

}


</script>
</head>
<body>
</body>
</html>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">

/*
 * break关键字可以用来退出switch或循环语句
 * 不能在if语句中使用break和continue
 * break关键字，会立即终止离他最近的那个循环语句
 */

/*for(var i=0 ; i<5 ; i++){
console.log(i);

if(i == 2){
break;
}

}*/


/*for(var i=0 ; i<5 ; i++){
console.log("@外层循环"+i)
for(var j=0 ; j<5; j++){
break;
console.log("内层循环:"+j);
}
}*/


/*
 * 可以为循环语句创建一个label，来标识当前的循环
 * label:循环语句
 * 使用break语句时，可以在break后跟着一个label，
 * 这样break将会结束指定的循环，而不是最近的
 */

/*outer:
for(var i=0 ; i<5 ; i++){
console.log("@外层循环"+i)
for(var j=0 ; j<5; j++){
break outer;
console.log("内层循环:"+j);
}
}*/


/*
 * continue关键字可以用来跳过当次循环
 * 同样continue也是默认只会对离他最近的循环循环起作用
 */
/*for(var i=0 ; i<5 ; i++){

if(i==2){
continue;
}

console.log(i);
}*/

outer:
for(var i=0 ; i<5 ; i++){

for(var j=0 ; j<5 ; j++){

continue;

console.log("-->"+j);

}

console.log("@--->"+i);
}


</script>
</head>
<body>
</body>
</html>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">


//测试如下的程序的性能
//在程序执行前，开启计时器
//console.time("计时器的名字")可以用来开启一个计时器
//它需要一个字符串作为参数，这个字符串将会作为计时器的标识
console.time("test");

//打印2-100之间所有的数
for(var i=2 ; i<=100000 ; i++){
var flag = true;
for(var j=2 ; j<=Math.sqrt(i) ; j++){
if(i%j == 0){
//如果进入判断则证明i不是质数,修改flag值为false
flag = false;
//一旦进入判断，则证明i不可能是质数了，此时循环再执行已经没有任何意义了
//使用break来结束循环
break;

//不加break 215ms
//加break 25ms
//修改j<=后 2.6
}
}
//如果是质数，则打印i的值
if(flag){
//console.log(i);
}
}

//终止计时器
//console.timeEnd()用来停止一个计时器，需要一个计时器的名字作为参数
console.timeEnd("test"); //在浏览器控制台显示

/*
 * 36
 * 1 36
 * 2 18
 * 3 12
 * 4 9
 * 6 6
 */

//可以通过Math.sqrt()对一个数进行开方
//var result = Math.sqrt(97);

//console.log("result = "+result)


</script>
</head>
<body>
</body>
</html>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">
/*
 * JS中数据类型
 * - String 字符串
 *  - Number 数值
 * - Boolean 布尔值
 * - Null 空值
 * - Undefined 未定义
 * - 以上这五种类型属于基本数据类型，以后我们看到的值
 * 只要不是上边的5种，全都是对象
 * - Object 对象
 * 
 * 
 * 基本数据类型都是单一的值"hello" 123 true,
 * 值和值之间没有任何的联系。
 * 
 * 在JS中来表示一个人的信息（name gender age）：
 * var name = "孙悟空";
 * var gender = "男";
 * var age = 18;
 * 如果使用基本数据类型的数据，我们所创建的变量都是独立，不能成为一个整体。
 * 
 * 对象属于一种复合的数据类型，在对象中可以保存多个不同数据类型的属性。
 * 
 * 对象的分类：
 * 1.内建对象
 * - 由ES标准中定义的对象，在任何的ES的实现中都可以使用
 * - 比如：Math String Number Boolean Function Object....
 * 
 * 2.宿主对象
 * - 由JS的运行环境提供的对象，目前来讲主要指由浏览器提供的对象
 * - 比如 BOM DOM
 * 
 * 3.自定义对象
 * - 由开发人员自己创建的对象
 * 
 */

//创建对象
/*
 * 使用new关键字调用的函数，是构造函数constructor
 * 构造函数是专门用来创建对象的函数
 * 使用typeof检查一个对象时，会返回object
 */
var obj = new Object();


/*
 * 在对象中保存的值称为属性
 * 向对象添加属性
 * 语法：对象.属性名 = 属性值;
 */

//向obj中添加一个name属性
obj.name = "孙悟空";
//向obj中添加一个gender属性
obj.gender = "男";
//向obj中添加一个age属性
obj.age = 18;

/*
 * 读取对象中的属性
 * 语法：对象.属性名
 * 
 * 如果读取对象中没有的属性，不会报错而是会返回undefined
 */

//console.log(obj.gender);
//console.log(obj.hello);

/*
 * 修改对象的属性值
 * 语法：对象.属性名 = 新值
 */
obj.name = "tom";

/*
 * 删除对象的属性
 * 语法：delete 对象.属性名
 */
delete obj.name;


console.log(obj.age);





</script>
</head>
<body>
</body>
</html>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">

var obj = new Object();

/*
 * 向对象中添加属性
 * 属性名：
 * - 对象的属性名不强制要求遵守标识符的规范
 * 什么乱七八糟的名字都可以使用
 * - 但是我们使用是还是尽量按照标识符的规范去做
 * 
 */
obj.name = "孙悟空";

//obj.var = "hello";

/*
 * 如果要使用特殊的属性名，不能采用.的方式来操作
 * 需要使用另一种方式：
 * 语法：对象["属性名"] = 属性值
 * 读取时也需要采用这种方式
 * 
 * 使用[]这种形式去操作属性，更加的灵活，
 * 在[]中可以直接传递一个变量，这样变量值是多少就会读取那个属性
 * 
 */
obj["123"] = 789;
obj["nihao"] = "你好";
var n = "nihao";
//console.log(obj["123"]);

/*
 * 属性值
 * JS对象的属性值，可以是任意的数据类型
 * 甚至也可以是一个对象
 */

obj.test = true;
obj.test = null;
obj.test = undefined;

//创建一个对象
var obj2 = new Object();
obj2.name = "猪八戒";

//将obj2设置为obj的属性
obj.test = obj2;

//console.log(obj.test.name);

/*
 * in 运算符
 * - 通过该运算符可以检查一个对象中是否含有指定的属性
 * 如果有则返回true，没有则返回false
 *  - 语法：
 * "属性名" in 对象
 */
//console.log(obj.test2);

//检查obj中是否含有test2属性
//console.log("test2" in obj);
//console.log("test" in obj);
console.log("name" in obj);

</script>
</head>
<body>
</body>
</html>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">

/*
 * 基本数据类型
 * String Number Boolean Null Undefined
 * 
 * 引用数据类型
 * Object
 * 
 * JS中的变量都是保存到栈内存中的，
 * 基本数据类型的值直接在栈内存中存储，
 * 值与值之间是独立存在，修改一个变量不会影响其他的变量
 * 
 * 对象是保存到堆内存中的，每创建一个新的对象，就会在堆内存中开辟出一个新的空间，
 * 而变量保存的是对象的内存地址（对象的引用），如果两个变量保存的是同一个对象引用，
 * 当一个通过一个变量修改属性时，另一个也会受到影响
 */

var a = 123;
var b = a;
a++;

/*console.log("a = "+a);
console.log("b = "+b);*/

var obj = new Object();
obj.name = "孙悟空";

var obj2 = obj;

//修改obj的name属性
obj.name = "猪八戒";



/*console.log(obj.name);
console.log(obj2.name);*/

//设置obj2为null
obj2 = null;

/*console.log(obj);
console.log(obj2);*/

var c = 10;
var d = 10;
//console.log(c == d);

var obj3 = new Object();
var obj4 = new Object();
obj3.name = "沙和尚";
obj4.name = "沙和尚";

/*console.log(obj3);
console.log(obj4);*/

/*
 * 当比较两个基本数据类型的值时，就是比较值。
 * 而比较两个引用数据类型时，它是比较的对象的内存地址，
 * 如果两个对象是一摸一样的，但是地址不同，它也会返回false
 */
console.log(obj3 == obj4);


</script>
</head>
<body>
</body>
</html>