<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<script>
// 1、入职薪水为10k（10000），每年涨5%(0.05)(从上一年的薪水作为基数上涨)，
// 计算输出50年后薪水是多少？
var money = 10000;
for(var y=1;y<=50;y++){
money *= 1.05; // monry = monry*1.05
}
console.log(money); // 114673.997857537
// 2、打印100-999之间的水仙花数
// 水仙花数：百位数字的三次方 + 十位数字的三次方 + 个位数字的三次方 === 这个数字
// 举个栗子：153 = 1*1*1 + 5*5*5 + 3*3*3
for(var n=100;n<=999;n++){
// console.log(n);
var b = parseInt(n/100);
var s = parseInt(n/10)%10;
var g = n%10;
if(b*b*b+s*s*s+g*g*g === n){
console.log(n+'是水仙花数');
}
}
// 3、找出1000-2000年中所有的闰年，并以每行四个数的形式输出(使用document.write()在页面中写入)
// 对比其他作业相对来说稍稍有点难度
// 设定变量 计数
var nnn = 0;
for(var year=1000;year<=2000;year++){
// console.log(year);
if(year%4==0&&year%100!=0 || year%400==0){
document.write(year+" ");
// 计数
nnn++;
// 判断 是否够 四个
if(nnn%4===0){
document.write('<br>');
}
}
}
// 4、求 1/1 - 1/2 + 1/3 - 1/4 + 1/5 - 1/6 + 1/7 - 1/8 + ...... - 1/98 + 1/99 - 1/100 的结果
// 在加分母为奇数的数，在减分母为偶数的数
// 对比其他作业相对来说稍稍有一点点难度
for(var f=1,sum=0;f<=100;f++){
// console.log(f);
if(f%2==0){
sum -= 1/f; // sum = sum - 1/f
}else{
sum += 1/f; // sum = sum + 1/f
}
}
console.log(sum);
// 需要用到循环的嵌套，循环 套 循环，这个 可以不做，但是如果有能力可以尝试
// 5、打印 100-200之间的所有素数
// 素数/质数：除1和自身以外没有其他的因数。除了1和它本身以外不再有其他因数的自然数
// 只能被 1 和 自身 整除，其他数字都不能将其整除
// 提示：循环嵌套，break语句
// 控制 验证 哪个数字
for(var n2=100;n2<=200;n2++){
// 控制 验证 一个数字是否素数，从2开始到比验证的数字小1 的区间
// n3<=n2-1;
for(var n3=2;n3<n2;n3++){
if(n2%n3 === 0){
break;
}
}
if(n2 === n3){
console.log(n2+'是一个素数')
}
}
console.log('-----------------华丽的分割线--------------');
// 控制 验证 哪个数字
for(var nx1=100;nx1<200;nx1++){
// 定义 一个开关，开关开启true, 开启表示 他是一个素数，一开始假设 验证的这个数字是素数
var flag = true;
// 控制 验证 一个数字是否素数，从2开始到比验证的数字小1 的区间
for(var nx2=2;nx2<nx1;nx2++){
if(nx1%nx2 === 0){
// 确定不是素数了，关闭开关 false
flag = false;
break;
}
}
// 只要 开关的值还是 true 当前验证的这个值就是 素数
if(flag) console.log(nx1+'是一个素数');
}
console.log('-----------------华丽的分割线--------------');
// 控制 验证 哪个数字
for(var nxy1=100;nxy1<200;nxy1++){
// 定义 一个开关，开关开启true, 开启表示 他是一个素数，一开始假设 验证的这个数字是素数
var flag = true;
// 控制 验证 一个数字是否素数，从2开始到比验证的数字小1 的区间
for(var nxy2=2;nxy2<nxy1/2;nxy2++){
if(nxy1%nxy2 === 0){
// 确定不是素数了，关闭开关 false
flag = false;
break;
}
}
// 只要 开关的值还是 true 当前验证的这个值就是 素数
if(flag) console.log(nxy1+'是一个素数');
}
</script>
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<script>
console.log(fn1);
console.log(fn2);
fn1();
// fn2();
// 函数
// 当一段代码需要多个地方使用 用 函数 --- 减少代码冗余，方便维护开发
// 函数 是一段有名字的代码块，完成特定功能的代码块，可以被调用执行多次，实现复用。
// 函数的特点在于 一次定义 多次使用
// 我们之前学习过 一些 js的内置方法 --- 只不过这些方法是有官方定义的，我们只是在使用
// Number() parseInt() typeof() ......
// 我们学习函数 是 要能 自己定义方法 然后使用
// 函数的定义(创建) 通过 function关键字 ---
// 声明式函数 --- (有名函数、普通函数) --- 函数的命名规则同变量
// function 函数名(){
// 函数体
// }
// 定义 声明式函数
function fn1(){
console.log('涛哥真帅，非常帅，帅的我晚上睡不着');
}
// 函数内的代码要执行，就必须要 调用函数 --- 多次调用
// 声明式函数 通过 函数名() 实现调用
// 声明式函数可以在任意位置调用（可以在 定义函数 前 后 都可以调用这个函数）
fn1();
fn1();
// 函数就代表函数体
console.log(fn1);
// 赋值式函数 --- (匿名函数) --- 就是函数自身没有名字 将 函数赋值给变量保存
// var 变量 = function(){
// 函数体
// }
// 定义 赋值式函数
var fn2 = function(){
console.log('涛哥不让我夸他了，娇姐让我给她和涛哥编一点故事');
}
// 函数内的代码要执行，就必须要 调用函数 --- 多次调用
// 赋值式函数 通过 变量名() 实现调用
// 赋值式函数 只能在 函数赋值给变量之后 进行调用，在这之前无法调用
fn2();
fn2();
console.log(fn2);
function sushu(){
for(var n2=100;n2<=200;n2++){
// 控制 验证 一个数字是否素数，从2开始到比验证的数字小1 的区间
// n3<=n2-1;
for(var n3=2;n3<n2;n3++){
if(n2%n3 === 0){
break;
}
}
if(n2 === n3){
console.log(n2+'是一个素数')
}
}
}
sushu();
sushu();
// 在 网页中实现 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
// 1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
// 1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
// 1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
// 1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
// 1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
</script>
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<script>
// 在 网页中实现 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
// 1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
// 1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
// 1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
// 1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
// 1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
function biao99(){
// 控制 乘法表的 行 循环变量可以作为一个 因数
for(var r=1;r<=9;r++){
// 控制 乘法表 当前行的 公式 个数 循环变量可以作为一个 因数
for(var c=1;c<=r;c++){
// 判断 乘积的结果是否小于10，如果小于给等号后面添加一个空格，为了整齐
if(c*r<10){
document.write(c+'*'+r+'= '+c*r+' ');
}else{
document.write(c+'*'+r+'='+c*r+' ');
}
}
// 换行
document.write('<br>');
}
}
biao99();
biao99();
//
//  
//  
</script>
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<script>
// JS语言中函数拥有四个非常重要的特性，它们分别是：
// 函数名 (语法要求)
// 函数体 (函数体缺失那么该函数就是无意义的)
// 参数 (可以让函数变的更加灵活)
// - 形参 --- 形式参数
// - 实参 --- 实际参数
// 返回值 (语法要求)
console.log(Number('45')); // 45
console.log(Number(true)); // 1
console.log(Number('abc')); // NaN
// 函数的参数
// 一个函数可以没有参数，也可以有1至多个参数，说白了就是函数的参数数量不限定
// 函数的 形参 和 实参 应当 一一对应
// 实参 和 形参 的数量 应当 一样
// 第一个实参 给 第一个形参 赋值
// 第二个实参 给 第二个形参 赋值
// 第几个实参 给 第几个形参 赋值
// 当 函数的实参 赋值给 函数的形参后 在函数内部 使用这个形参 就是在使用 赋值的实参的值
// - 形参 --- 形式参数
// 在 定义函数时 写在 函数名后的小括号中的 就是形参，形参其实就是一个变量
// function fn1(形参){
// 函数体
// }
// - 实参 --- 实际参数
// 在调用函数时 写在 函数名后的小括号中的 就是实参，实参就是在给 形参 赋值
// fn(实参)
function fn(n1,n2,n3){ // var n1,n2,n3
console.log(n1);
console.log(n2);
console.log(n3);
}
fn(10,20,30); // 将 实参 依次 赋值给了 函数的 形参 n1=10 n2=20 n3=30
fn(66,55,44); // 将 实参 依次 赋值给了 函数的 形参 n1=66 n2=55 n3=44
// 编写一个函数，传入两个参数--都是数字，计算两个参数的相加之和
function sum(num1,num2){
var s = num1 + num2;
console.log(s);
}
sum(34,77); // 111
sum(21,55); // 76
function biao99(n){
// 控制 乘法表的 行 循环变量可以作为一个 因数
for(var r=1;r<=n;r++){
// 控制 乘法表 当前行的 公式 个数 循环变量可以作为一个 因数
for(var c=1;c<=r;c++){
// 判断 乘积的结果是否小于10，如果小于给等号后面添加一个空格，为了整齐
if(c*r<10){
document.write(c+'*'+r+'= '+c*r+' ');
}else{
document.write(c+'*'+r+'='+c*r+' ');
}
}
// 换行
document.write('<br>');
}
}
biao99(5);
biao99(7);
// 函数的 形参 和 实参 应当 一一对应
// 如果 实参的数量 少于 形参的数量
// 第几个实参就是给第几个形参赋值，多余的形参没有接收到实参赋值，那它的值就是undefined
function nn1(a,b,c,d,e,f){
console.log(a,b,c,d,e,f); // 'aa' '22' 'haha' undefined undefined undefined
}
nn1('aa','22','haha')
// 如果 实参的数量 多于 形参的数量
// 第几个实参就是给第几个形参赋值，多出来的实参就没有形参接收，但是对于程序没有影响
function ff1(a,b,c){
console.log(a,b,c); // 11 22 33
}
ff1(11,22,33,44,55,66)
</script>
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<script>
// JS语言中函数拥有四个非常重要的特性，它们分别是：
// 函数名 (语法要求)
// 函数体 (函数体缺失那么该函数就是无意义的)
// 参数 (可以让函数变的更加灵活)
// - 形参 --- 形式参数
// - 实参 --- 实际参数
// 返回值 (语法要求) --- 将函数的结果进行导出-实现 调用函数 就 相当于得到结果
var a1 = 10 + '22';
console.log(a1); // '1022'
var a2 = 10 + Number('22');
console.log(a2); // 32
var a3 = '55';
console.log(a3); // '55'
var a4 = Number('55');
console.log(a4); // 55
// 函数的返回值
// 函数执行完之后必须有一个结果，这个结果叫做：返回值。
// 函数 通过 return关键字 得到 返回值
// 在函数内部 return关键字后面 写的什么，那这个函数的返回值就是什么
// 当函数有了返回值，那 函数的调用语句 就会得到函数的返回值，
// 函数的调用语句 就 等于 函数的 返回值
// 如果函数中 没有return 或者 ruturn后面没有值，那这个函数的返回值就是 undefined
// 函数必须要有返回值吗？
// 不一定
// 取决于 函数内部得到的结果在 函数外面是否还要使用
// 如果 不需要使用 则函数 可以没有返回值
// 如果 需要使用 则函数就必须要有返回值
// 注：return关键字 具有 终止函数执行 的作用
// 在函数中 只要 执行了 return关键字，则函数内部后面(除了返回值以外的代码)还有代码就不会执行了
// 因为在函数中 只要 执行了 return，函数就结束了
function sum(num1,num2){
var s = num1 + num2;
console.log(1);
return s;
console.log(2);
}
var b1 = sum(44,66);
console.log(b1); // 110
var n1 = 10 * sum(44,66); // 10 * 110
console.log(n1); // 1100
// 打印三角形
// *
// ***
// *****
// *******
// *********
function xing3(n){
// 用来 拼接 星号 和 换行的 字符串
// debugger;;
var str = '';
for(var r=1;r<=n;r++){
for(var c=1;c<=2*r-1;c++){
str += '*';
}
str += "<br>";
}
// console.log(str);
return str;
}
// console.log(xing3(5));
document.write(xing3(10));
// document.write(xing3(4));
// document.write('*<br>***<br>*****<br>*******<br>*********')
</script>
</body>
</html>
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
