ond xinchi外语

fond英 [f?nd] 美 [fɑ?nd]

adj. 喜爱的，喜欢做……的；美好的，愉悦的；慈爱的，深情的；天真的，不切实际的

v. <旧>盲目地喜欢；呵护，抚弄

n. 烹饪后锅中的棕色残留物；（信息科学）全宗

【名】 （Fond）（法）丰，（瑞典）丰德（人名）

[ 复数 fonds 第三人称单数 fonds 现在分词 fonding 过去式 fonded 过去分词 fonded 比较级 fonder 最高级 fondest ]

短语

be fond of 喜欢 ; 爱好 ; 喜爱 ; 喜好

Fond of 情有独钟 ; 喜欢 ; 爱好 ; 喜爱

be fond of doing sth 对做某事感兴趣 ; 喜欢做某事 ; 对做某事感兴致

Cancer Fond 癌症基金会

Ae Fond Kiss 再一次亲吻 ; 爱之吻 ; 阿拉伯之吻

Find fond 选择字体

fond dream 唐代淳于棼做梦到大槐安国享受富贵荣华

Insurance Fond 保险基金

收起网络短语

柯林斯英汉双解大词典

fond /f?nd/ CET4 TEM4 ( fonder, fondest )

1. ADJ If you are fond of someone, you feel affection for them. 喜爱的 [v-link ADJ 'of' n]

例：I am very fond of Michael.

我很喜欢迈克尔。

2. fondness N-UNCOUNT 喜爱

例：...a great fondness for children.

…对孩子们的一种深深喜爱。

3. ADJ You use fond to describe people or their behaviour when they show affection. 慈爱的 [ADJ n]

例：...a fond father.

…一个慈爱的父亲。

4. fondly ADV 慈爱地 [ADV after v]

例：Liz saw their eyes meet fondly across the table.

利兹看到他们隔着桌子深情地对视着。

5. ADJ If you are fond of something, you like it or you like doing it very much. 很喜欢 [v-link ADJ 'of' n/-ing]

例：He was fond of marmalade.

他很喜欢橘子酱。

6. fondness N-UNCOUNT 钟爱

例：I've always had a fondness for chocolate cake.

我一直对巧克力蛋糕情有独钟。

7. ADJ If you have fond memories of someone or something, you remember them with pleasure. (回忆) 美好的 [ADJ n]

例：I have very fond memories of living in our village.

我对在我们村的生活有着美好的回忆。

8. fondly ADV 愉快地 [ADV with v]

例：My dad took us there when I was about four and I remembered it fondly.

我爸爸在我四岁左右时带我去过那里，想起来很愉悦。

9. ADJ You use fond to describe hopes, wishes, or beliefs which you think are foolish because they seem unlikely to be fulfilled. (希望、想法或信仰等) 不切实际的 [ADJ n]

例：My fond hope is that we will be ready by Christmastime.

我的不切实际的愿望就是我们能在圣诞节假期前准备好。

10. fondly ADV 不切实际地 [ADV with v]

例：I fondly imagined that surgery meant a few stitches and an overnight stay in the hospital.

我不切实际地以为外科手术就是缝几针并在医院呆上一夜。

11. N the background of a design, a

design, as in lace (如花边)设计背景

词组短语同近义词同根词

fond of 喜欢；爱好

fond dream南柯一梦；黄粱美梦

双语例句原声例句权威例句

I have grown very fond of Alec.

我已变得很喜欢亚力克。

《柯林斯英汉双解大词典》

I am very fond of Michael.

我很喜欢迈克尔。

《柯林斯英汉双解大词典》

He was fond of marmalade.

他很喜欢橘子酱。

每天分享外语知识，请点击 【关注】，不漏掉任何一期，助你提高外语水平。

【讯驰外语】可乐老师 编辑。

转载《有道词典》，如有侵权请通知删除。

码字不易，敬请【点赞】！

My email：ilikework_cz@126.com

内容是《Web前端开发之Javascript视频》的课件，请配合大师哥《Javascript》视频课程学习。

