云顶娱乐集团

当前位置:云顶娱乐集团 > 云顶娱乐集团 > 深入之new的效仿实现,Logo字体应用实施

深入之new的效仿实现,Logo字体应用实施

来源:http://www.clubskodakaroq.com 作者:云顶娱乐集团 时间:2019-10-04 15:32

JavaScript 深入之施行上下文

2017/05/18 · JavaScript · 奉行上下文

原来的书文出处: 冴羽   

Logo字体 VS 七喜图——图标字体采行

2017/04/05 · HTML5 · 1 评论 · Logo字体

原来的作品出处: 人人网FED博客   

本文介绍使用Logo字体和SVG替代7-Up图的格局。Sprite图是广大网址常常应用的一种才干,不过它有瑕玷:高清屏会模糊、不可能动态变化如hover时候反色。而接纳Logo字体能够健全化解上述难题,同临时候具有宽容性好,生成的文书小等优点。

JavaScript 深刻之new的效仿达成

2017/05/26 · JavaScript · new

原来的小讲出处: 冴羽   

JavaScript 深刻之类数组对象与 arguments

2017/05/27 · JavaScript · arguments

初稿出处: 冴羽   

十三个HTML5水墨画及美术设计工具

2011/03/26 · HTML5 · 来源: smashinghub     · HTML5

  1. Mr. Doob’s Harmony

非常符合随手绘制勾勒图像概略的二个工具。

图片 1

  1. Sketch

以此工具的开荒者是Hakim El Hattab。你会意识用它画摄影蛮有意思,甚至仍是能够画3D草图。

图片 2

  1. Deviant Muro

那是个很强劲的工具。带有种种笔刷跟滤镜,能够进行比较娇小的著作。不必安装FLASH 插件就能够利用。

图片 3

  1. 深入之new的效仿实现,Logo字体应用实施。Sketchy Structures

用它能够绘制梦幻般复杂的景色。

图片 4

  1. Multi-User Sketchpad

支撑多顾客同临时间美术。

图片 5

  1. Sketchpad

一款Mini好用的绘图应用,非常轻易上手。

图片 6

  1. Bezier Sketching

能够极低价地定义路线的版画工具。

图片 7

8.Spirograph

Spirograph是八个不胜有趣的HTML 5工具,通过安装分化的参数,能够自动绘制风云万变的圆圈类图形。

图片 8

  1. Bomomo

Bomomo 具备20种油画和样子的工具。鼠标跟随效果很风趣哦。

图片 9

  1. Zwibbler

用Zwibbler能够绘制任何模样圆形跟矩形,还足以随便手绘。具有加阴影,裁撤,重做,复制和粘贴功效。

图片 10

原文:smashinghub

 

赞 收藏 评论

图片 11

前言

在《JavaScript深切之施行上下文栈》中讲到,当JavaScript代码实践一段可进行代码(executable code)时,会制造对应的施行上下文(execution context)。

对于每一个推行上下文,都有多少个基本点性质:

  • 变量对象(Variable object,VO)
  • 职能域链(Scope chain)
  • this

然后分别在《JavaScript深远之变量对象》、《JavaScript深刻之成效域链》、《JavaScript深刻之从ECMAScript规范解读this》中等教育授了那多少个天性。

翻阅本文前,如若对上述的概念不是很了然,希望先读书那几个小说。

因为,这一篇,大家会构成着具备内容,讲讲施行上下文的切实处理进程。

雪碧图

7-Up图实例:天猫商城PC端

图片 12

将多张小图放至一张大图

运用的时候,通过background-position调节彰显的地点,如下图所示:

图片 13

百事可乐图的接纳方法

选取Pepsi-Cola图唯一的亮点,能够说便是削减浏览器的伸手次数。因为浏览器同期能够加载的财富数是自然的,IE 8是6个,Chrome是6个,Firefox是8个。为了求证,写了以下html结构:(那部份固然有一些跑题,可是很要要求研究一下)

