【鸿蒙实战开发】JS原型和原型链

最新推荐文章于 2024-07-28 20:27:10 发布

「已注销」

最新推荐文章于 2024-07-28 20:27:10 发布

阅读量658

点赞数 20

分类专栏：鸿蒙安卓前端文章标签： javascript harmonyos android 华为鸿蒙安卓前端

本文链接：https://blog.csdn.net/HarmonyOS_002/article/details/140333008

版权

鸿蒙同时被 3 个专栏收录

46 篇文章 0 订阅

订阅专栏

安卓

45 篇文章 0 订阅

订阅专栏

前端

38 篇文章 0 订阅

订阅专栏

前言

在开发鸿蒙的时候，我们经常需要断点查看变量的值，当看到__proto__ 这个东西的时候是不是有点陌生。本次我们分享的就和它有关
在这里插入图片描述

基本概念

JS对象

1.JS对象是动态的属性（指其自有属性）包，可以自由添加、更改、删除上面的属性
2.JS对象分为函数对象和普通对象，每个对象都有__proto__属性，只有函数对象才有prototype属性
3.Object、Function 都是JS内置的函数，类似的还有Array、RegExp、Date、Boolean、Number、String等
4.proto__属性的值是一个对象，这个对象叫原型对象，它有两个属性，constructor和__proto。constructor 用于记录实例是由哪个构造函数创建

// 字面量 对象
const o1 = {}; 
// 通过new Object创建对象
const o2 = new Object();
// 通过new一个函数 创建对象
const o3 = new f1();

// 常规函数声明
function f1(){}; 
// 类型为函数的变量
const f2 = function(){};
// 通过new Function创建一个函数，并赋值给变量f3
const f3 = new Function('str','console.log(str)');

console.log(typeof Object); //function 
console.log(typeof Function); //function  

console.log(typeof f1); //function 
console.log(typeof f2); //function 
console.log(typeof f3); //function   

console.log(typeof o1); //object 
console.log(typeof o2); //object 
console.log(typeof o3); //object

o1 o2 o3 为普通对象，f1 f2 f3 为函数对象

1.凡是通过 new Function() 创建的对象都是函数对象，其他的都是普通对象
2.f1，f2归根结底都是通过 new Function()的方式创建的
3.Function、Object 也都是通过 new Function()创建的

引用类型的四个规则

1.具有对象特性，可自由扩展属性，对属性进行增删改查

const obj = {}
const arr = []
const fn = function() {}

// 可以自由添加属性
obj.a = 1
arr.a = 1
fn.a = 1

console.log(obj.a) // 1
console.log(arr.a) // 1
console.log(fn.a) // 1

2.有一个隐式原型 proto 属性，属性值是一个普通的对象

const obj = {};
const arr = [];
const fn = function() {}

console.log('obj.__proto__', obj.__proto__);
console.log('arr.__proto__', arr.__proto__);
console.log('fn.__proto__', fn.__proto__);

3.隐式原型 proto 的属性值指向它的构造函数的显式原型 prototype

const obj = {};
const arr = [];
const fn = function() {}

obj.__proto__ == Object.prototype // true
arr.__proto__ === Array.prototype // true
fn.__proto__ == Function.prototype // true

4.当你试图访问一个对象的某个属性时，如果这个对象本身没有这个属性，那么它会去它的隐式原型 proto（也就是它的构造函数的显式原型 prototype）中寻找

const obj = { a:1 }obj.toString
// ƒ toString() { [native code] }
// obj 对象并没有 toString 属性，之所以能获取到 toString 属性，是遵循了第四条规则，从它的构造函数 Object 的 prototype 里去获取

Object

1.在JavaScript中，Object构造函数创建一个对象包装器。Object是通过Function创建出来的，它是一种特殊的Function
2.如果给定值是null或undefined，将会创建并返回一个空对象，否则，将返回一个与给定值对应类型的对象
3.当以非构造函数（没有使用new）的方式被调用时，Object函数将转换为对象。它可以将任何值转换为对象。这种方式通常被用于将基本数据类型（如数字、字符串和布尔值）转换为相应的对象
4.只要是一个普通对象object，就可以用 new Object() 来实例化（Object() 是一个内置的构造函数），也就是说，所有的对象字面量都是 Object() 的实例
5.Object 作为构造函数，Object.prototype 指向一个具体的原型对象，该原型对象作为对象的实例，它的 proto 值为 null，因而 Object.prototype.proto = null 时也就走到了原型的尽头

