js小汇总

已于 2023-04-10 09:22:06 修改
阅读量353 收藏
点赞数
文章标签： javascript 学习 前端
于 2023-03-23 00:04:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52845451/article/details/129721480
版权

目录

js假值

js表达式&js语句

== 与 ===

一元运算符 与（& &&）或（| ||）非（!）

数据类型

类型转换

递增/减

循环语句

判断是否为数组

函数相关

类与对象的关系

原型链

对象相关

js假值

一共有6个，分别是

null，undefined，false，0，NaN，''

  • NaN不等于任何值，包含本身
NaN===NaN   //false
  • undefined + 任何值 = NaN，除了加字符串。
  • 转换undefined为数字型，也是NaN
  • 字符串转数字，除了数字字符串会转为数字，其他的转换也是NaN
  • parseInt()，转除了数字字符串和数字型以外的，也是NaN
  • parseFloat()，转除了数字字符串和数字型以外的，也是NaN
// 
console.log(1 + undefine) // NaN
console.log('123' + undefined) // 123undefined
// 
console.log(Number(undefined)) // NaN
console.log(undefined - 0) // NaN
// 
let str = '99' // 数字字符串
console.log(Number(str)) // 99
let s = 'a'
console.log(Number(s)) // NaN
// parseInt() 只能转换数字字符串和数字型的，会向下取整
console.log(parseInt('123')) // 123
console.log(parseInt(99)) // 99
console.log(parseInt(99.99)) // 99
console.log(parseInt('a')) // NaN
console.log(parseInt(true)) // NaN
console.log(parseInt(null)) // NaN
console.log(parseInt(undefined)) // NaN
// parseFloat() 也是只能转换数字字符串和数字型的，但是会保留小数
console.log(parseFloat('123.09')) // 123.09
console.log(parseFloat(99)) // 99
console.log(parseFloat(99.99)) // 99.99
console.log(parseFloat('a')) // NaN
console.log(parseFloat(true)) // NaN
console.log(parseFloat(null)) // NaN
console.log(parseFloat(undefined)) // NaN

js表达式&js语句

表达式就是会产生一个结果(值)的代码，可以写在右侧

let count = 10 + 20 // 右面就是一个表达式，会产生一个具体的值

语句就是一段可执行的代码(for,if,log,dir,alert...)

for(let i = 0;i < 9;i++) { console.log(i) } // 这个就是个js语句，不会产生值，就是执行

== 与 ===

双等只需要值相等，数据类型可以不同

null == undefined // true

三等既需要值相等，数据类型也要相同

null === undefined // false

一元运算符 与（& &&）或（| ||）非（!）

  • & 和 &&(短路与)     全真才为真
// 值对比
console.log(0 & 1) // 0
console.log(0 && true) // 0
// 值与表达式对比
console.log(2 + 5 & 0) // 0
console.log(2 + 5 && 0) // 0
console.log(2 + 5 & false) // 0
// 值与语句对比
0 & console.log('左为假,单&,执行了')     // 输出了,因为单&,前后都会对比,所以不管前面真假都会输出
1 & console.log('左为真,短路&,执行了')   // 输出了，同上
0 && console.log('左为假,单&,执行了')    // 未执行,因为短路&,前面的为假,就不会执行后面的了
1 && console.log('左为真,短路&,执行了')  // 执行了，推荐用这个，可以代替简单的if判断
  • | 和 ‖(短路或)     全假才为假
// 值对比
console.log(0 | 1) // 1
console.log(0 || true) // true
// 值与表达式对比
console.log(2 + 5 | 0) // 7
console.log(2 + 5 || 0) // 7
console.log(2 + 5 | false) // 7
// 值与语句对比
0 | console.log('左为假,单|,执行了')     // 输出了,因为单|,前后都会对比,所以不管前面真假都会输出
1 | console.log('左为真,单|,执行了')   // 输出了，同上
0 || console.log('左为假,短路|,执行了')    // 执行了，推荐用这个，可以代替简单的if判断
1 || console.log('左为真,短路|,执行了')  // 未执行,因为短路|,前面的为真,就不会执行后面的了
  • ！取反操作
console.log(!0) // true
console.log(!1) // false
console.log(!true) // false
console.log(!false) // true
console.log(!(99 - 9)) // true

数据类型

