JS学习25-49

一、for循环

语法： for (var i = 0; i < 10; i++) { }

for (var i = 1; i <= 10; i++) {// 初始化，条件判断，自身改变
  console.log(i)
}// 控制台会依次输出 1 ~ 10 

二、break

终止循环

 // 当 i 的值为 3 的时候，条件为 true，执行 {} 里面的代码终止循环
for (var i = 1; i <= 5; i++) {
  
  console.log('+1')
 
  if (i === 3) {
    break
  }
}

三、continue

跳过本次循环

for (var i = 1; i <= 5; i++) {
  if (i === 3) {
    console.log('跳过3')
    continue
  }
  console.log('+1')
}

四、函数

可快速重复使用的“盒子”

for (var i = 0; i < 10; i++) {
  console.log(i)
}
function fn() {
  for (var i = 0; i < 10; i++) {
    console.log(i)
  }
}

语法：function fn() {}（fn: 函数的名字，需遵循变量名的命名规则和命名规范

函数的调用

声明式函数

function fn() {
  console.log('我是 fn 函数')
}
// 调用函数
fn()

赋值式函数

var fn2 = function () {
  console.log('我是 fn2 函数')
}
// 调用函数
fn()

ps：赋值函数只能先赋值后调用

实参与行参

// 声明式
function fn(行参写在这里) {
  // 一段代码
}

fn(实参写在这里)

// 赋值式函数
var fn = function (行参写在这里) {
  // 一段代码
}
fn(实参写在这里)

如果只有行参的话，那么在函数内部使用的值个变量是没有值的，也就是 undefined
行参的值是在函数调用的时候由实参决定的

**返回值：return **
给函数执行完毕一个结果

预解析
上面提到了一点

• 声明式函数：
  在内存中先声明有一个变量名是函数名，并且这个名字代表的内容是一个函数
  var 关键字 在内存中先声明有一个变量名

fn()
console.log(num)

function fn() {
  console.log('我是 fn 函数')
}

var num = 100

==》

function fn() {
  console.log('我是 fn 函数')
}
var num

fn()
console.log(num)
num = 100

作用域
一个变量可以生效的范围

• 全局作用域：
  全局作用域是最大的作用域
  在全局作用域中定义的变量可以在任何地方使用
  页面打开时生成，关闭时销毁

• 局部作用域：
  在全局作用域下面的一个相对小一些的作用域
  在局部作用域中定义的变量只能在这个局部作用域内部使用
  只有函数能生成一个局部作用域，别的都不行
  每一个函数，都是一个局部作用域

变量使用规则：
有了作用域以后，变量就有了使用范围，也就有了使用规则
变量使用规则分为两种，访问规则和赋值规则

访问规则：
获取一个变量的值：访问
可在作用域内部查找
如果没有，就去上一级作用域查找，依次类推
如果一直到全局作用域都没有这个变量，那么就会直接报错（该变量 is not defined）

var num = 100

function fn() {
  var num2 = 200
   
  function fun() {
    var num3 = 300
    
    console.log(num3) 
    console.log(num2) // 去上一级
    console.log(num) //再往上
    console.log(a) 报错
  }
  fun()
}
fn()

变量赋值规则：
与访问同理，如果一直找到全局作用域都没有，那么就把这个变量定义为全局变量，再给他赋值

function fn() {
  num = 100
}
fn()
console.log(num) // 100

ps： fn 调用以后，要给 num 赋值 ，查看自己的作用域内部没有 num 变量 ，然后 就会向上一级查找 上一级就是全局作用域，发现依旧没有。
就会把 num 定义为全局的变量，并为其赋值
所以 fn()以后，全局就有了一个变量叫做 num 并且值是 100

p37质数练习

五、对象

键值对的集合，{} 里面的每一个键都是一个成员
把一些数据放在一个对象里面，他们就互不干扰了

写法一字面量的方式创建一个对象：

var obj = {}// 创建一个空对象

obj.name = 'Jack'
obj.age = 18

写法二内置构造函数的方式创建对象：

// 创建一个空对象
var obj = new Object()