图片 14

验证Chrome同一时候加载个数的html–相当多张十分大的图样

然后在Chrome的开拓者工具里面包车型客车Timeline能够看到Chrome确实是6个6个加载的,每一趟最多加载6个:

图片 15

Chrome同有的时候候最多加载财富数为6个

Pepsi-Cola图的制作方法能够用node的八个的包css-sprite,十三分地惠及。只要将图标做好,放到相应的公文夹里面,写好安顿文件运营,就能够转移对应的图形和css,不必要本人手动去调解地点等css属性。详见css-sprite

不过,使用Sprite图存在不可幸免的劣势

new

一句话介绍 new:

new 运算符创设贰个客户定义的对象类型的实例或享有构造函数的放到对象类型之一

兴许有一点点难懂,大家在模仿 new 以前,先看看 new 达成了什么样功效。

举个例证:

// Otaku 御宅族,简称宅 function Otaku (name, age) { this.name = name; this.age = age; this.habit = 'Games'; } // 因为相当不足训练的由来,身体强度令人忧虑 Otaku.prototype.strength = 60; Otaku.prototype.sayYourName = function () { console.log('I am ' + this.name); } var person = new Otaku('凯文', '18'); console.log(person.name) // 凯文 console.log(person.habit) // Gamesconsole.log(person.strength) // 60 person.sayYourName(); // I am 凯文

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// Otaku 御宅族,简称宅
function Otaku (name, age) {
    this.name = name;
    this.age = age;
 
    this.habit = 'Games';
}
 
// 因为缺乏锻炼的缘故,身体强度让人担忧
Otaku.prototype.strength = 60;
 
Otaku.prototype.sayYourName = function () {
    console.log('I am ' + this.name);
}
 
var person = new Otaku('Kevin', '18');
 
console.log(person.name) // Kevin
console.log(person.habit) // Games
console.log(person.strength) // 60
 
person.sayYourName(); // I am Kevin

从这些事例中,大家能够看出,实例 person 能够:

  1. 拜谒到 Otaku 构造函数里的天性
  2. 访谈到 Otaku.prototype 中的属性

接下去,大家得以尝尝着模拟一下了。

因为 new 是任重(Ren Zhong)而道远字,所以无法像 bind 函数一样直接覆盖,所以我们写多少个函数,命名称叫 objectFactory,来模拟 new 的作用。用的时候是如此的:

function Otaku () { …… } // 使用 new var person = new Otaku(……); // 使用 objectFactory var person = objectFactory(Otaku, ……)

1
2
3
4
5
6
7
8
function Otaku () {
    ……
}
 
// 使用 new
var person = new Otaku(……);
// 使用 objectFactory
var person = objectFactory(Otaku, ……)

类数组对象

所谓的类数组对象:

享有二个 length 属性和若干索引属性的对象

比如:

var array = ['name', 'age', 'sex']; var arrayLike = { 0: 'name', 1: 'age', 2: 'sex', length: 3 }

1
2
3
4
5
6
7
8
var array = ['name', 'age', 'sex'];
 
var arrayLike = {
    0: 'name',
    1: 'age',
    2: 'sex',
    length: 3
}

就算如此,为何叫做类数组对象啊?

那让我们从读写、获取长度、遍历多个方面看看那三个对象。

思考题

在《JavaScript深切之词法功用域和动态效用域》中,提议如此一道思试题:

var scope = "global scope"; function checkscope(){ var scope = "local scope"; function f(){ return scope; } return f(); } checkscope();

1
2
3
4
5
6
7
8
9
var scope = "global scope";
function checkscope(){
    var scope = "local scope";
    function f(){
        return scope;
    }
    return f();
}
checkscope();

var scope = "global scope"; function checkscope(){ var scope = "local scope"; function f(){ return scope; } return f; } checkscope()();