基本数据类型

string,number,boolean,undefined,null,symbol

复杂(引用)数据类型

Object(Array,Function),Map,Set

  • 通过 typeof() 判断数据类型

类型转换

转字符串：toString()，'' + 其他(隐式转换)，String()

// 数值
let num = 99
console.log(String(num)) // '99'
console.log(typeof (String(num))) // string
// 布尔
let flag = true
console.log(flag + '123') // 'true123'
// undefined
let un = undefined
console.log(String(un)) // 'undefined'
console.log(typeof (String(un))) // string
// 对象,toString是从Object基类继承下来的
const obj = { name: 'zs' }
console.log(obj.toString()) // '[object Object]'
console.log(typeof (obj.toString())) // string

转数字型：Number()，+号(隐式转换)，-*/(隐式转换)，parseInt()，parseFloat()

// 假值转换成数字型，都会为0
// 布尔
let flag = true
console.log(flag - 0) // 1
// null
let n = null
console.log(+n) // 0
// string,只能转换数字字符串，其他的也是NaN
let str = '99' // 数字字符串
console.log(Number(str)) // 99
let s = 'a'
console.log(Number(s)) // NaN
// undefined,注意这个，这个不管强转还是隐式转换，都是NaN
let un = undefined
console.log(un - 0) // NaN
console.log(Number(un)) // 0
// parseInt() 只能转换数字字符串和数字型的，会向下取整
console.log(parseInt('123')) // 123
console.log(parseInt(99)) // 99
console.log(parseInt(99.99)) // 99
console.log(parseInt('a')) // NaN
console.log(parseInt(true)) // NaN
console.log(parseInt(null)) // NaN
console.log(parseInt(undefined)) // NaN
// parseFloat() 也是只能转换数字字符串和数字型的，但是会保留小数
console.log(parseFloat('123.09')) // 123.09
console.log(parseFloat(99)) // 99
console.log(parseFloat(99.99)) // 99.99
console.log(parseFloat('a')) // NaN
console.log(parseFloat(true)) // NaN
console.log(parseFloat(null)) // NaN
console.log(parseFloat(undefined)) // NaN

转布尔型：Boolean()

// 假值转换成布尔，都会为false
console.log(Boolean(0)) // false
console.log(Boolean(1)) // true
console.log(Boolean(undefined)) // false
console.log(Boolean(null)) // false
console.log(Boolean('a')) // true
console.log(Boolean('')) // false

递增/减

递增递减单独使用

let num = 10
// 前++/--,会先进行自增/减
console.log(++num) // 11
console.log(--num) // 10
// 后++/--,会先进行紧挨的操作，操作完成后再自增/减
console.log(num++) // 10，因为它会先进行输出，输出后(10)，num自增(10 + 1)，这时num是11
console.log(num--) // 11，因为它会先进行输出，输出后(11)，num自减(11 - 1)，这时num是10

递增递减参与运算时

  • 前增/减，先自增/减，再参与运算
  • 后增/减，先参与当前次运算，然后再自增/减
let num = 10
// 前++/--,会先进行自增/减
console.log(10 + ++num) // 21,num会先自增(10 + 1),此时的num为11,然后参与运算(10 + (10 + 1))
console.log(10 + --num) // 20,num会先自减(11 - 1),此时的num为10,然后参与运算(10 + (11 - 1))
// 后++/--,会先进行紧挨的操作，操作完成后再自增/减
console.log(10 + num++) // 20，因为它会先进行运算(10 + 10)，输出后(20)，num自增(10 + 1)，这时num是11
console.log(num) // 11
console.log(10 + num--) // 21，因为它会先进行运算(10 + 11)，输出后(21)，num自减(11 - 1)，这时num是10
console.log(num) // 10

练习：

let num = 10
let res = num++ + 10 - num-- + ++num
// 1. num + 10 = 20  num = 11
// 2. 20 - 11 = 9  num = 10
// 3. 9 + 11 = 20 num = 11
console.log(res) // 20

循环语句

switch...case

  • 一般用于等值运算，不适合区间判断
let i = 2
switch (i) {
    case 0:
        console.log(0);
        break;
    case 1:
        console.log(1);
        break;
    case 2:
        console.log(2);
        break;
     default:
        console.log('...');
        break;
}