为了便于操作基本类型值，ECMAScript还提供了3个特殊的引用类型：Boolean、Number和String；这些类型与以上所说的引用类型相似，但同时也具有与各自的基本类型相应的特殊行为；实际上，每当读取一个基本类型值的时候，后台就会创建一个对应的基本包装类型的对象，从而让我们能够用一些方法来操作这些数据，如：

var s1="zero network";
var s2=s1.substring(4);
alert(s2);

基本数据类型不是对象，所以从逻辑上它们不应该有方法(实际上有)（原理：为了能够实现这种直观的操作，后台已经自动完成了一系列的处理：创建String对象实例，同样适用于Boolean和Number类型对应的布尔值和数字值。

基本数据类型与基本包装类型有本质上的不同，产生从类型的角度来讲，它们就是不同的；其保存的位置也不同。

引用类型与基本包装类型的区别就是对象的生存期：使用new操作符创建的引用类型对象，在执行流离开当前作用域之前都一直保存在内存中，而自动创建的基本包装类型的对象，则只存在于一行代码的执行瞬间，然后立即被销毁；这意味着不能在运行时为基本类型值添加属性和方法，如：

var s1="zero network";
s1.color="red";
alert(s1.color); // undefined

当然可以使用Boolean, Number和String显示的来创建基本包装类型的对象，但绝大部分情况下不需要，除非在绝对必要的情况下，因为这种做法很容易让开发者分不清是在处理基本类型还是引用类型的值；

对基本包装类型的实例调用typeof会返回object，而且所有基本包装类型的对象在转换为布尔类型时值都是true；如：

var s1=new Number(0);
// var s1=0;
alert(typeof s1);
alert(Boolean(s1));

Object构造函数，仅接受一个参数，其会根据传入值的类型返回相应基本包装类型的实例，如：

var obj=new Object("zeronetwork");
alert(obj instanceof String);  // true
var n=new Object(5);
alert(n instanceof Number); // true
console.log(n.constructor);

说明：传递的值是动态的，直到运行时才确定其类型，Object()可能会调用另一个内置函数来创建对象，并且返回了一个以不同构造函数所创建的对象。

ES在必要的时会将包装对象转换成原始值，但不总是这样；如：

var s1="zeronetwork";
var s2=new String("zeronetwork");
console.log(s1==s2);  // true
console.log(s1===s2); // false
var n1=18;
var n2=new Number(18);
console.log(n1==n2);  // true
console.log(n1===n2); // false

说明：“==”运算符会将原始值与包装对象视为相等，但“===”全等会将它们视为不等，因为它们的类型不同，可以使用typeof查看。

注意：使用new调用基本包装类型的构造函数，与直接调用同名的转型函数是不一样的，如：

var value="25";
var number=Number(value);  // 转型函数
alert(typeof number);  // number
var obj=new Number(value);  // 构造函数
alert(typeof obj); // object

注：null与undefined没有包装对象，访问它们的属性会造成一个类型错误。

尽管在实际场景中不太使用基本包装类型，并且也不建议使用，但它们操作基本类型值的能力还是相当重要的，而每个基本包装类型都提供了操作相应值的便捷方法。

Boolean类型：

Boolean类型是与布尔值对应的引用类型，Boolean 对象表示两个值："true" 或 "false"。

创建Boolean对象：var oBool=new Boolean(true); // 传入true或false值

注：如果逻辑对象无初始值或者其值为 0、-0、null、""、false、undefined 或者 NaN，那么对象的值为 false，否则，其值为 true；

在实际场景中，Boolean对象的用处不大，因为经常会造成一些误解，其中最常见的问题就是在布尔表达式中使用Boolean对象，如：

var bObj=new Boolean(false);
alert(bObj && true);  // true
var bValue=false;
alert(bValue && true); // false

基本类型与引用类型还有两个区别，首先，typeof操作符对基本类型返回boolean，而对引用类型返回object；其次，由于Boolean类型的实例，所以使用instanceof操作符测试Boolean对象会返回true，而测试基本类型的布尔值则返回false，如：