Function

1.JS 内置了 Function() 构造函数，Function是所有函数的构造函数，因而所有函数都算作是 Function 的实例对象
2.JS中的所有引用类型都是通过Function创建出来的
3.无论是Object还是自定义的函数，甚至Function本身都是通过Function函数创建出来的
4.Function是JS中的创造神

function fun() {} 
function Fun() {}

我们使用function关键字来定义函数，但是有的时候函数名看起来更像类名。一般函数名第一个字母大写的时候，我们是想把这个函数当成构造函数使用

constructor 构造函数

构造函数是用于创建和初始化一个对象的特殊方法，通常我们会使用new关键字来调用构造函数，创建新的对象实例
JS中没有类的概念，于是设计了构造函数来实现继承机制

// 构造函数
function Person(name, age) {
    this.name = name;
    this.age = age;
}

// 生成实例
const p = new Person('zhangsan', 18);

上面代码通过 new Person 生成了实例p，在Person这个构造函数内赋值给this的name和age属性是每个实例独有的，无法共享公共属性和公共方法。于是又设计了原型对象来实现共享属性和方法的功能

实例化

对构造函数使用 new 关键字可以创建出不同的实例（实例的本质就是一个对象）

prototype 原型

JS的每个函数都有一个 prototype 属性指向一个对象，这个对象就叫原型对象，也叫显示原型。原型对象有个属性为constructor指向该构造函数

每个对象中有一个属性叫__proto__，它叫隐式原型

构造函数的prototype指向原型对象，原型对象的constructor指向构造函数
在这里插入图片描述

function Person() {};
var p = new Person();

构造函数的prototype属性的值(Person.prototype)，也可以说成通过调用构造函数创建出来的那个实例对象的原型对象(p.proto)

1.只要是函数就有 prototype 属性，即函数的原型属性（由于对象是由函数创建的，因此对象也有prototype属性）
2.函数的原型对象也是对象（因此，这个对象也有对应的prototype属性）
3.由构造函数创建出来的对象会默认链接到其构造函数的这个属性上（constructor）
4.构造函数的 prototype 属性的作用是：实现数据共享（继承）

原型链

// 构造函数
function Preson(name, age) {
  this.name = name;
  this.age = age;
}
// 所有实例共享的公共方法
Preson.prototype.say = function (word) {
  console.log(`${this.name}说：${word}`);
}

const p1 = new Preson('张三', 18); // 创建一个Person实例对象
p1.hasOwnProperty('say') // false 说明不是定义在其本身上的
p1.say('hello world'); // 调用公共方法 打印：张三说：hello world

p1上是没有say属性的，但是我们却可以调用say这个方法，而say这个方法是存在于Person的原型对象上面。之所以能够调用到say方法，就涉及到__proto__属性了

proto

1.JS中的每个对象（object）都有一个私有属性__proto__指向原型（prototype）对象
2.原型对象也是对象，也有__proto__指向自己的原型，这样层层向上直到一个对象的原型为 null
3.null 没有原型，它是原型链（prototype chain）查找的终点
4.当试图访问一个对象的属性时，它不仅仅在该对象上搜寻，还会搜寻该对象的原型以及原型的原型，依次层层向上搜索，直到找到一个名字匹配的属性或到达原型链的末尾返回undefined
在这里插入图片描述

1.当我们访问p1的say属性时，会先在p1本身的属性里查找，没有找到
2.然后通过p1的__proto__隐式属性，找到它的构造函数的原型对象Person.prototype。然后在这个原型对象的属性里查找say属性
3.如果还没有找到就会在其构造函数的prototype的__proto__中查找，这样一层一层向上查找就会形成一个链式结构，我们称为原型链

可以通过proto修改对象的原型