1
2
3
4
5
6
7
8
9
var scope = "global scope";
function checkscope(){
    var scope = "local scope";
    function f(){
        return scope;
    }
    return f;
}
checkscope()();

两段代码都会打字与印刷’local scope’。即使两段代码推行的结果一致,然则两段代码毕竟有何不相同呢?

继而就在下一篇《JavaScript深刻之施行上下文栈》中,讲到了两侧的界别在于施行上下文栈的变通不等同,但是,假若是那样笼统的答应,依旧显得非常不够详细,本篇就能够详细的分析实践上下文栈和实践上下文的切切实实变化历程。

百事可乐图的败笔

千帆竞发完成

分析:

因为 new 的结果是三个新目标,所以在模仿完成的时候,我们也要树立七个新目的,倘若那些目的叫 obj,因为 obj 会具备 Otaku 构造函数里的性质,想想出色一连的例证,大家得以选取 Otaku.apply(obj, arguments)来给 obj 加多新的质量。

在 JavaScript 长远连串第一篇中,大家便讲了原型与原型链,大家清楚实例的 __proto__ 属性会指向构造函数的 prototype,约等于因为创立起那样的涉及,实例能够访谈原型上的质量。

今后,大家能够尝试着写第一版了:

// 第一版代码 function objectFactory() { var obj = new Object(), Constructor = [].shift.call(arguments); obj.__proto__ = Constructor.prototype; Constructor.apply(obj, arguments); return obj; };

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 第一版代码
function objectFactory() {
 
    var obj = new Object(),
 
    Constructor = [].shift.call(arguments);
 
    obj.__proto__ = Constructor.prototype;
 
    Constructor.apply(obj, arguments);
 
    return obj;
 
};

在这一版中,大家:

  1. 用new Object() 的不二等秘书诀新建了贰个对象 obj
  2. 抽取第三个参数,正是大家要传播的构造函数。其余因为 shift 会修改原数组,所以 arguments 会被删除第叁个参数
  3. 将 obj 的原型指向构造函数,那样 obj 就能够访谈到构造函数原型中的属性
  4. 采纳 apply,改变构造函数 this 的针对到新建的对象,那样 obj 就可以访问到构造函数中的属性
  5. 返回 obj

更加多关于:

原型与原型链,能够看《JavaScript深切之从原型到原型链》

apply,可以看《JavaScript深远之call和apply的模仿完毕》

经文一连,能够看《JavaScript深刻之继续》

复制以下的代码,到浏览器中,我们可以做一下测量试验:

function Otaku (name, age) { this.name = name; this.age = age; this.habit = 'Games'; } Otaku.prototype.strength = 60; Otaku.prototype.sayYourName = function () { console.log('I am ' + this.name); } function objectFactory() { var obj = new Object(), Constructor = [].shift.call(arguments); obj.__proto__ = Constructor.prototype; Constructor.apply(obj, arguments); return obj; }; var person = objectFactory(Otaku, 'Kevin', '18') console.log(person.name) // Kevin console.log(person.habit) // Games console.log(person.strength) // 60 person.sayYourName(); // I am Kevin

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
function Otaku (name, age) {
    this.name = name;
    this.age = age;
 
    this.habit = 'Games';
}
 
Otaku.prototype.strength = 60;
 
Otaku.prototype.sayYourName = function () {
    console.log('I am ' + this.name);
}
 
function objectFactory() {
    var obj = new Object(),
    Constructor = [].shift.call(arguments);
    obj.__proto__ = Constructor.prototype;
    Constructor.apply(obj, arguments);
    return obj;
};
 
var person = objectFactory(Otaku, 'Kevin', '18')
 
console.log(person.name) // Kevin
console.log(person.habit) // Games
console.log(person.strength) // 60
 
person.sayYourName(); // I am Kevin

[]~( ̄▽ ̄)~**

读写

console.log(array[0]); // name console.log(arrayLike[0]); // name array[0] = 'new name'; arrayLike[0] = 'new name';