var falseObject=new Boolean(false);
var falseValue=false;
alert(typeof falseObject);  // object
alert(typeof falseValue); // boolean
alert(falseObject instanceof Boolean); // true
alert(falseValue instanceof Boolean); // false

总结：理解基本类型的布尔值与Boolean对象之间的区别非常重要，建议不要使用，最好使用Boolean原始值；

可以使用Boolean(参数)进行数据类型转换;

Number对象：

Number 对象，是原始数值的包装对象。在必要时，JavaScript 会自动地在原始数据和对象之间转换；

可以用构造函数 Number() 明确地创建一个 Number 对象：

var numberObject=new Number(10);

Number对象属性：

• MAX_VALUE：表示的最大的数，静态属性；
• MIN_VALUE：表示的最小的数，静态属性；
• NaN：非数字值，静态属性；
• NEGATIVE_INFINITY：负无穷大，溢出时返回该值，静态属性；
• POSITIVE_INFINITY：正无穷大，溢出时返回该值，静态属性；

console.log(Number.MAX_VALUE);
console.log(Number.MIN_VALUE);
var x=-Number.MAX_VALUE * 2;
if(x==Number.NEGATIVE_INFINITY)
    console.log("X的值：" + x);
var y=Number.MAX_VALUE * 2;
if(y==Number.POSITIVE_INFINITY)
    console.log("Y的值：" + y);

注: Number.NaN 是一个特殊值，说明某些算术运算（如求负数的平方根）的结果不是数字。方法 parseInt() 和 parseFloat() 在不能解析指定的字符串时就返回这个值。

Number类或对象方法：

• parseInt() 和 parseFloat()方法，静态方法；
• isNaN() 来判断是否为数字，静态方法；
• isFinite：是否为有限，静态方法；
• isInteger：是否为整形，静态方法；
• toString()方法: 如:NumberObject.toString(radix)，radix可选，规定表示数字的基数，使 2 ~ 36 之间的整数，若省略该参数，则使用基数 10。

var number=new Number(1337);
console.log(number.toString(8));

• toLocaleString() 方法可把一个 Number 对象转换为本地格式的字符串。
• toFixed() 方法：把 Number 四舍五入为指定小数位数的数字，类型是字符串；参数规定了小数的位数，是 0 ~ 20 之间的值；有些实现可以支持更大的数值范围。如果省略了该参数，将用 0 代替。

var num=new Number(12.345678);
console.log(num.toFixed(2));  // 12.35

• toExponential()方法可把对象的值转换成指数计数法。如:NumberObject.toExponential(num) ，num规定指数计数法中的小数位数，是 0 ~ 20 之间的值；

var num=1200.00;
console.log(num.toExponential(2));

• toPrecision() 方法可在对象的值超出指定位数时将其转换为指数计数法；其可能会返回固定大小格式，也可能返回指数格式，具体规则是看哪种格式最合适；如:NumberObject.toPrecision(num) ，num规定必须被转换为指数计数法的最小位数，该参数是 1 ~ 21；

var num=99;
console.log(num.toPrecision(1));    // 1e+2
console.log(num.toPrecision(2));    // 99
console.log(num.toPrecision(3));    // 99.0
num=10000;
console.log(num.toPrecision(1));    // 1e+4
console.log(num.toPrecision(4));    // 1.000e+4

注意：与Boolean对象类似，Number对象也以后台方式为数值提供了重要的功能；不建议直接实例化Number类型，原因与Boolean一样；一般情况下是使用数字的原始表示法；

var numberObject=new Number(10);
var numberValue=10;
alert(typeof numberObject);  // object
alert(typeof numberValue);  // number
alert(numberObject instanceof Number); // true
alert(numberValue instanceof Number); // false

String对象：

String类型是字符串对象包装类型，用于处理文本（字符串）。语法：var str=new String(str); 如：

var oStr=new String();
var oStr=new String("零点程序员");
var oStr=String("525");

length属性：返回字符串中的字符个数 如: str.length ;

注：即使字符串包含双字节字符（不是占一个字节的ASCII字符），每个字符也仍然算一个字符；