for

  • 适合不确定次数的，并且不会跳过假值，里面的变量是局部变量
for (var i = 0; i < 10; i++) {
    console.log(i);
}
// 不会跳过假值
const arr = [, , , , ,]
for (let i = 0; i < arr.length; i++) {
    arr[i] = 'a' + i
}
console.log(arr) // ['a0', 'a1', 'a2', 'a3', 'a4']

while

  • 适合确定次数的
let i = 0
while (i < 3) {
    console.log(i)
    i++
}

无限循环

while(true) ｛｝      或     for(；；；)｛｝

判断是否为数组

  1. Array.isArray()，会返回一个布尔值
  2. insranceOf 运算符，会判断是否在其原型链上
let arr = [1, 2, 3]
// Array.isArray(arr)
console.log(Array.isArray(arr)) // true
// instanceof 运算符
console.log(arr instanceof Array) // true

函数相关

函数的参数可以传入默认值

function 函数名(参数名 = 默认值)｛ 函数体 ｝

形参当成局部变量

unction fn(args) {
    return args
}
console.log(fn(99)) // 99
console.log(args) // 会直接报错的，因为形参是局部变量，只能函数体内用。args is not defined

return返回一个值，如果想返回多个值，用数组或对象

// 只能返回第一个,因为遇到return，就会终止函数
function fn() {
    return '99'
    return 0
}
console.log(fn()) // '99'
// 需要返回很多数据时，最好用对象或数组
function fun() {
    return {
        xx: 0,
        xxx: 1,
        xxxx: 2,
        // ...
    }
}
console.log(fun()) // {xx: 0, xxx: 1, xxxx: 2}
function f() {
    return [1, { xx: 0 }, 'pink', '4']
}
console.log(f()) // [1, {…}, 'pink', '4']

return结束的是函数，break结束的是循环，contation跳出的是本次循环

// return 终止的是函数
function fn() {
    let num = 10
    num++
    num--
    return num
}
console.log(fn()) // 10
// breack 终止的循环
for (let i = 0; i < 10; i++) {
    if (i === 5) {
        console.log('到5就结束了')
        break
    }
}
// continue 跳出的是本次循环
for (let i = 0; i < 10; i++) {
    if (i === 3) {
        continue
    }
    console.log(`第${i}次执行`)
}

函数如果不确定有多少参数

  • 可以用arguments，函数内置的，以伪数组形式存储，不需要写在参数里
function fn() {
    console.log(arguments)
    // arguments以伪数组形式进行存储
    console.log(Array.isArray(arguments)) // false
    // 伪数组是用不了真数组的方法的,如果我们想用真数组的方法,需要把它转成真数组(Array.from())
    // arguments.forEach(item => {
    //     console.log(item) // 用不了真数组的方法
    // })
    console.log(Array.from(arguments)) // [10, 20, 30, 40, 50]
    // 可以用循环正常遍历，伪数组存在length属性
    for (let i = 0; i < arguments.length; i++) {
        console.log(`伪数组第${i}项:`, arguments[i])
    }
    // 不写return,默认返回undefined
    // return
}
fn(10, 20, 30, 40, 50)
  • 还可以用剩余(rest)参数，需要写在参数里fun(...args)｛｝，或fun(a,b,...args)｛｝
function fn(...args) {
    // 是真数组呦
    console.log(args[0]) // 10
    console.log(args[1]) // 20
    // ...
}
fn(10, 20, 30, 40, 50)
function fun(num1, num2, ...args) {
    console.log(num1) // 10
    console.log(num2) // 20
    console.log(args[0]) // 30
}
fun(10, 20, 30, 40, 50)

作用域

  • 分为全局作用域和局部作用域，域就是块，可以理解为代码可执行的范围，再简单理解，就是｛｝包住的
  • 域的出现，主要是为了解决命名的问题，有效防止了命名冲突，不同域里可以写同名变量，互不影响
// 全局作用域,全局生效
let num = 100 // 全局变量
function fn() { // 全局函数
    // 局部作用域，只在块(域)内生效
    let num = 99 // 局部变量
    console.log(num) // 99
    return function () { // 局部函数
        return num
    }
}
// 全局函数，全局都可以进行调用
fn() // 99
let res = fn()()
console.log(res) // 99(第一个99，是外层函数打印的) 99(第二个99，是调用闭包，接收的变量值为99)

