day0425

最新推荐文章于 2023-04-25 18:37:08 发布
最新推荐文章于 2023-04-25 18:37:08 发布
阅读量135 收藏
点赞数 2
分类专栏： qianfeng
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46008442/article/details/116117499
版权

day0425

类

在这里插入图片描述

类：模具
对象：类的实例

实例化对象，可以写小括号，也可以不写小括号，如果实例化时构造函数有参数，则必须写
写小括号优先级更高20，不写小括号优先级低一点19

JavaScript运算符优先级汇总表：

在这里插入图片描述

构造函数和普通函数的区别

在这里插入图片描述

ES6中的类
// es6中提供的一个语法糖 class 它可以方便我们去完成类的创建
// 类
class Myclass {
  // 成员属性，定义并赋值  访问权限的私有
  __age = 20

  // 构造方法
  constructor(id, name = '李四') {
    // 成员属性，属性值通过构造方法得到
    this.id = 100
    this.name = '张三'
  }

  /* getAge() {
    return this.__age + '岁'
  }

  setAge(num) {
    this.__age = Math.max(1, Math.min(200, num))
  } */

  get age() {
    return this.__age + '岁'
  }
  set age(num) {
    this.__age = Math.max(1, Math.min(200, num))
  }


  // 方法
  fn() {
    console.log('fn -=- 我是类中的一个方法');
    console.log(this);
  }
}

// 匿名类
const Myclass = class {
  hello(){
    console.log('hello');
  }
}

const my = new Myclass
my.hello()
ES5中的类
// 它就是一个类 (如果函数成为了类，则此函数叫构造函数)  ==  函数
function Myclass(a, b) {
  // 私有变量 函数的定义方式
  // var c = 2000
  // 如果把此函数当前构造函数
  // this.c = 3000
  console.log(this, a, b)
  // return 1
  return {
    id: 1
  }
}

// console.log(Myclass(1, 2))
console.log(new Myclass(10, 20))

原型与原型链

在这里插入图片描述

function Fn() { };
Fn.prototype.a = function () { };

const o = new Fn;
// 方法返回指定对象的原型 ( 即：内部[prototype]属性）
console.log(Fn.prototype)
console.log(o.__proto__)
console.log(Object.getPrototypeOf(o))
//====================================
let arr = [];
console.log(arr.__proto__ == Array.prototype); // true
let str = "";
console.log(str.__proto__ == String.prototype); // true

私有方法和原型方法同时存

function Fn() {
  this.x = 10
  this.y = 20
  this.getX = function () {
    console.log(this.x)
  }
}

Fn.prototype.getX = function () {
  console.log('prototype == ' + this.x)
}
Fn.prototype.getY = function () {
  console.log(this.y)
}

let f1 = new Fn()
f1.getX() // 10

获取与设置原型

// 设置一个指定的对象的原型
Object.setPrototypeOf(对象，父对象)
// 指定对象的原型
Object.getPrototypeOf(对象)
//==========================================
let child = {};
let parent = { id: 100 };
// child.__proto__ = parent;
// 设置child.__proto__的原型指向到parent
Object.setPrototypeOf(child, parent);
console.log(child);
// console.log(child.__proto__)
// 获取child对象的原型
console.log(Object.getPrototypeOf(child));

原型重定向

function Fn() { }
Fn.prototype = {
  // 手动设置的constructor
  constructor: Fn,
  getX() { },
  getY() { }
}

优点：
	把原型上为其，实例提供的公共属性和方法，全部写在一起了，提高整体性后者模块性
缺点
	重定向后的原型对象中，缺失了constructor属性，需要通过手动添加constructor

// ======================== 如果原类中就定义了prototype方法，上面写法会存在方法丢失
function Fn() { }
Fn.prototype = Object.assign(Fn.prototype, {
  getX() { },
  getY() { }
})

console.log(Fn.prototype)

原型重定向会引发constructor丢失

设置对象属性不可枚举