String 类定义了大量操作字符串的方法，例如从字符串中提取字符或子串，或者检索字符或子串。

需要注意的是，JavaScript 的字符串是不可变的（immutable），String 类定义的方法都不能改变字符串的内容。像 String.toUpperCase() 这样的方法，返回的是全新的字符串，而不是修改原始字符串。

1）字符方法：

用于访问字符串中特定字符的方法：charAt()和charCodeAt()；这两个方法都接收一个参数，即基于0的字符位置；其中，charAt()方法以单字符字符串的形式返回给定位置的那个字符（ECMAScript中没有字符类型），如：

var str="zero network";
alert(str.charAt(2));

如果想得到字符编码而不是字符时，使用charCodeAt()，如：

var str="zero network";
alert(str.charCodeAt(2));  // 114

ECMAScript还定义了另一个访问字符的方法，即使用括号（类似于访问数组元素）语法，使用数字索引来访问字符串中的特定字符，如：

var str="zero network";
alert(str[2]);  // 2

2）字符串操作方法：

concat()方法：用于将一或多个字符串拼接起来，返回拼接得到的新字符串，如：

var str = "zero";
var result = str.concat("network");
alert(str);
alert(result);

concat()方法可以接受多个任意参数，即可以通过它可以拼接任意多个字符串，如：

var str = "zero";
var result = str.concat("network","!");
alert(result);

说明：虽然concat()是专门用来拼接字符串的，但在实际场景中使用更多的还是加号操作符（+）；而且，使用加号操作符在大多数情况下都比使用concat方法要简便易行，特别是在拼接多个字符串的情况下；

ECMAScript提供了三个基于字符串创建新字符串的方法：slice()、substr()和substring()；这三个方法都会返回被操作字符串的一个子字符串，而且也都接受一或两个参数；第一个参数指定子字符串的开始位置，第二个参数表示子字符串到哪里结束；具体来说，slice()和substring()的第二个参数指定的是子字符串最后一个字符后面的位置；而substr()的第二个参数指定的则是返回的字符个数；如果没有给这些方法传递第二个参数，则将字符串的末尾作为结束位置，如：

var str = "zero network";
alert(str.slice(3));
alert(str.substring(3));
alert(str.substr(3));
alert(str.slice(3,6));
alert(str.substring(3,6));
alert(str.substr(3,6));

同时这些方法的值可以是负值；其中，slice()会将传入的负值与字符串的长度相加，substr()将负的第一个参数加上字符串的长度，而将负数的第二个参数转换为0，substring()方法会把所有负值参数都转换为0，如：

var str = "zero network";
alert(str.slice(-3));
alert(str.substring(-3));
alert(str.substr(-3));
alert(str.slice(3,-4));
alert(str.substring(3,-4));
alert(str.substr(3,-4));

一个小示例：

<style>
#mydiv{width: 100px; height: 1.5em; border: 1px solid; overflow: hidden;}
</style>
<div id="mydiv"></div>
<script>
var msg="北京零点网络科技有限公司";
var spacer="...";
var pos=0;
var mydiv = document.getElementById("mydiv");
function ScrollMsg(){
    mydiv.innerHTML = msg.substring(pos,msg.length) + spacer + msg.substring(0, pos);
    pos++;
    if(pos>msg.length) pos=0;
    window.setTimeout("ScrollMsg()",200);
}
ScrollMsg();
</script>

3）字符串位置方法：

有两个可以从字符串中查找子字符串的方法：indexOf()和lastIndexOf()；这两个方法都是从一个字符串中搜索给定的子字符串，然后返回子字符串的位置，如果没有找到子字符串，则返回-1；两个方法的区别在于，一个从开头向后搜索子字符串，而lastIndexOf是从末尾向前搜索，如：

var str = "zero network";
alert(str.indexOf("o"));
alert(str.lastIndexOf("o"));

说明：如果o在字符串只出现了一次，则两个方法会返回相同的位置值；

这两个方法都可以接受可选的第二个参数，表示从字符串中的哪个位置开始搜索；如：

var str = "zero network";
alert(str.indexOf("o",6));
alert(str.lastIndexOf("o",6));