1
2
3
4
5
console.log(array[0]); // name
console.log(arrayLike[0]); // name
 
array[0] = 'new name';
arrayLike[0] = 'new name';

实际进行分析

咱俩剖判第一段代码:

var scope = "global scope"; function checkscope(){ var scope = "local scope"; function f(){ return scope; } return f(); } checkscope();

1
2
3
4
5
6
7
8
9
var scope = "global scope";
function checkscope(){
    var scope = "local scope";
    function f(){
        return scope;
    }
    return f();
}
checkscope();

推行进度如下:

1.实施全局代码,创立全局实行上下文,全局上下文被压入试行上下文栈

ECStack = [ globalContext ];

1
2
3
    ECStack = [
        globalContext
    ];

2.全局上下文起始化

globalContext = { VO: [global, scope, checkscope], Scope: [globalContext.VO], this: globalContext.VO }

1
2
3
4
5
    globalContext = {
        VO: [global, scope, checkscope],
        Scope: [globalContext.VO],
        this: globalContext.VO
    }

2.初叶化的同时,checkscope 函数被创设,保存功能域链到函数的里边属性[[scope]]

checkscope.[[scope]] = [ globalContext.VO ];

1
2
3
    checkscope.[[scope]] = [
      globalContext.VO
    ];

3.实行 checkscope 函数,创设 checkscope 函数实践上下文,checkscope 函数施行上下文被压入推行上下文栈

ECStack = [ checkscopeContext, globalContext ];

1
2
3
4
    ECStack = [
        checkscopeContext,
        globalContext
    ];

4.checkscope 函数施行上下文初叶化:

  1. 复制函数 [[scope]] 属性成立作用域链,
  2. 用 arguments 创制活动指标,
  3. 初叶化活动指标,即步入形参、函数注脚、变量评释,
  4. 将运动对象压入 checkscope 功能域链最上部。

再者 f 函数被创建,保存功效域链到 f 函数的内部属性[[scope]]

checkscopeContext = { AO: { arguments: { length: 0 }, scope: undefined, f: reference to function f(){} }, Scope: [AO, globalContext.VO], this: undefined }

1
2
3
4
5
6
7
8
9
10
11
    checkscopeContext = {
        AO: {
            arguments: {
                length: 0
            },
            scope: undefined,
            f: reference to function f(){}
        },
        Scope: [AO, globalContext.VO],
        this: undefined
    }

5.推行 f 函数,成立 f 函数实施上下文,f 函数推行上下文被压入推行上下文栈

ECStack = [ fContext, checkscopeContext, globalContext ];

1
2
3
4
5
    ECStack = [
        fContext,
        checkscopeContext,
        globalContext
    ];

6.f 函数实践上下文初阶化, 以下跟第 4 步一样:

  1. 复制函数 [[scope]] 属性创设效率域链
  2. 用 arguments 创造活动对象
  3. 早先化活动对象,即步向形参、函数注明、变量阐明
  4. 将运动指标压入 f 成效域链顶上部分

fContext = { AO: { arguments: { length: 0 } }, Scope: [AO, checkscopeContext.AO, globalContext.VO], this: undefined }

1
2
3
4
5
6
7
8
9
    fContext = {
        AO: {
            arguments: {
                length: 0
            }
        },
        Scope: [AO, checkscopeContext.AO, globalContext.VO],
        this: undefined
    }

7.f 函数进行,沿着作用域链查找 scope 值,重临 scope 值

8.f 函数实行实现,f 函数上下文从实行上下文栈中弹出

ECStack = [ checkscopeContext, globalContext ];

1
2
3
4
    ECStack = [
        checkscopeContext,
        globalContext
    ];

9.checkscope 函数推行达成,checkscope 实行上下文从实践上下文栈中弹出

ECStack = [ globalContext ];