函数分为具名函数(普通函数)和匿名函数(函数表达式)

  • 普通函数，具有函数提升，可以放在任何位置
// 具有函数提升
let res = fn()
console.log(res) // 99
// 普通函数
function fn() {
    return 99
}
  • 函数表达式，把函数用一个变量接收，必须先声明，再调用
// 函数表达式，用变量接收函数
const fn = function () {
    return 100
}
console.log(fn()) // 100
const fun = () => {
    return 99
}
console.log(fun()) // 99
  • 还有一种特殊函数，立即执行函数(立即执行函数):末尾一定写分号(不然他会以为不是结尾，跟下面代码混一块啦)

(function()｛｝)() ； 或  (function()｛｝())；

  • 箭头函数，本身没有this指向，会找它上一个作用域的this赋值给自身，只要第一次确认了，后面就不会变
const obj = {
    name: 'zs',
    sing: function () {
        console.log(this) // {name: 'zs', sing: ƒ, dance: ƒ}
    },
    dance: () => {
        console.log(this) // window
    }
}
// 对象的方法，如果是普通函数，this指向对象本身
obj.sing()
// 如果是箭头函数，则指向window
obj.dance()

类与对象的关系

类是抽象的，包含了一大类，抽离了一些这一类公有的属性和行为

es6之前的类，表现形式就是构造函数

// 构造函数首字母大写，用于与普通函数做区分(推荐首字母大写)
        function Person(name, age, gender) {
            // 属性
            this.name = name
            this.age = age
            this.gender = gender
            // 行为
            this.say = function (language) {
                return '会说' + language
            }
        }
        // 想要使用构造函数，需要new关键字
        let zs = new Person('张三', 24, '男')
        console.log(zs) // Person {name: '张三', age: 24, gender: '男', say: ƒ}
        console.log(zs.say('中文')) // 会说中文

es6新增了类class

// 类名首字母大写
        class Person {
            // 属性
            constructor(name, age, gender) {
                this.name = name
                this.age = age
                this.gender = gender
            }
            // 行为
            say(language) {
                return `会说${language}`
            }
        }
        // 使用类，也需要new关键字，new就是new出来一个具体的，真实存在的对象
        const ls = new Person('李四', 24, '男')
        console.log(ls) // Person {name: '李四', age: 24, gender: '男'}
        console.log(ls.say('中文')) // 会说中文

我们new一个类，就会得到一个具体的对象，对象是具体的，真真实实存在的。打个比方，例如人类，就是一个大类，类里面存放一些人类共有的属性(名词)和行为(动词)，然后，我，就是一个实实在在的人，就是一个对象。通过new 人类，就会得到一个具体的对象

原型链

作用：

  • 用来存放一些公用的属性和方法

谁存在原型：

  • 函数与对象都是有原型的
  • 函数有显示原型prototype
  • 对象有隐式原型__proto__

我们new一个构造函数或者类，就会得到一个新的对象，构造函数的prototype其实就等于new出来这个对象的__proto__

图解

代码

// 构造函数
        function Person(name, age, gender) {
            this.name = name
            this.age = age
            this.gender = gender
            this.say = function (language) {
                return '会说' + language
            }
        }
        console.log(Person.prototype) // {constructor: ƒ}
        console.log(Person.prototype.constructor) // 指回构造函数
        console.log(Person.prototype.constructor === Person) // true
        // new出来的实例化对象
        const ls = new Person('李四', 24, '男')
        console.log(ls.__proto__) // {constructor: ƒ}
        console.log(Person.prototype === ls.__proto__) // true
        console.log(ls.__proto__.constructor) // 指回构造函数

原型查找机制:

对象本身查找-->去创建当时对象的构造函数中查找-->去对象的原型中查找-->去构造函数的原型中查找-->去原型的原型中查找直到查找到null

图解

代码