在使用第二个参数的情况下，可以循环调用这两个方法来找到所有匹配的子字符串，如：

var str = "lorem ipsum dolor sit amet, consectetur adipisicing elit";
var positions = new Array();
var pos = str.indexOf("e");
while(pos>-1){
    positions.push(pos);
    pos = str.indexOf("e",pos + 1);
}
alert(positions);  // 3,24,32,35,52

4）trim()方法：

ECMAScript5为所有字符串定义了trim()方法；该方法会创建一个字符串的副本，删除前置及后缀的所有空格，然后返回结果，如：

var str = "  zero network    ";
var trimStr = str.trim();
alert(str);
alert(trimStr);

此外，还有两个非标准的trimLeft()和trimRight()方法，分别用于删除字符串开头和末尾的空格；

var trimStr = str.trimLeft();
var trimStr = str.trimRight();

5）字符串大小写转换方法：

涉及字符串大小写转换的方法有4个：

• toLocaleLowerCase()把字符串转换为小写；
• toLocaleUpperCase()把字符串转换为大写；
• toLowerCase()把字符串转换为小写；
• toUpperCase()把字符串转换为大写；

其中toLowerCase()和toUpperCase()是最常用的方法；而toLocaleLowerCase()和toLocaleUpperCase()则是针对特定地区的实现，对有些地区来说，针对地区的方法与其通用方法得到的结果相同，但少数语言（如土耳其语）会为Unicode大小写转换应用特殊的规则，这时候就必须使用针对地区的方法来保证实现正确的转换，如：

var str = "ZERO network";
alert(str.toLocaleLowerCase());
alert(str.toLocaleUpperCase());
alert(str.toLowerCase());
alert(str.toUpperCase());

6）字符串的模式匹配方法：

String类型定义了几个用于在字符串中匹配模式的方法；

match()方法：本质上与RegExp的exec()方法相同；其只接受一个参数，要么是一个正则表达式，要么是一个RegExp对象，如：

var text = "cat, bat, sat, fat";
var pattern = /.at/;
var matches = text.match(pattern);
alert(matches);
alert(matches.index);
alert(matches[0]);
alert(pattern.lastIndex);

说明：match()返回了一个数组，其第一项是与整个模式匹配的字符串，之后的每一项（如果有）保存着与正则表达式中的捕获组匹配的字符串；

search()方法：接受的参数与match()一样；该方法返回字符串中第一个匹配项的索引；如果没有找到匹配项，则返回-1；如：

var text = "cat, bat, sat, fat";
var pos = text.search(/at/);
alert(pos);  // 1

replace()方法：此方法的目的是为了简化替换子字符串的操作；该方法接受两个参数，第一个参数可以是一个RegExp对象或一个字符串（这个字符串不会被转换成正则表达式），第二个参数可以是一个字符串或一个函数；如果第一个参数是字符串，那么只会替换第一个子字符串，要想替换所有子字符串，唯一的办法就是提供一个正则表达式，而且要指定全局g标志，如：

var text = "cat, bat, sat, fat";
var result = text.replace("at","ond");
alert(result);  // cond, bat, sat, fat
result = text.replace(/at/g,"ond");
alert(result);  // cond, bond, sond, fond

split()方法：

可以基于指定的分隔符将一个字符串分割成多个子字符串，并将结果放在一个数组中；分隔符可以是字符串，也可以是RegExp对象；其可以接受可选的第二个参数，用于指定数组的大小，以便确保返回的数组不会超过既定大小，如：

var colorText = "red,blue,green,yellow";
var colors1 = colorText.split(",");
var colors2 = colorText.split(",",2);
var colors3 = colorText.split(/[^\,]+/);
alert(colors1);  // red,blue,green,yellow
alert(colors2);  // red,blue
alert(colors3);  // ,,,,,,,

7）localeCompare()方法：

localeCompare()用本地特定的顺序来比较两个字符串，默认返回下列值中的一个：-1、0、1，如：