// 给对象添加一个属性，并且给属性添加一些描述, 不可枚举
Object.defineProperty(Fn.prototype, 'constructor', {
  // 指定值
  value: Fn,
  // 不可枚举
  enumerable: false
})

原型检测

instanceof 检测构造函数的 prototype 属性是否出现在某个实例对象的原型链上

function A() {}
function B() {}
function C() {}

const c = new C();
B.prototype = c;
const b = new B();
A.prototype = b;
const a = new A();

console.dir(a instanceof A); //true
console.dir(a instanceof B); //true
console.dir(a instanceof C); //true
console.dir(b instanceof C); //true
console.dir(c instanceof A); //false

// 使用isPrototypeOf检测一个对象是否是另一个对象的原型链中

const a = {};
const b = {};
const c = {};

Object.setPrototypeOf(a, b);
Object.setPrototypeOf(b, c);

console.log(b.isPrototypeOf(a)); //true
console.log(c.isPrototypeOf(a)); //true
console.log(c.isPrototypeOf(b)); //true

原型扩展方法

在这里插入图片描述

Array.prototype.unique = function () {
  let arr = [];
  for (let i = 0; i < this.length; i++) {
    if (this.indexOf(this[i]) == i) {
      arr.push(this[i])
    }
  }
  return arr
};

Array.prototype.sum = function () {
  let total = 0;
  for (let i = 0; i < this.length; i++) {
    total += this[i]
  }
  return total;
};

Array.prototype.max = function () {
  return Math.max.call(null, ...this)
};

// 给字符串添加几个原型方法
// query  id=1&name=lisi
// trim   去空格
// parse  {id:1,name=’lisi’} id=1&name=lisi

继承

JS本身是基于面向对象开发的编程语言

封装：类也是一个函数,把实现一个功能的代码进行封装，以此实现“低耦合高内聚”
多态: 
      重写： 子类重写父类上的方法（伴随着继承运行的）
      重载： 相同的方法，由于参数或者返回值不同，具备了不同的功能（js中不具备严格意义上的重载）
继承： 子类继承父类中的方法和属性

JS中继承方案：

1.原型继承 (让子类的原型 = 父类实例)

2.call继承 （只能继承父类中私有的，不能继承父类中公共的）

3.寄生组合式继承 (call继承 + 原型继承)

（4.混合继承，实现多继承）

1.原型继承
// 第1种： 原型继承 (让子类的原型 = 父类实例)
function Parent() {
  this.x = 100
}
Parent.prototype.getX = function () {
  return 'getX方法中输出：' + this.x
}

function Child() {
  this.y = 200
}
// 原型继承
Child.prototype.__proto__ = new Parent;

Child.prototype.getY = function () {
  return 'getY方法中的方法输出：' + this.y
}

// 父类中的私有属性都变成了子类公有的
let c1 = new Child
console.log(c1)
2.call继承
function Parent() {
  this.x = 100
}
Parent.prototype.getX = function () {
  return 'getX方法中输出：' + this.x
}

function Child() {
  // call继承
  // 在子类构造函数中，把父类当做普通方法执行(没有父类实例，父类原型上的哪些东西也就和它没有关系了)
  Parent.call(this)
  this.y = 200
}
Child.prototype.getY = function () {
  return 'getY方法中的方法输出：' + this.y
}

let c1 = new Child
console.log(c1)
3.寄生组合式继承
function Parent() {
  this.x = 100
}
Parent.prototype.getX = function () {
  return 'getX方法中输出：' + this.x
}

function Child() {
  // call继承
  Parent.call(this)
  this.y = 200
}

// Child.prototype.__proto__ = Parent.prototype
// Object.create 创建一个空对象，让其原型链指向obj
Child.prototype = Object.create(Parent.prototype)
// 指定一下constructor
Child.prototype.constructor = Child

Child.prototype.getY = function () {
  return 'getY方法中的方法输出：' + this.y
}

let c1 = new Child
console.log(c1)
4.混合继承

JS不能实现多继承，如果要使用多个类的方法时可以使用mixin混合模式来完成。