1.如果通过p1实例对象的__proto__属性赋值，则会改变其构造函数的原型对象，从而被所有实例所共享
2.我们在开发的时候，要注意不要通过实例对象去改变其构造函数的原型对象，这样会对其他通过该构造函数生成的实例对象造成影响

// 构造函数
function Preson(name, age) {
	this.name = name;
	this.age = age;
}
// 所有实例共享的公共方法
Preson.prototype.say = function (word) {
	console.log(`${this.name}说：${word}`);
}

const p1 = new Preson('张三', 18); // 创建一个Person实例对象
const p2 = new Preson('李四', 20); // 新创建一个Proson实例对象
p1.say('hello world'); // 调用公共方法
p1.hasOwnProperty('say') // false 说明不是定义在其本身上的

p1.__proto__.do = function () {
	console.log('往原型对象中添加方法');
}
p2.do(); // 打印出了-往原型对象中添加方法

图解原型链

“铁三角关系”（重点）实例对象的隐式原型 === 构造函数的显式原型

function Person() {};
var p = new Person();

在这里插入图片描述

这个图描述了构造函数，实例对象和原型三者之间的关系，是原型链的基础：
（1）实例对象由构造函数new产生；
（2）构造函数的原型属性与实例对象的原型对象均指向原型
（3）原型对象中有一个属性constructor指向对应的构造函数

原型链：p --> Person.prototype

描述：实例对象能够访问到 Person.prototype 中不同名的属性和方法

验证：

p instanceof Person; // true
p.__proto__ === Person.prototype; // true
Person.prototype.constructor === Person; // true

原型也是构造函数

在这里插入图片描述

原型链：p --> Person.prototype --> Object.prototype --> null
描述：
（1）构造函数的原型也是对象，因此：它也有原型对象，指向Object.prototype
（2）构造函数的原型的原型也是对象，因此：它也有原型对象，指向null（特例）
验证：

p instanceof Person; // true
p instanceof Object; // true
Person.prototype instanceof Object; // true

Function构造函数

在这里插入图片描述

原型链1：p --> Person.prototype --> Object.prototype --> null

原型链2：Person --> Function.prototype --> Object.prototype --> null

描述：
（1）构造函数Person作为实例对象时，Person = new Function()隐式调用，因此Person --> Function.prototype
（2）Function.prototype也是对象，Function.prototype = new Object()隐式调用，因此Function.prototype --> Object.prototype

验证：

Person instanceof Function; // true
Person instanceof Object; // true
Function.prototype instanceof Object; // true

原型链3：Function --> Function.prototype --> Object.prototype --> null
描述：
构造函数Function作为实例对象时，Function = new Function()隐式调用，因此Function --> Function.prototype
在这里插入图片描述

Function 这条原型链是最为特殊的“铁三角关系”，理解Function = new Function()就非常好理解了
验证：

Function.__proto__ === Function.prototype; // true
Function instanceof Function; // true
Function instanceof Object; // true

完整的原型链

在这里插入图片描述

原型链1：p --> Person.prototype --> Object.prototype --> null
原型链2：Person --> Function.prototype --> Object.prototype --> null
原型链3：Function --> Function.prototype --> Object.prototype --> null
原型链4：Object --> Function.prototype --> Object.prototype --> null
图中新增了Object = new Function()的逻辑
验证：

Object instanceof Function;// true

几个结论：
（1）对象都有原型对象，对象默认继承自其原型对象
（2）所有的函数都是 Function 的实例
（3）所有的原型链尾端都会指向Object.prototype

原型链改写（重点）

当实例对象被创建时，其原型链就已经确定了，当其对应的原型对象的属性指向改变时，也无法改变原型链

function Person({name="小A", age=21}={}) {
  this.name = name;
  this.age = age;
};

// 情况1：在修改原型属性前实例化对象
var p1 = new Person();

// 添加原型属性(方法)
Person.prototype.sayName = function() {
  console.log(this.name);
}

// 情况2：在修改原型属性后实例化对象
var p2 = new Person();

p1.sayName(); // "小A"
p2.sayName(); // "小A"

实例对象p1和实例对象p2的原型链相同，为 p1(p2) --> Person.prototype --> Object.prototype
由于是在原有原型对象上添加的方法，相当于对象的扩展，故两个实例对象均能执行该方法
在这里插入图片描述