var str = "yellow";
alert(str.localeCompare("brick")); // 1
alert(str.localeCompare("yellow")); // 0
alert(str.localeCompare("zoo")); // -1
注：利用localeCompare()可以自定义返回的值，如：
function determineOrder(value){
    var result = stringValue.localeCompare(value);
    if(result  < 0){
        alert("yellow在'"+value+"'之前");
    }else if(result > 0){
        alert("yellow在'"+value+"'之后");
    }else{
        alert("yellow与'"+value+"'相等");
    }
}
determineOrder("brick");
determineOrder("yellow");
determineOrder("zoo");

localeCompare()方法比较与众不同的地方，就是实现所支持的地区（国家和语言）决定了这个方法的行为；如，美国以英语作为ECMAScript实现的标准语言，因此localeCompare()就是区分大小写的，于是大写字母在字母表中排在小写字母前头就成为了一项决定性的比较规则；在其他地区有可能就不是这种情况了。

8）fromCharCode()方法：

String构造函数本身还有一个静态方法：fromCharCode()，这个方法的任务是接受一或多个字符编码，然后将它们转换成一个字符串；从本质上看，这个方法与实例方法charCodeAt()执行的是相反的操作，如：

alert(String.fromCharCode(104,101,108,108,111));  // hello

9）HTML方法：

早期的Web浏览器可以使用Javascript动态格式化HTML，其扩展了字符串的标准，实现了一些专门用于简化常见HTML格式化任务的方法；但是，尽量不要使用这些方法，因为它们创建的标记通常无法表达语义；

• anchor(name)创建 HTML 锚，输出如：<a name=”name”>string</a>
• big()用大号字体显示字符串，如：<big>string</big>
• small()使用小字号来显示字符串，如：<small>string</small>
• blink()显示闪动字符串；
• bold()使用粗体显示字符串，如：<b>string></b>
• fontcolor(color)使用指定的颜色来显示字符串，如：<font color=”color>string</font>
• fontsize(size)使用指定的尺寸来显示字符串，如：<font size=”size”>string</font>
• italics()使用斜体显示字符串，如：<i>string</i>
• link(url)将字符串显示为链接，如：<a href=”url”>string</a>
• fixed()以打字机文本显示字符串，如：<tt>string></tt>
• sup()把字符串显示为上标，如：^string
• sub()把字符串显示为下标，如：_string
• strike()使用删除线来显示字符串，如：<strike>string</strike>

示例：检测上传文件后缀名：

<input type="file" id="myFile"/>
<input type="button" value="上传" onclick="upFile()" />
<script>
function upFile(){
    var fileName = document.getElementById('myFile').value;
    if(fileName){
        // console.log(fileName);
        var pos = fileName.lastIndexOf('.');  // 找到路径中最后出现“.”的位置
        // console.log(pos);
        var suffix = fileName.substr(pos + 1);  // 找到后缀名
        // console.log(suffix);
        var suffixArr = ['jpg','png','gif'];  // 图片格式数组
        // console.log((suffixArr.indexOf(suffix)));
        if(suffixArr.indexOf(suffix) >= 0){  // 后缀名与格式数组作比较
            // 上传图片的操作处理
            console.log("上传成功");
        }else{
            console.log("图片格式不正确");
            return;
        }
    }
}
</script>

示例：过滤脏话：

// 简单过滤
var str = "不要相信女人，女人太坏了";
var arr = ["坏","笨","傻"];  // 敏感字
for(var i = 0; i<arr.length; i++){
    str = str.replace(arr[i],"*");
}
console.log(str);
// 复杂的过滤
var arrStr = [
    "傻子，你的脑子是不是有病？你就是傻子一个！",
    "你的眼睛是不是瞎了？",
    "你是一个大坏蛋！"
];
var arr = ["病","傻子","瞎了","坏蛋"];
for(var i =0;i<arrStr.length; i++){
    for(var j=0;j<arr.length; j++){
        arrStr[i] = arrStr[i].replace(arr[j],"**");
// var reg = new RegExp(arr[j],"img");
       // arrStr[i] = arrStr[i].replace(reg,"**");
 
    }
}
console.log(arrStr);