function A(name) {
  this.name = name;
}
A.prototype.show = function () {
  console.log(this.name);
};

const B = {
  total() {
    console.log("统计下输出");
  }
};
const C = {
  ajax() {
    console.log("发送请求");
  }
};

function User(name) {
  A.call(this, name);
}
User.prototype = Object.create(A.prototype)
User.prototype.constructor = User

Object.assign(User.prototype, B, C);
let u = new User("张三");
u.show();
u.total();
u.ajax();

重写new

function Fn() {
  // 创建一个实例对象
  // this指向实例对象
  // 也会像普通函数执行一样，让其执行，只不过this指向实例对象
  // 返回值没有或基本值，则返回实例对象，如果引用值，以自己的为主
}
let f1 = new Fn()

// ===============================================================
function _new(Construct, ...args) {
  // 创建一个实例对象（创建Construct类的实例，让其 对象.__proto__ = Construct.prototype）
  // obj.__proto__ = Construct.prototype
  let obj = Object.create(Construct.prototype)
  // 把函数执行，让this指向实例对象
  let ret = Construct.call(obj, ...args)
  //  处理返回值，引用类型,直接返回引用类型的值
  if (ret !== null && /^(object|function)$/.test(typeof ret)) {
    return ret
  }
  return obj
}

function Fn(name) {
  this.name = name
  this.age = function () {
    console.log('方法===' + this.name)
  }
}
let f1 = _new(Fn, '张三')
f1.age()s

重写call和bind

重写call：

Function.prototype.myCall = function (ctx, ...params) {
  // 参数可以为 undefined或null
  ctx = ctx == null ? window : ctx
  // 需要保证ctx必须是对象类型的值:因为只有对象才能设置属性
  ctx = !/^(object|function)$/.test(typeof ctx) ? Object(ctx) : ctx

  let self = this
  let ret = null
  // 新增的属性名保证唯一性，防止污染原始对象中的成员数据
  let functionName = Symbol('functionName')
  // 给对象添加属性
  ctx[functionName] = self
  // 执行方法
  ret = ctx[functionName](...params)
  // 删除自定义属性
  delete ctx[functionName]
  return ret
};

function fn(x, y) {
  console.log(this, x, y)
}
let obj = {
  name: '张三'
}
fn.myCall(obj, 2, 3)

重写bind：

Function.prototype.myBind = function myBind(ctx, ...params) {
  let self = this
  return function (...args) {
    self.apply(ctx, [...params, ...args])
  }
};

var obj = { id: 1 }
function fn(...args) {
  console.log(this, args)
}
btn.onclick = fn.bind(obj, 1, 2)

重写instanceof

注：不能检测基本数据类型,检测的实例必须是对象

在这里插入图片描述

function _instanceof(obj, FC) {

  if (typeof FC !== "function") {
    // 抛异常
    throw new Error('类型不能，无法使用')
  }
  if (obj == null) return false

  // 检查是否有Symbol.hasInstance属性
  if (typeof Symbol !== "undefined") {
    let hasIns = FC[Symbol.hasInstance]
    if (typeof hasIns === 'function') {
      // 执行返回true/false
      return hasIns.call(FC, obj)
    }
  }

  // 不支持Symbol
  // 获取类的原型
  let prototype = FC.prototype
  // 获取实例的原型链
  let proto = Object.getPrototypeOf(obj)
  // 如果类没有prototype则直接返回false
  if (!prototype) return false

  while (1) {
    // 找到原型链最顶，还没有找到返回false
    if (proto === null) return false

    // 在原型上找到返回true
    if (proto === prototype) return true

    proto = Object.getPrototypeOf(proto)
  }
}