// 构造函数
function Person(name, age, gender) {
    this.name = name
    this.age = age
    this.gender = gender
    this.say = function (language) {
        return '会说' + language
    }
}
console.log(Person.prototype) // {constructor: ƒ}
console.log(Person.prototype.constructor) // 指回构造函数
console.log(Person.prototype.constructor === Person) // true
// new出来的实例化对象
const ls = new Person('李四', 24, '男')
console.log(ls.__proto__) // {constructor: ƒ}
console.log(Person.prototype === ls.__proto__) // true
console.log(ls.__proto__.constructor) // 指回构造函数
// 但是实例化对象的隐式原型__proto__(又叫原型对象，也是个对象)也存在原型。这样一层一层往上查找，形成一条原型链，直到指向null
console.log(ls.__proto__.__proto__.__proto__) // null

原型链的最顶端是null

对象相关

遍历对象

  • 推荐for...in，不能用for...of(因为对象内置没有Iterator，用不了，非要用，就手动添加Iterator)
const obj = {
            name: 'zs',
            age: 24,
            gender: '男',
            sing: function () {
                return '唱'
            }
        }
        for (const key in obj) {
            console.log(key) // 对象的键名
            console.log(obj[key]) // 对象的值名
        }

访问对象属性

  • 对象名.访问
const obj = { name: 'zs', age: 24, gender: '男', }
console.log(obj.name) // 'zs'
  • 对象名['属性名']   ， 对象名[变量名]访问，这种适合属性名为变量的，动态的
const obj = { name: 'zs', age: 24, gender: '男', }
// 对象名['键名']
console.log(obj['age']) // 24
// 对象名[变量名]
let key = 'gender'
console.log(obj[key]) // '男'

对象的键名是字符串，只是默认省略了。如果对象的键中有-，则就需要用引号包住啦

const obj = { name: 'zs', age: 24, gender: '男', 'sing-dance-rap': '唱跳rap' }
console.log(obj['sing-dance-rap']) // '唱跳rap'

对象中如果不存在某属性，会输出undefined

const obj = { name: 'zs', age: 24, gender: '男' }
console.log(obj.sing) // undefined

对象中不存在某属性，但是直接给这个属性赋值，则对象中就会添加此属性

const obj = { name: 'zs', age: 24, gender: '男' }
obj.sing = '唱'
console.log(obj['sing']) // 唱

in运算符

  • 可以判断对象中是否存在某属性
const obj = {
            name: 'zs',
            age: 24,
            gender: '男',
            sing: function () { return '唱' }
        }
        console.log(name in obj) // true
        // console.log(dance in obj) // 会报错

对象的一些方法

  • Object.keys(对象名)    会返回对象的键组成的数组
const obj = {
            name: 'zs',
            age: 24,
            gender: '男'
        }
        let keys = Object.keys(obj)
        console.log(keys) // ['name', 'age', 'gender']
  • Object.values(对象名)     会返回对象的值组成的数组
const obj = {
            name: 'zs',
            age: 24,
            gender: '男',
            sing: function () { return '唱' }
        }
        let values = Object.values(obj)
        console.log(values) // ['zs', 24, '男', ƒ]
  • Object.assign(对象名)     会拷贝对象，是浅拷贝
const obj = {
            name: 'zs',
            age: 24,
            gender: '男',
            sing: function () { return '唱' }
        }
        let newObj = Object.assign(obj)
        console.log(newObj) // {name: 'zs', age: 24, gender: '男', sing: ƒ}
        // 是浅拷贝
        console.log(obj === newObj) // 因为地址相同，所以为true，浅拷贝
  • Object.entries(对象名)     会返回对象键值对的数组
const obj = {
            name: 'zs',
            age: 24,
            gender: '男',
            sing: function () { return '唱' }
        }
        let keysValues = Object.entries(obj)
        console.log(keysValues)
  • Object.fromEntries(对象名)     可以把二维数组转换成对象，与Object.entries(对象名) 方法互逆操作
const obj = {
            name: 'zs',
            age: 24,
            gender: '男',
            sing: function () { return '唱' }
        }
        let keysValues = Object.entries(obj)
        console.log(keysValues)
        let newObj = Object.fromEntries(keysValues)
        console.log(newObj) // {name: 'zs', age: 24, gender: '男', sing: ƒ}