1
2
3
    ECStack = [
        globalContext
    ];

第二段代码就留给咱们去尝尝模拟它的实行过程。

var scope = "global scope"; function checkscope(){ var scope = "local scope"; function f(){ return scope; } return f; } checkscope()();

1
2
3
4
5
6
7
8
9
var scope = "global scope";
function checkscope(){
    var scope = "local scope";
    function f(){
        return scope;
    }
    return f;
}
checkscope()();

但是,在下一篇《JavaScript深远之闭包》中也会谈到这段代码的实行进程。

高清屏会失真

在2x的装置像素比的显示器上比方mac,借使要达到规定的规范和文字同样的清晰度,图片的肥瘦须要实际显示大小的两倍,不然看起来会相比模糊:读者能够对照左侧文字和左臂图片里文字的清晰度

图片 16

侧面图片里的文字比侧面字体的文字模糊

专程是前天手提式无线电话机绝大部份是高清屏了,举个例子iphone 6 plus的分辨率高达了1916 * 1080,所以为了高清屏,使用Coca Cola图或许要筹划三种准则的图样。

重返值效果落实

接下去大家再来看一种意况,倘使构造函数有重返值,举个例证:

function Otaku (name, age) { this.strength = 60; this.age = age; return { name: name, habit: 'Games' } } var person = new Otaku('Kevin', '18'); console.log(person.name) // Kevin console.log(person.habit) // Games console.log(person.strength) // undefined console.log(person.age) // undefined

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
function Otaku (name, age) {
    this.strength = 60;
    this.age = age;
 
    return {
        name: name,
        habit: 'Games'
    }
}
 
var person = new Otaku('Kevin', '18');
 
console.log(person.name) // Kevin
console.log(person.habit) // Games
console.log(person.strength) // undefined
console.log(person.age) // undefined

在这一个事例中,构造函数重返了四个对象,在实例 person 中不得不访谈回到的靶子中的属性。

並且还要小心一点,在那边我们是再次回到了叁个对象,假设我们只是重临贰个主干项目标值吗?

再举例:

function Otaku (name, age) { this.strength = 60; this.age = age; return 'handsome boy'; } var person = new Otaku('Kevin', '18'); console.log(person.name) // undefined console.log(person.habit) // undefined console.log(person.strength) // 60 console.log(person.age) // 18

1
2
3
4
5
6
7
8
9
10
11
12
13
function Otaku (name, age) {
    this.strength = 60;
    this.age = age;
 
    return 'handsome boy';
}
 
var person = new Otaku('Kevin', '18');
 
console.log(person.name) // undefined
console.log(person.habit) // undefined
console.log(person.strength) // 60
console.log(person.age) // 18

结果完全颠倒过来,此番尽管有再次回到值,可是一定于尚未再次回到值实行拍卖。

据此大家还索要推断重回的值是或不是贰个指标,如若是多个指标,大家就再次回到那些目的,若无,我们该再次回到什么就回去什么。

再来看第二版的代码,也是最后一版的代码:

// 第二版的代码 function objectFactory() { var obj = new Object(), Constructor = [].shift.call(arguments); obj.__proto__ = Constructor.prototype; var ret = Constructor.apply(obj, arguments); return typeof ret === 'object' ? ret : obj; };

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 第二版的代码
function objectFactory() {
 
    var obj = new Object(),
 
    Constructor = [].shift.call(arguments);
 
    obj.__proto__ = Constructor.prototype;
 
    var ret = Constructor.apply(obj, arguments);
 
    return typeof ret === 'object' ? ret : obj;
 
};

长度

console.log(array.length); // 3 console.log(arrayLike.length); // 3

1
2
console.log(array.length); // 3
console.log(arrayLike.length); // 3

本文由云顶娱乐集团发布于云顶娱乐集团,转载请注明出处:深入之new的效仿实现,Logo字体应用实施

关键词:

上一篇:没有了

下一篇:没有了