javaScript基础(学习笔记)

js基础

弹出框

<script>
        var iname = prompt('请输入一个名字');/*  弹出输入框,输入的类型会转换成string */
        alert(iname)
        console.log(iname);
            var age = 18,
                id = 123,       /*123为数字字面量*/
                price = 66;    /*同时声明多个变量*/
        
        var sex;
        console.log(sex);  //结果为undefined
        qq = 11;
        console.log(qq);   //结果为110，不生命变量可使用，但不提出
    </script>

字符串变量可以用' ',也可以用" ",还可以用``反引号

/*模板字符串用` `反引号包起来，解决了字符串拼接繁琐，可以换行，传统的拼接不能换行，换行会被当作结束。*/
let age = 18
        document.write(`我今年${age}岁了！`)
        document.write(`我今年${age + 5}岁了！`)
        document.write(`
        <p>我今年${age + 5}岁了！</p>
        <p>名字是mike</p>
                        `)
-------------------------------------------------------------------
        console.log(typeof uname) /* 检测数据类型 */
        let age = prompt('请输入年龄')
        let num = 10
        console.log(typeof num + '10') /* 先检测数据类型，再做拼接，结果number10 */
        console.log(typeof age + '10')/* 先检测数据类型，再做拼接，输入10，结果string10 */
        console.log(typeof (num + '10')) /*结果string */
        console.log(typeof (num + + '10')) /* 结果number */

类型转换

        //隐式转换,通过表单和prompt()获取的都是String类型
        console.log(10 + '10')    /* 1010 */
        // 除了+号，- * /默认把'10'转换成数字类型
        console.log(10 - '10')     /* 0 */
        let num = '10'
        console.log(typeof +num)   /*  小技巧：+ 号作为正号解析可以转换成number型 */
​
        //显式转换
        //转换成数字类型
        console.log(Number('10'))
        // 只取整数部分
        console.log(parseInt(10.68))
        // 保留小数部分
        console.log(parseFloat(20.132))
  ☆    // 区别：Number( )只能放数字类型，不能放String这样的，否者返回NAN，not a number
        console.log(Number('10.1abc'))
        // parseFloat会自动去掉abc部分
        console.log(parseFloat('20.132abc'))
        console.log(parseFloat('abc20.132abc'))/*返回也是NAN*/
​
        //转换成字符串类型
        console.log(String(10))
        let age = 10
        console.log(age.toString())
        // 转换成二进制
        console.log(age.toString(2))
☆     undefind+其他数据类型 = NAN
        undefind + 'str类型' = undefindstr类型

综合案例

let str = ''
        let money = 100
        while (str !== '4') {
            str = prompt(`
           1、存款
           2、取款
           3、查看余额
           4、退出
           `)
            switch (str) {
                case '1':
                    let cMoney = +prompt('请输入要存的钱')
                    money += cMoney
                    break
                case '2':
                    let qMoney = +prompt('请输入你要取走的钱')
                    money -= qMoney
                    break
                case '3':
                    alert(`余额:${money}`)
                    break
            }
        }

运算符

自增运算符也就是一元运算符，++自增，--自减

前置自增参与运算时，先自增后使用，后置自增参与运算时，先使用后自增

        let i = 1
        console.log(i++ + ++i + i)  /*结果是7*/

赋值运算符

> :大于
< :小于
>= :大于等于
<= :小于等于
== :左边和右边是否相等(只要值一样，不管数据类型就是true)
=== :左边和右边是否类型和值都相等
!== :左右两边是否不全等 
比较结果为布尔值，即只会得到true和false
☆ NAN不等于任何值,包括自身.
不要比较小数，精确度有问题
​
        let num = prompt('请输入一个数字')
        num = num || 0     /*没输入的时候，返回的是空字符串，这时候就是0*/
        console.log(num % 4 === 0 && num % 100 !== 100)

switch

switch(数据){
    case 值 :
        代码
        break/continue
    case 值 :
        代码
        break/continue
    default:
        代码
            }
☆ 运行过程：1.找到跟小括号里面数据全等的case值，并执行里面的代码
           2.若没有全等=== 的值，则执行default里面的值