function Person({name="小A", age=21}={}) {
  this.name = name;
  this.age = age;
};

// 情况1：在修改原型属性前实例化对象
var p1 = new Person();

// 重写原型对象
Person.prototype = {
  sayName: function() {
    console.log(this.name);
  }
}

// 情况2：在修改原型属性后实例化对象
var p2 = new Person();

p2.sayName(); // "小A"
p1.sayName(); // p1.sayName is not a function

重写原型对象的方式，会改变实例对象的原型链，如下图所示：
在这里插入图片描述

但是，为什么p1的原型链没有变，而p2的原型链变了呢？
当实例对象被创建时，其原型链就已经确定了，当其对应的原型属性指向改变时，也无法改变原型链
原型链是以实例对象为核心的，不能被原型对象的改变而误导

对象与函数（重点）

官方定义: 在Javascript中,每一个函数实际上都是一个函数对象

function fn() {};
var obj = {};

fn instanceof Object; // true
fn instanceof Function; // true

obj instanceof Object; // true
obj instanceof Function; // false

原型链解释：
fn对应的原型链：fn --> Function.prototype --> Object.prototype
obj对应的原型链：obj --> Object.prototype

从函数的定义来说: 在javascript中一切函数实际都是函数对象，但对象不一定是函数

Function instanceof Object; // true
Object instanceof Function; // true

Function instanceof Function; // true

原型链解释：

Function对应的原型链（Function作为实例对象）：Function --> Function.prototype --> Object.prototype

Object对应的原型链（Object作为实例对象）：Object --> Function.prototype --> Object.prototype
由于Function和Object都是构造函数，在内置对象中，均会调用new Function()的方法

结论：
（1）函数一定是对象，但是对象不一定是函数
（2）对象都是由函数来创建的
针对第一点，这两个原型链可验证：
fn --> Function.prototype --> Object.prototype
obj --> Object.prototype
针对第二点，可这样验证：

var obj = { a: 1, b: 2}
var arr = [2, 'foo', false]

// 实际过程
var obj = new Object()
obj.a = 1
obj.b = 2

var arr = new Array()
arr[0] = 2
arr[1] = 'foo'
arr[2] = false

//typeof Object === 'function'  
//typeof Array === 'function

原型链的应用：属性搜索原则和属性来源判断

属性搜索原则

1.当代码读取某个对象的某个属性时，都会执行一次搜索，目标是具有给定名字的属性。
2.搜索先从对象实例本身开始，如果在实例中找到了具有给定名字的属性，则返回该属性的值；
3.如果没有找到，则继续搜索指针指向的原型对象，在原型对象中查找具有给定名字的属性。如果在原型对象中找到了这个属性，则返回这个属性，
4.如果没有找到，则继续在这个原型对象的原型对象中查找，直到找到这个属性，否则返回undefined

简言之，沿着对象的原型链查找属性，返回最近的属性，这就是属性搜索原则

function Person(){}

Person.prototype.name = "Nicholas";
Person.prototype.age = 29;
Person.prototype.job = "Software Engineer";
Person.prototype.sayName = function(){
  alert(this.name);
};

var person1 = new Person();
var person2 = new Person();

person1.name = "Greg";
alert(person1.name); //"Greg" 来自实例
alert(person2.name); //"Nicholas" 来自原型

同样的，这也是属性屏蔽的原则
在这里插入图片描述

// 接着上面的例子
delete person1.namel;
alert(person1.name); // "Nicholas" 来自原型

hasOwnProperty()方法与in操作符

hasOwnProperty

使用hasOwnProperty()方法可以检测一个属性是存在于实例中，还是在原型中，这个方法只在给定属性存在于对象实例中时，才会返回true

function Person(){}

Person.prototype.name = "Nicholas";
Person.prototype.age = 29;
Person.prototype.job = "Software Engineer";
Person.prototype.sayName = function(){
  alert(this.name);
};

var person1 = new Person();
var person2 = new Person();

alert(person1.hasOwnProperty("name"));  //false