obj.name = 'Rose'
obj.age = 20

“增”操作p44

var obj = {}
        obj.name = "chris"
        obj.age =19 
        console.log(obj)

或者

 obj["name"] = "chris"

“查”操作

 document.write("姓名是"+obj.name)

”改“和”删“操作(重新赋值，删赋空值

obj.age = 200
 console.log(obj)

删

delete obj.name

六、数组

字面量创建一个数组：

// 创建一个空数组
var arr1 = []

// 用逗号隔开
var arr2 = [1, 2, 3]

内置构造函数创建数组：

// 创建一个空数组
var arr1 = new Array()

// 创建一个长度为 10 的数组
var arr2 = new Array(10)

// 创建一个有内容的数组
var arr3 = new Array(1, 2, 3)

数组的 length：
（length 就是表示数组的长度，数组里面有多少个成员，length 就是多少

// 创建一个数组
var arr = [1, 2, 3]

console.log(arr.length) // 3

数组的索引：
指一个数据在数组里面排在第几个的位置
ps： 索引都是从 0 开始的（所有语言

// 创建一个数组
var arr = ['hello', 'world']

上面这个数组中，第 0 个 数据就是字符串 hello，第 1 个 数据就是字符串 world
想获取数组中的第几个就使用 数组[索引] 来获取

var arr = ['hello', 'world']

console.log(arr[0]) // hello
console.log(arr[1]) // world

数组的排序：
排序，就是把一个乱序的数组，通过我们的处理，让他变成一个有序的数组

冒泡排序：

逐渐上升的比大小
ep：

var arr = [3, 1, 5, 6, 4, 9, 7, 2, 8]

让第 0 项和第 1 项换位置：倒水原理

var tmp = arr[0]
arr[0] = arr[1]
arr[1] = tmp

第一次遍历数组，把最大的放到最后面去

for (var i = 0; i < arr.length; i++) {
  // 判断，如果数组中的当前一个比后一个大，那么两个交换一下位置
  if (arr[i] > arr[i + 1]) {
    var tmp = arr[i]
    arr[i] = arr[i + 1]
    arr[i + 1] = tmp
  }
}// 结果[3, 1, 5, 6, 4, 7, 2, 8, 9]

此时，数组中的最后一个，为最大的数字

重复，数组有多少项就执行多少次

for (var j = 0; j < arr.length; j++) {
  for (var i = 0; i < arr.length; i++) {
    // 判断，如果数组中的当前一个比后一个大，那么两个交换一下位置
    if (arr[i] > arr[i + 1]) {
      var tmp = arr[i]
      arr[i] = arr[i + 1]
      arr[i + 1] = tmp
    }
  }
}

选择排序：

关注重点：索引

方法：先假定数组中的第 0 个就是最小的数字的索引
如果比其小，那就替换之前记录的索引
知道数组遍历结束后，让最小的索引换到第 0 个的位置
在遍历一次数组，找到比我小的那个数字的索引，最后遍历结束后换个位置

var arr = [3, 1, 5, 6, 4, 9, 7, 2, 8]

假定数组中的第 0 个是最小数字的索引

var minIndex = 0

遍历数组，判断，只要数字比我小，那么就替换掉原先记录的索引

var minIndex = 0
for (var i = 0; i < arr.length; i++) {
  if (arr[i] < arr[minIndex]) {
    minIndex = i
  }
}
// 最后让第 minIndex 个和第 0 个交换
var tmp = arr[minIndex]
arr[minIndex] = arr[0]
arr[0] = tmp

同理，重复执行以上的代码

for (var j = 0; j < arr.length; j++) {
  // 
  var minIndex = j
  
 
  for (var i = j + 1; i < arr.length; i++) {// 直接从 j + 1 开始
    if (arr[i] < arr[minIndex]) {
      minIndex = i
    }
  }

  // 遍历结束后找到最小的索引，第一堂的时候是和第 0 个交换，第二趟的时候是和第 1 个交换
  // 直接和第 j 个交换即可
  var tmp = arr[minIndex]
  arr[minIndex] = arr[j]
  arr[j] = tmp
}