let res = _instanceof(1, Array)
console.log(res)
pika521197
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Time of Day 3.2.0
07-06
Time of day 3.2.0.unitypackage Time of day 3.2.0.unitypackage
0day漏洞检测
04-13
利用FUZZING技术检测漏洞，检测Activex插件的漏洞学习。
C++ 0425 笔记
宁静以致墨的专栏
04-25 93
类接口 参数类型 注意代码中使用了枚举量mar的限定名Month::mar。我们没有用Month::mar,因为Month不是一个 对象（而是一个类型），而mar也不是一个数据成员（而是一个枚举量-----一个符号常量）。 我们在类名、枚举名或名字空间名后使用::，而在对象后使用.（点）。 拷贝 默认构造函数 未初始化的变量可能会成为错误之源。为了解决这个问题，我们可以用构造函数来保证 ...
Java day 04丶25
weixin_30824479的博客
04-25 62
Java第三天 练习6：编程计算$$$\sum_{n=1}^{100}n$$$。 package day 0425; /** * 用while循环实现1-100求和 * @author A * */ public class Test03 { public static void main(String[] args) { int sum = 0; // ...
0425写作01
Lich Howger
04-25 161
  sociablehe is always shy ,but he is trying to be outgoing and sociable.  consideratehe is very considerate,he always pays attention to everyone's emotion.  a good sense of humorthis host have a good...
0425写作02
Lich Howger
04-26 196
 In order to demonstrate viciousness of crimes or attract more audiences and readers, some public media such as television and newspaper will describe crimes in detail.Some people claim that the amoun...
MyBatis框架——day01
weixin_49444963的博客
07-21 116
MyBatis框架——day01 三层架构 界面层【controller包（servlet）】：与用户交互，接受用户的参数，显示处理的结果（jsp、html、servlet） 业务逻辑层【service包（XXXService类）】：接受界面层传递的数据，计算逻辑，调用数据库，获取数据 数据访问层【dao包（XXXDao类）】：访问数据库，实现增删改查 三层中类的交互 用户使用界面层————>业务逻辑层————>数据访问层————>数据库 三层对应的框架 界面层————>
Mysql学习笔记 Day11 0424-Day12 0425
catseeking的博客
04-25 90
测试事务实现（转账）、索引（索引的分类、测试索引、 索引原则）
day4 随机抽样 入门 一起学 PyTorch吧，PyTorch从入门开始 每天都更新 超详细 参数 常用方法 简单案列 共同学习，共同进步 坚持
Cchaofan的博客
12-29 779
day4 随机抽样 入门 一起学 PyTorch吧，PyTorch从入门开始 每天都更新 超详细 参数 常用方法 简单案列 共同学习，共同进步 坚持
基础编程每日练习题汇总
战场战魁
03-08 1034
Java基础练习题
0Day – 2011.1.6[From B4A]
weixin_33709364的博客
01-22 258
0-Day Accent.OFFICE.Password.Recovery.v5.10.48.841.Ultimate.Edition.MULTILINGUAL-CRD 1F 3.5MB Accent.ZIP.Password.Recovery.v2.0.48.1027.Ultimate.Edition.MULTILINGUAL-CRD 1F 3.11MB Brainworx.B...
dayofyear.rar_dayofyear
09-24
输入一个日期，弹出这是一年中的第几天，不管是平年还是闰年都可以
Javaday02训练
02-08
Javaday02训练
代码随想录刷题打卡day02
04-18
代码随想录刷题打卡day02
基于业务逻辑生成特征变量python实现源码+数据集+超详细注释.zip
05-31
【优质项目推荐】 1、项目代码均经过严格本地测试，运行OK，确保功能稳定后才上传平台。可放心下载并立即投入使用，若遇到任何使用问题，随时欢迎私信反馈与沟通，博主会第一时间回复。 2、项目适用于计算机相关专业（如计科、信息安全、数据科学、人工智能、通信、物联网、自动化、电子信息等）的在校学生、专业教师，或企业员工，小白入门等都适用。 3、该项目不仅具有很高的学习借鉴价值，对于初学者来说，也是入门进阶的绝佳选择；当然也可以直接用于 毕设、课设、期末大作业或项目初期立项演示等。 3、开放创新：如果您有一定基础，且热爱探索钻研，可以在此代码基础上二次开发，进行修改、扩展，创造出属于自己的独特应用。 欢迎下载使用优质资源！欢迎借鉴使用，并欢迎学习交流，共同探索编程的无穷魅力！ 基于业务逻辑生成特征变量python实现源码+数据集+超详细注释.zip基于业务逻辑生成特征变量python实现源码+数据集+超详细注释.zip基于业务逻辑生成特征变量python实现源码+数据集+超详细注释.zip基于业务逻辑生成特征变量python实现源码+数据集+超详细注释.zip基于业务逻辑生成特征变量python实现源码+数据集+超详细注释.zip基于业务逻辑生成特征变量python实现源码+数据集+超详细注释.zip基于业务逻辑生成特征变量python实现源码+数据集+超详细注释.zip 基于业务逻辑生成特征变量python实现源码+数据集+超详细注释.zip 基于业务逻辑生成特征变量python实现源码+数据集+超详细注释.zip
六一儿童节快乐！（六一儿童节庆祝代码）Vue开发
最新发布
05-31
六一儿童节快乐！（六一儿童节庆祝代码）Vue开发 like Project setup npm install Compiles and hot-reloads for development npm run serve Compiles and minifies for production npm run build Lints and fixes files npm run lint Customize configuration
uniapp聊天工具源码.zip
05-31
提供的源码资源涵盖了安卓应用、小程序、Python应用和Java应用等多个领域，每个领域都包含了丰富的实例和项目。这些源码都是基于各自平台的最新技术和标准编写，确保了在对应环境下能够无缝运行。同时，源码中配备了详细的注释和文档，帮助用户快速理解代码结构和实现逻辑。 适用人群： 这些源码资源特别适合大学生群体。无论你是计算机相关专业的学生，还是对其他领域编程感兴趣的学生，这些资源都能为你提供宝贵的学习和实践机会。通过学习和运行这些源码，你可以掌握各平台开发的基础知识，提升编程能力和项目实战经验。 使用场景及目标： 在学习阶段，你可以利用这些源码资源进行课程实践、课外项目或毕业设计。通过分析和运行源码，你将深入了解各平台开发的技术细节和最佳实践，逐步培养起自己的项目开发和问题解决能力。此外，在求职或创业过程中，具备跨平台开发能力的大学生将更具竞争力。 其他说明： 为了确保源码资源的可运行性和易用性，特别注意了以下几点：首先，每份源码都提供了详细的运行环境和依赖说明，确保用户能够轻松搭建起开发环境；其次，源码中的注释和文档都非常完善，方便用户快速上手和理解代码；最后，我会定期更新这些源码资源，以适应各平台技术的最新发展和市场需求。
NX二次开发uc1603 函数介绍
05-31
NX二次开发uc1603 函数介绍，Ufun提供了一系列丰富的 API 函数，可以帮助用户实现自动化、定制化和扩展 NX 软件的功能。无论您是从事机械设计、制造、模具设计、逆向工程、CAE 分析等领域的专业人士，还是希望提高工作效率的普通用户，NX 二次开发 Ufun 都可以帮助您实现更高效的工作流程。函数覆盖了 NX 软件的各个方面，包括但不限于建模、装配、制图、编程、仿真等。这些 API 函数可以帮助用户轻松地实现自动化、定制化和扩展 NX 软件的功能。例如，用户可以通过 Ufun 编写脚本，自动化完成重复性的设计任务，提高设计效率；或者开发定制化的功能，满足特定的业务需求。语法简单易懂，易于学习和使用。用户可以快速上手并开发出符合自己需求的 NX 功能。本资源内容 提供了丰富的中英文帮助文档，可以帮助用户快速了解和使用 Ufun 的功能。用户可以通过资源中的提示，学习如何使用 Ufun 的 API 函数，以及如何实现特定的功能。
day.replace
02-28
day.replace() 是 Python 中的一个字符串方法，用于替换字符串中的子串。它接受两个参数，第一个参数是要被替换的子串，第二个参数是替换后的新子串。 例如，我们有一个字符串 "Today is a sunny day."，我们想把...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值