person1.name = "Greg";
alert(person1.name); //"Greg" 来自实例 
alert(person1.hasOwnProperty("name")); //true

alert(person2.name); //"Nicholas" 来自原型
alert(person2.hasOwnProperty("name")); //false

delete person1.name;
alert(person1.name); //"Nicholas" 来自原型
alert(person1.hasOwnProperty("name")); //false

in

有两种方式使用in操作符：单独使用和在for-in循环中使用。在单独使用时，in操作符会在通过对象能够访问给定属性时返回true，无论该属性存在于实例中还是原型中
因此，同时使用hasOwnProperty()和in操作符，就可以确定某个属性到底是存在于对象中还是存在于原型中

function hasPrototypeProperty(object, name){
  return !object.hasOwnProperty(name) && (name in object);
}

顺便一提，由于in操作符会在整个原型链上查找属性，处于性能考虑，在使用for-in循环时，建议多加一层判别

function Person(){}

Person.prototype.name = "Nicholas";
Person.prototype.age = 29;

var p = new Person();
p.sex = "fale";

for(key in p) {
  console.log(key); // sex name age 
}

// 实际上，我们一般只是在查找实例中的属性
for(key in p) {
  if(p.hasOwnProperty(key)) {
    console.log(key); // sex 屏蔽了原型中的属性
  }
}

JS对象布局图

代码

function Foo() {}
const f1 = new Foo();
const o1 = new Object();
// 可以把Foo.prototype理解成是Foo的类，而Foo只是一个构造函数
// 把__proto__理解成OC中的isa指针

// f1实例的__proto__指向它的构造函数的原型对象。f1 = new Foo()
console.log("f1.__proto__===Foo.prototype", f1.__proto__===Foo.prototype);
// Foo构造函数的原型对象的constructor指向Foo函数
console.log("Foo.prototype.constructor===Foo", Foo.prototype.constructor===Foo);
// Foo.prototype的__proto__是Object.prototype
console.log("Foo.prototype.__proto__===Object.prototype", Foo.prototype.constructor===Foo);

// 每一个JS函数都可以理解成是Function的一个实例。即Foo = new Function(...)。所以Foo实例的__proto__指向Function.prototype
console.log("Foo.__proto__===Function.prototype", Foo.__proto__===Function.prototype);
// Function原型对象的constructor指向Function函数
console.log("Function.prototype.constructor===Function", Function.prototype.constructor===Function);
// Function本身也是通过Function创建的一个实例。即Function = new Function(...)，所以Function.__proto__指向Function.prototype
console.log("Function.__proto__===Function.prototype", Function.__proto__===Function.prototype);

// Function原型对象的__proto__指向Object.prototype
console.log("Function.prototype.__proto__===Object.prototype", Function.prototype.__proto__===Object.prototype);
// Object.prototype的constructor指向Object
console.log("Object.prototype.constructor===Object", Object.prototype.constructor===Object);
// Object也是一个实例，它的__proto__指向Function.prototype。即Object = new Function(...)
console.log("Object.__proto__===Function.prototype", Object.__proto__===Function.prototype);
// Object.prototype.__proto__指向null
console.log("Object.prototype.__proto__===null", Object.prototype.__proto__===null);

// o1实例的__proto__指向Object.prototype
console.log("o1.__proto__===Object.prototype", o1.__proto__===Object.prototype);

神图

在这里插入图片描述

细剖

在这里隐式原型指__proto__的指向，显示原型指 prototype的指向

实例对象 f1

在这里插入图片描述

1.f1是function Foo()的实例对象，function Foo()是构造它的函数。f1的隐式原型指向function Foo()的显式原型。实例对象的隐式原型等于构造函数的显式原型
2.function Foo()的显式原型指向Foo.prototype
3.所以实例对象f1的隐式原型也指向Foo.prototype

Foo.prototype

在这里插入图片描述

1.原型对象的constructor指向它的构造函数，所以Foo.prototype的constructor指向function Foo()
2.Foo.prototype也是一个实例对象，function Object()是构造它的函数，Foo.prototype的隐式原型指向function Object()的显式原型
3.function Object()的显示原型是Object.prototype
4.所以Foo.prototype的隐式原型也指向Object.prototype