数组

数组是一种有顺序的数据类型，通过.length获取长度

  //数组.push()方法将一个或多个元素增加到数组末尾,并返回该数组的新长度
        let num = [1, 2, 3, 4, 5]
        num.push('pink', 'red')
​
       // 数组.unshift()方法将一个或多个元素增加到数组前面, 并返回该数组的新长度
        let num = [1, 2, 3, 4, 5]
        num.unshift('pink', 'red')
        console.log(num)
---------------------------------------------------------------------
        let num = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7]
        let num2 = []
        for (let i = 0; i < num.length; i++) {
            if (num[i] >= 10) {
                // console.log(num[i])
                num2.push(num[i])
            }
        }
        console.log(num2)
​
        // 数组.shift()方法从数组中删除第一个元素,并返回该元素的值
        let num = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7]
        num.shift()
        console.log(num)
​
        // 数组.pop()方法从数组中删除最后一个元素,并返回该元素的值
        let num = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7]
        num.pop()
        console.log(num)
​
        // 数组.splice(从哪个下标开始删，删几个)方法从数组中删除指定元素
        let num = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7]
        num.splice(1,2)
        console.log(num)

函数

 let n = [2, 1, 6, 1, 77, 0, 52, 0, 25, 7]
        function getSum(num) {
            let a
            for (let i = 0; i < num.length - 1; i++) {
                for (let j = i + 1; j < num.length; j++) {
                    if (num[i] > num[j]) {
                        a = num[j]
                        num[j] = num[i]
                        num[i] = a
                    }
                }
            }
            return num    /*  return不要换行，有结束当前函数的作用.函数没有返回值默认undefind */
        }
        let result = getSum(n)
        document.write(result)

------------------------------------------------
        let n = [2, 1, 6, 1, 77, 0, 52, 0, 25, 7]
        function getMax(num) {
            let max = num[0]
            let i = 1
            while (i < num.length) {
                if (num[i] > max) {
                    max = num[i]
                }
                i++
            } return max
        }
        let max = getMax(n)
        document.write(max)

//返回多个值用数组 return[x,y]
//如果函数内部和块级作用域，没有声明，直接赋值，就当全局变量看。但是强烈不推荐
函数没有写形参，调用函数写实参，函数里面通过argument伪数组接收

匿名函数

let fn = function(){
            函数体
        }
调用：
fn()

立即执行函数

 // 立即执行函数,加不加函数名关系不大,立即函数里面的变量是局部变量  (function(){})(),(function(){}())
        (function (x, y) {
            console.log(x + y)
        })(1, 3)          /*  多个立即执行函数要用;隔开 */
            ; (function () {
                console.log(222)
            }())

对象

let 对象名 = {
    属性名: 属性值,
    方法名: 函数
} /*对象是一种无序的数据集合，能够详细地描述某个事物.由属性和方法组成*/
//访问属性，得到属性值，对象.属性名 或者 对象['属性名']
案例
let person = {
            uname: '德华',
            age: 18,
            sex: '男'
        }
        console.log(`名字：${person.uname}，今年${person.age}岁，性别：${person.sex}`)
//对象的遍历
for (let k in person){
    //k是属性名
    person[k] /*取值*/
}

对象中的方法访问 对象.方法名（）

随机数

//求N 到 M之间的一个随机数公式
Math.floor(Math.random() * (M - N + 1)) + N  //M是大的数
一般封装成函数使用

  function getRandom(min, max) {
            return Math.floor(Math.random() * (max - min + 1)) + min
        }
        let r = getRandom(1, 3)
        console.log(r)

不同数据类型的存储方式

//内存里面有栈内存和堆内存，简单数据类型存储到栈内存里面，引用数据类型存储在堆内存里面

        let num1 = 10
        let num2 = num1
        num2 = 20
        console.log(num1)  /*简单数据类型（直接存储一个值），num2影响不了num1*/

        let obj1 = {
            age: 18
        }
        obj2 = obj1
        obj2.age = 20
        console.log(obj1.age)  /*20*/

//矩形栈内存，圆形堆内存