循环结构语句for

循环结构语句for

循环结构语句-for
		=第一:将来用的最多的
    =第二:书写诡异(代码糖) 代码糖:用起来方便,写起来方便,看起来诡异
语法:
		// for(初始化,条件,自增){重复执行}
		for(var i = 0; i<10; i++){重复执行的代码};

		// 标准语法
		var i = 0
    for(i<10;){
      // 重复执行的代码
      i++
    }

// 正常流程解读
for(let i = 0; i <= 10; i++){
  	console.log(i)
  	/*
  	1.首先执行 变量定义 let i = 0
  	2.条件判断 i<=10
  	3.执行重复代码块 console.log(i)
  	4.自增 i++
  	5.i++ 执行结束后 跳回 条件判断 i<=10 继续执行以下步骤!
  	*/
}

// 案例巩固 99乘法表
var str = ""
for(var i = 1;i<=9;i++){
    for(var j=1;j<=i;j++){
        str += i+'*'+j+ '='+i*j + '';
        if(i === j)
            str += '\n'
        }
    }
console.log(str)

使用break命令可以直接结束循环 continue结束本次循环

for(let a = 0;a<=10;a++){
    if(a===1){
        continue // 跳出当前循环执行下次循环
    }else if (a===9){
        break // 直接跳出循环
    }else{ 
        console.log(a)
    }
}

js标记语法

here: // 标记这里
for(var i =1;i<=5;i++){
    for(var j =1;j<=3;j++){
        if(i===3 && j===2){
            console.log('看到半条虫子')
            /*
            当我们吃到虫子的时候 我们就不想继续吃了
            但是 这里的break只能跳出里面的循环
            那么我们就需要用到标记语法    
            */
            break
          	// break + 标记
          	break here
        }
        console.log('正在吃第',i,'个包子的第',j,'口')
    }
}

函数

了解js函数

/*
	+ 函数就相当于一个盒子
	+ 用来承载一段代码,当你需要执行这一段代码的时候
	+ 只要呼唤这个盒子就可以了
	+ 对一段代码的 封装
*/

过程

1.把代码装在盒子里面 =>定义函数
2.使用盒子里的代码 => 调用函数

定义函数

1.声明式函数
		=> 语法: function 函数名(){}
				-> function:声明函数的关键字
        -> 空格:必须有,分割关键字与函数名
				-> 函数名: 这个函数的名字(遵循变量的起名方式)
				-> () :参数
        -> {} :代码段
    =>演示:
    		function fn(){
          	console.log('i am fn')
        }

2.赋值式函数
		=> 语法: var 函数名 = function () {}
    => 演示:
    		var fn = function(){
          	console.log('i im fn')
        }

调用函数

+ 定义方式不一样
+ 调用方式是一样的
		=> 函数名()
注意:
		1.函数名 和 函数名() 是不一样的 
    		=> 函数名是一个变量,表示这个函数的
				=> 函数名() 是把这个函数执行掉!

特点

1.代码的复用
2.代码简洁
3.灵活调用

调用区别

函数调用上的区别
+ 两种声明方式,调用方式是一样的
+ 区别:调用时机不一样
	=> 声明式函数,可以在声明之前调用,也可以在声明之后调用
	=> 赋值式函数,只能在赋值之后调用,不然会报错的:fun is not function

 //先调用
fn()

function fn(){
    console.log('i am fn')
}
//后调用
fn()

// 以上都可以调用

函数的参数

+ 在js中 函数的参数分成两种
	1.形参
  		=> 写在函数定义阶段的()里面
  		=> 就相当于一个只能在函数内部使用的变量
			=> 他的值由函数的实参来决定的
  2.实参
  		=> 写在函数调用阶段的()里面
  		=> 就是一个准确的值,是为了给函数的形参进行赋值的
	+ 都可以写多个,用逗号隔开.

// 1.定义一个函数
function fn(a,b){
  // 定义了两个变量,一个叫a,一个叫b
  // 这两个变量不是直接赋值 而是由实参决定的
  // 而且只能在函数内部使用
}

fn(100,200) //实参 100给了a 200给了b

+ 函数参数的个数关系
   	+一样多
   			=> 按照从左向右的顺序一一对应
   	+实参多
   			=> 前面按照位置一一对应,多出来的实参 不能使用
   	+形参多
   			=> 前面按照位置一一对应,多出来的形参 没有复制 是 undefined

arguments

arguments
		+ 在函数内部天生自带的变量 
		+ 表示所有实参的集合(伪数组)
arguments属性
		1.length
    		=> 长度,arguments 里面有多少个数据
        => 其实就是你的函数调用有几个实参 
		2.arguments的排列
    		=> 按照序号进行排列
				=> 索引 从 0 开始,依次加1
		3.arguments里的某个数据操作
    		=> 我们可以通过索引 来 操作 里面的数据
        => 读: arguments[0]
				=> 写: arguments[0] = 你需要设置的值
					-> 如果索引有 那么就是 修改 没有就是 添加

function fn1(){
    for(var i = 0;i<=arguments.length;i++){
        console.log(arguments[i])
    };
}

fn1(1,2,3,4,5,6,3,3,3,3)

返回值

return

function fn(a,b){
    return a+b
}
console.log(fn(1,20))

打断函数

function fn(){
    console.log('123')
    console.log('123')
    return 
    console.log('123')
    console.log('123')
    console.log('123')
}
fn()

递归函数

函数的一种应用方式 自己调用自己
	= 递 一层一层的进去 递归
	= 归 一层一层的返回 回溯
  = 例子: 5 的阶层 5*4*3*2*1

function fn(n){
    if(n===1){
        return 1
    }
    return n*fn(n-1)
    //  5*4*3*2*1
}

var res = fn(5)
console.log(res)