构造函数 function Foo()

在这里插入图片描述

1.function Foo()的显示原型指向Foo.prototype
2.构造函数也是对象，是function Function()创建出来的实例对象，它的隐式原型会指向function Function()函数的显式原型
3.function Function()的显示原型是Function.prototype
4.所以function Foo()的隐式原型也指向Function.prototype。万物皆对象

构造函数 function Object()

在这里插入图片描述

1.function Object()是构造函数，它的显示原型指向Object.prototype
2.function Object()也是一个对象，function Function()是构造它的函数。function Object()的隐式原型指向function Function()的显示原型
3.function Function()的显示原型是Function.prototype
4.所以function Object()的隐式原型也指向Function.prototype

实例对象 o1

在这里插入图片描述

1.o1是通过function Object()的实例对象，function Object是构造它的函数。 o1的隐式原型指向function Object()的显式原型
2.function Object()的显式原型指向Object.prototype
3.所以o1的隐式原型也指向Object.prototype
4.function Object()和function Function()函数是系统已经封装好的函数

Object.prototype

在这里插入图片描述

1.Object.prototype没有构造函数，也就没有构造函数的显式原型
2.同样的，Object.prototype的隐式原型就是null

解释

1.代码中的f1和o1的生成代码 const f1 = new Foo(); const o1 = new Object();
2.函数Foo的显式原型为Foo.prototype，函数Foo的隐式原型是_proto_
3.f1实例的__proto__指向它的构造函数的原型对象。f1 = new Foo()
4.Foo.prototype的__proto__是Object.prototype
5.每一个JS函数都可以理解成是Function的一个实例。即Foo = new Function(…)。所以Foo实例的__proto__指向Function.prototype
6.Function本身也是通过Function创建的一个实例。即Function = new Function(…)，所以Function.__proto__指向Function.prototype
7.o1实例的__proto__指向Object.prototype
8.Object也是一个实例，它的__proto__指向Function.prototype。即Object = new Function(…)
9.实例对象的隐式原型 === 构造函数的显式原型

从上面的图我们也可以得出结论

1.JS中所有的函数是通过Function函数构造出来的
2.Function本身也是一个对象，也是通过Function函数构造出来的
3.也是一个对象，也是通过Function函数构造出来的

总结

1.函数实例的__proto__指向它的构造函数的原型对象，比如f1的__proto__指向Foo.prototype，o1的__proto__指向Object.prototype
2.所有构造函数的__proto__都指向Function.prototype，比如Foo、Function、Object的__proto__都指向Function.prototype
3.除Object.prototype外的原型对象的__proto__都指向Object.prototype，比如Foo.prototype、Function.prototype的__proto__都指向Object.prototype
4.Object.prototype的__prototype__指向null，这样就形成了一个闭环

iOS中的继承图

学过iOS的同学，应该对这张图比较了解
在这里插入图片描述

在iOS中存在实例对象、类对象、元类对象三个概念，其中

●instance对象（实例对象）的isa指向class对象
●class对象（类对象）的isa指向类的MetaClass对象
●MetaClass对象（元类对象）的isa指向NSObject MetaClass对象，NSObject MetaClass对象的isa指向自己
●NSObject MetaClass的superClass是基类NSObject，这样就形成了一个闭环

看起来是不是和JavaScript的上古神图很相似，可以对比理解。
App启动之后 iOS中的类和元类只有一份，JS中的Function.prototype和Object.prototype也是只有一份。
都可以简单的理解成是在环境准备的过程中由系统或引擎自动初始化并持有在内存中的

JS对象在解释器启动过程的布局

在这里插入图片描述

JS解释器启动时会创建JS上下文环境以及最顶层的Object和Function并让这些代码对JS代码可见。一个对象都可以有任意一个属性，这些属性以Map或者Dictionry的形式存在于对象上。当然这些对象也包括 Object和Function
之后解析网页上的所有脚本及其片段，创建对应的JS对象呈现网页中的元素
如果我们使用Java模拟器JS解释器，我们可以有一个叫做JSObject的类，并且提供一个Map存储所有的动态属性。然后通过子类化不同的JSObject去执行关联上的解释器代码