小辉吖～
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
javascript 应用小技巧方法汇总
10-23
### JavaScript 应用小技巧方法汇总 #### 事件处理技巧 在JavaScript中处理事件是提升用户体验的重要手段。技巧包括获取事件源对象的标签名和类型，使用`event.srcElement.tagName`和`event.srcElement.type`。例如...
Javascript常用小技巧汇总
10-24
本文将深入探讨JavaScript中的几个常用小技巧，这些技巧可以帮助开发者提高代码效率和可读性。 首先，我们来看看布尔表达式。在JavaScript中，`null`, `undefined`, 空字符串`''`, 以及数字`0`被视为假性值（falsy...
正则表达式
LiErDan的博客
02-11 554
元字符 '/.*?/' ---&gt; .代表除换行外任意字符, *代表0次或多次, ?放在次数后面代表懒惰模式,相对于贪婪模式, 若放在元字符后面代表0次或1次; 模式修正符 '/^[a-z].*$/i' //不区分大小写 '/^[a-z].*$/s' //万能点模式 '.'可以匹配包括换行的任意字符 '/[\x{4e00}-\x{9fa5}]/u' //表示采用utf8编...
常用特殊符号--网络搜比PPT插入更快
Joyce1001的博客
05-16 3870
1.常用的特殊符号大全 囧⊙●○⊕◎Θ⊙¤㈱㊣★☆♀◆◇◣◢◥▲▼△▽⊿◤ ◥ ▂ ▃ ▄ ▅ ▆ ▇ █ █ ■ ▓ 回 □ 〓≡ ╝╚╔ ╗╬ ═ ╓ ╩ ┠ ┨┯ ┷┏ ┓┗ ┛┳⊥『』┌ ┐└ ┘∟「」↑↓→←↘↙♀♂┇┅ ﹉﹊﹍﹎╭ ╮╰ ╯ _ * - _ （ ∵∴‖｜ ｜︴﹏﹋﹌（）〔〕 【】〖〗＠：！/\ " _ < > `,·。≈{}~ ～() _ -『』√ $ @ ...
特殊符号大全(建议收藏_复制着用_数学符号最下面)
热门推荐
红目香薰
09-02 17万+
数字符号 ① ② ③ ④ ⑤ ⑥ ⑦ ⑧ ⑨ ⑩ ⑪ ⑫ ⑬ ⑭ ⑮ ⑯ ⑰ ⑱ ⑲ ⑳ ⑴ ⑵ ⑶ ⑷ ⑸ ⑹ ⑺ ⑻ ⑼ ⑽ ⑾ ⑿ ⒀ ⒁ ⒂ ⒃ ⒄ ⒅ ⒆ ⒇ ⒈ ⒉ ⒊ ⒋ ⒌ ⒍ ⒎ ⒏ ⒐ ⒑ ⒒ ⒓ ⒔ ⒕ ⒖ ⒗ ⒘ ⒙ ⒚ ⒛ ㊀ ㊁ ㊂ ㊃ ㊄ ㊅ ㊆ ㊇ ㊈ ㊉ ㈠ ㈡ ㈢ ㈣ ㈤ ㈥ ㈦ ㈧ ㈨ ㈩ № ½ ⅓ ⅔ ¼ ¾ ⅛ ⅜ ⅝ ⅞ 希腊数字 Ⅰ Ⅱ Ⅲ Ⅳ Ⅴ Ⅵ Ⅶ Ⅷ Ⅸ Ⅹ Ⅺ Ⅻ ⅰ ⅱ ⅲ ⅳ ⅴ ⅵ ⅶ ⅷ ⅸ ⅹ ⅺ ⅻ 月份符号 ㋀
$J的用法
12-28 6595
$J相当于C里面的static类型 procedure TForm1.Button1Click(Sender: TObject);const{$J+} i: integer = 0;{$J-}begin ShowMessage(IntToStr(i)); Inc(i);end; 转载于:https://www.cnblogs.com/Jekhn/archi...
javascript小知识点汇总
luluzsa的博客
08-29 257
document对象常指document本身，DOM Element则指document对象获得的元素本身。1.document对象和DOM Element的区别。
js知识汇总
weixin_41246577的博客
07-02 119
补码 https://blog.csdn.net/weixin_41246577/article/details/94437852
微信小程序面试题汇总
jyl919221lc的博客
06-05 3781
(1) 首先在挨批评。App.json中配置tabbar，开启custom 自定义tabbar，配置完之后创建custom-tab-bar文件，这时候会在小程序底部生成文件内容，给index.wxml添加tabBar的结构代码， 给index.js 添加数据配置 和 事件方法(1) 小程序全局对象是: wx，所有的 API 都保存在 wx 对象中(1) 创建components文件夹(2) 创建组件文件(例tabs)，新建为component形式。
js实战小技巧汇总
weixin_44745920的博客
11-16 474
js小技巧汇总 记录实战开发中使用到的js技巧 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录js小技巧汇总前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么
js 数组对象分类汇总
weixin_45274523的博客
02-06 386
【代码】js 数组对象分类汇总。
js知识点汇总
少说，多做。
11-05 2万+
1.本门课的作用（JavaScript的作用）所有基于Web的程序开发基础 2.一种计算机客户端脚本语言，主要在Web浏览器解释执行。 3.浏览器中Javascript，用于与用户交互，以及实现页面中各种动态特效 4.在HTML文件中，任何JavaScript代码必须放到<script>标签中 5.把JavaScript代码放到外部文件中，在HTML代码中直接引入该文件(外部文...
JavaScript 小游戏代码汇总
07-02
JavaScript 小游戏代码汇总 JavaScript 是一种广泛使用的脚本语言，常用于开发 web 应用程序尤其是游戏开发。以下是 JavaScript 小游戏代码汇总的知识点： 1. HTML 基础：代码开头使用的 `<!DOCTYPE html>` 声明...
微信小程序 实例汇总 完整项目源代码
11-01
同时，JavaScript用于处理逻辑和数据绑定。 2. **页面生命周期**：每个小程序页面都有其独特的生命周期，包括onLoad、onShow、onReady、onHide、onUnload等方法，开发者需要理解并合理利用这些方法来管理页面状态。...
微信小程序骨架屏
djjdjdjdjddjjdjd的博客
08-16 301
⑤ 在onLoad 中页面加载前定义 isLoading.value=true, 在加载完后定义 isLoading.value=false.骨架屏是页面的一个空白版本，通常会在页面完全渲染之前，通过一些灰色的区块大致勾勒出轮廓，待数据加载完成后，再替换成真实的内容。① 在相应微信小程序页面右下角点生成骨架屏，左侧小程序目录会自动生成 .wxml 、.wxss 文件，⑥ 在生成骨架屏页面中 v-if="isLoading" v-else 定义显示与隐藏。
网上商品订单转手系统bootpf
最新发布
weixin_43213064的博客
08-18 387
【代码】springboot网上商品订单转手系统bootpf
vue3进阶用法之通过调用函数动态加载组件用法及示例
wz9608的博客
08-14 355
vue官方文档那边虽然说了函数的使用方法，但没有列举这种业务场景。这里只是做一个简单的实例，其实可以通过这种方法实现其他更多的功能，比如说modal框等等等。
44 个 React 前端面试问题
广漂程序猿DevinRock
08-14 1019
虚拟 DOM 是 React 中的一个概念，其中创建实际 DOM（文档对象模型）的轻量级虚拟表示并将其存储在内存中。它是一种用于优化 Web 应用程序性能的编程技术。当 React 组件的数据或状态发生更改时，虚拟 DOM 会被更新，而不是直接操作真实 DOM。然后，虚拟 DOM 计算组件的先前状态和更新状态之间的差异，称为“比较”过程。一旦识别出差异，React 就会高效地仅更新真实 DOM 的必要部分以反映更改。这种方法最大限度地减少了实际 DOM 操作的数量，并提高了应用程序的整体性能。
【vue教程】五. Vue 的路由管理
前端探索者
08-13 1159
Vue Router 是 Vue 官方的路由管理器，用于构建单页面应用。它允许你通过 URL 来映射不同的组件，实现页面的动态加载和导航。路由守卫用于在路由跳转前后执行代码，可以用来检查用户认证状态、获取数据等。通过本篇文章，我们学习了 Vue Router 的基本概念、配置和使用，以及如何实现动态路由和嵌套路由。我们还探讨了路由守卫的概念，并提供了如何在 Vue 组件中使用它们的示例。这些知识点将帮助你构建一个功能完备的单页面应用。
JavaScript表单验证技巧汇总
96-105对应小键盘上的数字键）。 - 使用`onkeypress`事件，限制按键码小于45或大于57的字符。 - 监听`keyup`事件，去除除数字以外的所有字符。 ```html <!-- 方法一 --> (event.keyCode || event.keyCode > 57...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值