总结

1.在JS层的任意一个函数，比如myfoo这个函数 function myfoo() { }

都有一个原型属性（在它的字典中），指向一个共享对象。这个对象在通过 new 操作符创建的所有对象的变量搜索范围内，比如：var f1 = new foo()

原型/共享对象类似于在 Java 中的超类静态类变量（类型为 Map）。所有实例（f1、f2 等）自动访问相同的超类 Map。这个作用域在上面的图表中用黄色/橙色表示。

2.函数本身在 JavaScript 中也被表示为“对象”。这些函数对象是由 JavaScript 的“Function”创建者创建的，因此函数也有自己的共享静态超类 Map（对所有函数都通用）。这个作用域在上面的图表中用红色表示。

需要提醒的两点

1.红色和橙色链是分开的
2.无论是函数还是简单对象，两个作用域都在“Object”的原型处结束，因此在“Object.prototype”中设置的任何内容对系统中的所有内容都是可见的（除非在特定对象中被覆盖/遮蔽相同属性）

写在最后

有很多小伙伴不知道学习哪些鸿蒙开发技术？不知道需要重点掌握哪些鸿蒙应用开发知识点？而且学习时频繁踩坑，最终浪费大量时间。所以有一份实用的鸿蒙（HarmonyOS NEXT）资料用来跟着学习是非常有必要的。

这份鸿蒙（HarmonyOS NEXT）资料包含了鸿蒙开发必掌握的核心知识要点，内容包含了（ArkTS、ArkUI开发组件、Stage模型、多端部署、分布式应用开发、音频、视频、WebGL、OpenHarmony多媒体技术、Napi组件、OpenHarmony内核、Harmony南向开发、鸿蒙项目实战等等）鸿蒙（HarmonyOS NEXT）技术知识点。

希望这一份鸿蒙学习资料能够给大家带来帮助，有需要的小伙伴自行领取，限时开源，先到先得~无套路领取！！

获取这份完整版高清学习路线，请点击→纯血版全套鸿蒙HarmonyOS学习资料

鸿蒙（HarmonyOS NEXT）最新学习路线

在这里插入图片描述

有了路线图，怎么能没有学习资料呢，小编也准备了一份联合鸿蒙官方发布笔记整理收纳的一套系统性的鸿蒙（OpenHarmony ）学习手册（共计1236页）与鸿蒙（OpenHarmony ）开发入门教学视频，内容包含：ArkTS、ArkUI、Web开发、应用模型、资源分类…等知识点。

获取以上完整版高清学习路线，请点击→纯血版全套鸿蒙HarmonyOS学习资料

《鸿蒙 (OpenHarmony)开发入门教学视频》

在这里插入图片描述

《鸿蒙生态应用开发V3.0白皮书》

在这里插入图片描述

《鸿蒙 (OpenHarmony)开发基础到实战手册》

OpenHarmony北向、南向开发环境搭建

在这里插入图片描述

《鸿蒙开发基础》

●ArkTS语言
●安装DevEco Studio
●运用你的第一个ArkTS应用
●ArkUI声明式UI开发
.……
在这里插入图片描述

《鸿蒙开发进阶》

●Stage模型入门
●网络管理
●数据管理
●电话服务
●分布式应用开发
●通知与窗口管理
●多媒体技术
●安全技能
●任务管理
●WebGL
●国际化开发
●应用测试
●DFX面向未来设计
●鸿蒙系统移植和裁剪定制
……
在这里插入图片描述

《鸿蒙进阶实战》

●ArkTS实践
●UIAbility应用
●网络案例
……
在这里插入图片描述

获取以上完整鸿蒙HarmonyOS学习资料，请点击→纯血版全套鸿蒙HarmonyOS学习资料

「已注销」

关注

20
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
【鸿蒙实战开发】JS原型和原型链

1.函数实例的__proto__指向它的构造函数的原型对象，比如f1的__proto__指向Foo.prototype，o1的__proto__指向Object.prototype2.所有构造函数的__proto__都指向Function.prototype，比如Foo、Function、Object的__proto__都指向Function.prototype。
复制链接

扫一扫