一 : 读于丹的书 有感

读于丹的《论语心得》的感悟

感悟一：生命就是一枝铅笔

如果说生活是一张白纸，等待着我们用血和泪去描绘自己奋斗和拼博的轨迹，那么生命便是一枝铅笔，它总是用自已瘦瘦的身驱，在洁白的素笺上流泻出笔底的风风雨雨?? 生命之所以是一枝铅笔，而不是一枝钢笔，或别的什么，是因为铅笔和毛笔都可以多次利用，只要吸上墨水，它们就能长时间地写下去，而铅笔却不是这样的，这犹如光阴从我们身边一日一日地溜走，并且永不复还，须知铅笔是越用越短??

生命是一枝铅笔，还意味着人生这篇文章里，如果因为某种原因而写出了错别字甚至病句，你就可以用醒悟的橡皮轻轻地擦去，再去擦拭一新的空白处，重新斟酌，重新运笔，写下自已新生活的火热心迹，一个人有了错误并不可怕，可怕的是不敢正视它和改正它。[www.61k.com) 生命是一枝铅笔，你可以用它为自已的未来设计充满喜悦与渴望的蓝图，也可以用灯下苦读的身影做细线条，为自己紧张而丰富的生活勾勒出一幅充满活力的图画。

生命是一枝铅笔，对我们还有这样一个有力的启示——做人，要像它一样时时刻刻把腰干挺直。

生命就是一枝铅笔??

感悟二：荷花·荷叶·淤泥

一直以来，人们都用“出淤泥而不染”来赞颂荷花。但我认为，这句话太贬低淤泥了，为什么人们总认为淤泥在污染荷花呢？

荷叶因作为陪衬荷花的使者，而受到人们的赞颂，荷叶尚且能让人们发现、赞颂，至少不会受到非议。可怜淤泥辛苦养育了荷花，得到的却是一大堆批评和误解。

在我看来，淤泥不但没有污染荷花，而且还养育了荷花，为了让荷花开得更美丽，更茁壮，它们沉在水下，默默地奉献出自己的一切，却从来不求赞颂，不求索取，也从不计较自已的得失，甚至还要忍受别人的批评和指责，这种精神多么伟大！的确，从外表看，淤泥不美，但美是不能只看外表的，世界上的东西往往是因为伟大才显得美丽，不是加为美丽而显得伟大！

荷花为大自然奉献的精神是可贵的，荷叶默默无闻陪衬的精神更是难得的，而它们赖以生存的“沃土”———淤泥则更崇高，更伟大。我要赞颂这无言的美，博大的美，深沉的美，以及人间最伟大的精神。

王运华

于丹的书 读于丹的书 有感

随笔 落日

四月的落日像个顽皮的孩子，我和爱人静静地欣赏。［www.61k.com)

那时，夕阳越来越来越红，像是女儿们的胭脂盒。周边彩霞是它的裙子

阳光照在红色的正在踱步的公鸡身上，变成了紫色；照在窝棚的黑鸟的小鸟身上，变成了黄色；照在玩耍的娃娃的脸上，变成了红色??真是太有意思了！

太阳光映在奇形怪状云彩身上，那才叫美呢。它给“马”一身白袍；给“狮子”一身黄绸缎；给“小鸡”一身灰铠甲??

摇摇欲坠的夕阳不但给万事万物添加了变幻莫测的光彩，还给植物，动物报时，夜幕降临，它告诉爱美的金银花小姐要睡觉了，它告诉贪玩的萤火虫弟弟要值班了，它告诉高嗓门的青蛙主持要稍娱乐一会儿了??

月亮正在催它呢！太阳也要回家了??

二 : Javascript核心读书有感之语句

这篇文章主要介绍了Javascript核心读书有感之语句,需要的朋友可以参考下

在javascript中，表达式是短语，那么语句（statement）就是整句或命令。正如英文语句以句号结尾，javascript以分号结尾。

表达式计算出一个值，但语句使某件事发生。

“使某件事发生”的一个方法是计算带有副作用的表达式。诸如赋值和函数调用这些有副作用的表达式，是可以作为单独的语句的。这种把表达式当做语句的用法也称做表达式语句（expression statement）。类似的语句还有声明语句（declaration statement），声明语句用来声明新变量或者定义新函数。

javascript程序就是一系列的可执行语句的集合，默认情况下，javascript解释器依照编写顺序依次执行。另一种“使某件事情”发生的方法就是改变语句的默认执行顺序：

1.条件语句（conditional）语句：javascript解释器可以根据一个表达式的值来判断；来执行还是跳过这些语句，例如if和switch语句。

2.循环语句（loop）语句：可以重复执行的语句，例如while和for语句

3.跳转（jump）语句：可以让解释器跳转至程序的其它部分继续执行、例如break、return和throw语句

接下来本文将介绍javascript中各式各样的语句和其语法。本章最后对这些语句做了总结。一个javascript程序无非是以分隔分割的语句集合，所以一旦掌握了javascript语句，就可以编写javascript程序了。

1.表达式语句

赋值语句是一种比较重要的表达式语句，它的作用就是改变一个变量的值，就像执行一条赋值语句一样：例如

代码如下:

greet = "hello" + name;

i *= 3;

递增运算符(++)和递减运算符(--)和赋值语句有关。它们的作用是改变一个变量的值，就像执行一条赋值语句一样。

代码如下:

counter++;

delete运算符的重要作用就是删除一个对象的属性（或数组的元素），所有它一般作为语句使用，而不是作为复杂表达式的一部分。

代码如下:

delete o.x;

函数调用是表达式语句的另外一个大类，例如

代码如下:

alert(greet);

window.close();

虽然这些客户端函数都是表达式，但它们对web浏览器造成了一定的影响。所以我们认为也是语句，调用一个没有副作用的函数是没有意义的，除非它是复杂的表达式或赋值语句的一部分，例如。不可能随便把一个余弦值丢弃；

Math.cos(x);

相反，得出余弦值就得把它赋值给一个变量，以便将来使用这个值：

var cx = Math.cos(x);

再次提醒各位，每行代码就是以分号结束的。

2.复合语句和空语句

可以用逗号运算符将几个表达式连接在一起，形成一个表达式。同样，javascript还可以讲多条语句联合在一起，形成一个复合语句（compound statement）。只需花括号将多条语句括起来即可。因此，下面几行代码可以当成一条单独的语句，使用在javascript任何希望使用一条语句的地方。

代码如下:

{

x = Math.PI;

cx = Math.cos(x);

console.log("cos(π)=" + cx);

}

关于语句块有几点需要注意：第一，语句块不需要分号。块中的元素语句必须以分号结尾，但语句块不需要。

第二，语句块中的行都有缩进，这不是必须的，但整齐的缩进能使代码可读性更强，更容易理解。

第三，javascript没有块级作用域，在语句块中声明的变量并不是语句块所私有的。（参考3章10节第一小节）

将很多条语句合并成一个大语句块的做法在javascript编程中非常常见。类似的表达式通常包含子表达式一样，很多javascript包含其它子语句，从形式来讲，javascript通常允许一个语句块包含一条子语句。例如：while循环的循环体就可以只包含一条语句。使用语句块，可以将任意数量的语句放到这个块中，这个语句块可以当做一条语句来使用。

在javascript中，当希望多条语句被当做一条语句使用时，使用符合语句来替代。空语句(empty statement)则恰好相反，它允许包含0条语句。空语句如下所示：

;//分号

javascript解释器在执行空语句时显然不执行任何动作，但实践证明：当创建一个具有空循环体的循环时，空语句有时是很有用的，例如下面的for循环

代码如下:

//初始化一个数组a

for (i = 0; i < a.length; a[i++] = 0);

在这个循环中，所有的操作都在表达式a[i++]=0中完成，这里并不需要任何循环体。然而javascript需要循环体中至少包含一条语句，因此这里只使用了一个单独的分号来表示一条空语句。

注意，在for循环、while循环或if语句的右边园括号的分号很不起眼，这很可能造成 一些致命的bug，而这些bug很难定位到。例如下面的代码的执行结果很可能就是作者不想要的效果：

代码如下:

if((a==0)||(b==0)); //这一行代码什么也没做....

o = null; //这一行代码总会执行

如果有特殊目的使用空语句，最好在代码中添加注释，这样能更清楚的说明这条空语句是有用的

代码如下:

for (i = 0; i < a.length; a[i++] = 0) /*empty*/;

3.声明语句

var和function都是声明语句，它们声明或定义变量或函数。这些语句定义标识符（变量名和函数名）并给其赋值，这些标识符可以在程序任意地方使用。声明语句本身什么也不做，但它有一个重要意义：通过创建变量和函数，可以更好的组织代码的语义。

接下几节将讲述var语句和function语句，但并不包含变量和函数的全部内容。

i.var

var语句用来声明一个或者多个变量，它的语法如下：

var name_1[ = value_1][, ..., name_n[ = value_n]]

关键字var之后跟随的是要声明的变量列表，列表中的每一个变量都可以带有初始化表达式，可用于指定它的初始值。例如：

代码如下:

var i; //一个简单的变量

var j = 0; //一个带有初始值的变量

var p, q; //两个变量

var greet = "hello" + name; //更复杂的初始化表达式

var x = 2.34,y = Math.cos(0.75),r, theta; //很多变量

var x = 2,y = x * x; //第二个变量使用了第一个变量

var x = 2,

f = function(x) {return x * x}, //每个变量都独占一行

y = f(x)

如果var语句出现在函数体内，那么定义的是一个局部变量，其作用域就是这个函数。如果在顶层代码中使用var语句，那么它声明的是全局变量，在整个javascript中，都是可见的。在第三章10节提到：全局变量是全局对象的属性，然后和其它全局对象属性不同的是，var声明的变量是无法通过delete删除的。

如果var语句中的变量没有指定初始化表达式，那么这个变量的值初始为undefined。所以，在声明语句之前的变量值就是undefined。

需要注意的是，var语句同样可以作为for循环或者for/in循环的组成部分。（在循环之前声明的变量声明一样，这里声明变量也会"提前"），例如：

代码如下:

for (var i = 0; i < 10; i++) console.log(i);

for (var i = 0, j = 10; i < 10; i++, j--) console.log(i * j);

for (var i in o)console.log(i);

注意，多次声明同一变量是无所谓的。

ii.function

关键字function用来声明函数的，我们已经学过函数表达式（4.3）.函数定义可以写成语句的形式。例如：下面示例代码中的两种定义写法：

代码如下:

var f = function f(x) {return x + 1;} //将表达式赋值给一个变量

function f(x){return x + 1;} //含有变量名的语句

函数声明的语法如下：

代码如下:

function funcname([arg1[, arg2[..., argn]]]) {

statements

}

funcname是要声明的函数的名称标识符。函数名之后是参数列表，参数之间使用逗号隔开。当调用函数的时候，这些标识符则指代传入函数的实参。

函数体是由javascript语句组成的，语句数量不限，且用花括号括起来。在定义函数时，并不执行函数体内的语句，它和调用函数时待执行的新函数对象相关联。注意，function函数语句里的花括号是必须的，这和while循环和其它一些语句锁使用的语句块是不同的，即使函数体只有一条语句，仍然需要花括号将其括起来。

代码如下:

function hyteus(x, y) {

return Math.sqrt(x * x + y * y);

}

hyteus(1, 2) //=>2.23606797749979

function facial(n) { //一个递归函数

if (n <= 1) return 1;

return n * facial(n - 1);

}

facial(11) //=>39916800

函数的声明通常出现在javascript代码的最顶部，也可以嵌套在其他函数体内。但在嵌套时，函数声明只能出现在所嵌套的函数顶部。也就是说：函数定义不能出现在if、while、或其他语句中。

和var语句一样，函数声明语句创建的变量也是不可删除的。但是这些变量不是只读的，变量值可以重写。

4.条件语句

条件语句是通过判断指定的表达式的值是否来执行或跳过某些语句。这些语句是代码的”决策点“，有时称为”分支“。如果javascript解释器是按照代码的”路径“执行的。条件语句就是这条路上的分叉点。程序到达这里必须选择一条路径来继续执行。

i.if语句

if语句是基本的控制语句，准确的说，它让程序有条件的执行，这种语句有两种形式：第一种是

代码如下:

if (expression)

statement

这种形式中，判断expression 的值，如果是真，执行statement语句，如果是假值，就不执行statement.例如

代码如下:

if (username == null) //如果username是null或undefined

username = "jack wong"; //对其进行定义

需要注意的是，if语句括住expression的园括号是必须的。

javascript语法规定，if关键字和带园括号的表达式之后必须跟随一条语句。但可以使用语句块将多条语句合成一条。因此，if语句的形式如下所示：

代码如下:

if (!address) {

address = "";

message = "please mailing address"

}

if语句的第二种形式引入了else从句，当expression的值是false值时执行else 逻辑

代码如下:

if (expression)

statement1

else

statement2

例如以下代码

代码如下:

if (n == 1)

console.log("1 new message");

else

console.log("you have" + n + "new message");

当if/else语句中，嵌套使用if语句时，必须注意确保else语句匹配正确的if语句。考虑如下代码：

代码如下:

i = j = [www.61k.com］1;

k = 2;

if (i == j)

if (j == k)

console.log("i equs k");

else

console.log("i dosent equal j"); //错误！！

这个实例中，内层的if语句构成了外层if语句所需要的子句。但是，if和else的匹配关系不清晰（只有缩进给了一点暗示）而且在这个例子里，缩进给出的暗示是错误的，因为javascript解释器是这么理解的。

代码如下:

if (i == j) {

if (j == k)

console.log("i equs k");

else

console.log("i dosent equal j");

}

和大多编程语言一样，javascript中的if、else匹配规则是，else总是和就近的if语句匹配，为了让个例子的可读性更强，更容易理解，更方便维护和调试，应当使用花括号

代码如下:

if (i == j) {

if (j == k) {

console.log("i equs k");

} else { //花括号使代码的结果更清晰

console.log("i dosent equal j");

}

}

许多程序员都将有if和else语句主体用花括号括起来的习惯（就像类似while循环这样的符合语句中一样），即使每条分支只有一条语句，但这样做能避免刚才的程序歧义问题。

ii.else if

if/else语句通过判断一个表达式的计算结果来选择两条分支中的一条。当代码中有许多条分支的时候应该怎么办呢？一种解决的办法是使用else if语句。else if并不是真正的javascript语句，它只不过是多条if / else语句连接在一起的写法。

代码如下:

if (n == 1) {

//执行代码块 1

} else if (n == 2) {

//执行代码块2

} else if (n == 3) {

//执行代码块3

} else {

//之前的条件都为false，则执行代码块4

}

这种代码没有什么特别之处，它由多条if语句组成，每条if语句的else的从句又包含另外一条if语句。可以用if语句的嵌套形式来完成语法上的等价代码，但与此相比，显然else if的写法更加清晰也更可取。

iii.switch

if语句在程序执行的过程中，创建一支分支，并且可以使用else if来处理多条分支。然后，当所有的分支都依赖同一个表达式的值时，else if并不是最佳的解决方案。在这种情况下，重复计算多条if语句中的表达式是非常浪费的做法。

switch语句适合处理这种情况。关键字switch之后紧跟着园括号括起来的一个表达式。随后是花括号括起来的代码块。

代码如下:

switch (expression) {

statements

}

然而switch语句完整的语法要比这更复杂一些。case之后是一个表达式和冒号，case和标记语很类似，只是这个标记语并没有名字。

它只和他后面的表达式关联在一起。当执行执行这条switch语句时，它首先计算expression的值，然后查找case子句的表达式是否和expression的值相同。（这里的相同是按照“===”运算符进行比较的），如果匹配case，它将会执行对应的代码。如果找不到匹配的case,它将会执行"default:"标签中的代码块。如果没有“default：”标签，switch将跳过所有的代码块。

switch语句是非常容易混淆的，用例子介绍会比较清晰一点，下面的switch语句和方才的if/else语句是等价的

代码如下:

switch (n) {

case 1: //如果n ===1从这里开始

//执行代码块1

break;

case 2:

//执行代码块2

break;

case 3:

//执行代码块3

break;

default:

//执行代码块4

break;

}

需要注意的是，每个case语句的结尾处都使用了关键字break。我们将后面介绍break语句，break语句可以使解释器跳出switch语句或循环语句。在switch中，case只是指明了要执行的代码起点，但没有指明终点。如果没有break语句，那么switch语句就从expression的值的匹配的case标签处代码开始执行，依次执行后续的语句，一直到整个switch代码块结束。当然，如果在函数中使用switch语句，可以使用return来替换break，return和break都用于终止switch语句，也会防止一个case语句执行完继续执行下一个case语句块。

下面的语句贴近实战，它根据值的类型将该值转换为字符串。

代码如下:

function convert(x) {

switch (typeof x) {

case 'number': //将数字转换为16进制

return x.toString(16);

case 'string':

return '"' + x + '"'; //返回两段带双引号的字符串。

default: //使用普通方法转换其它类型

return String(x);

}

}

console.log(convert(100255114)) //=>5f9c58a

注意，在上面的两个例子中，case关键字后跟随的是数字和字符串直接量，在实际中这是switch最常见的用法，但是ECMAScript标准允许每个关键字跟随任意的表达式。

switch语句首先计算switch 关键字后的表达式，然后按照从上到下的顺序计算每个case后的表达式，知道执行到case的表达式的值和switch的表达式的值相等时为止。由于对每个case的匹配操作实际上是“===”恒等运算符比较，而不是“==”，因此表达式和case的匹配并不会做任何类型转换。

每次执行switch语句的时候，并不是所有的case表达式都能执行到，因此，应当避免带有副作用的case表达式，比如函数调用的表达式和赋值表达式。最安全的做法就是在case表达式中使用常量表达式。

前面提到过，switch表达式与所有的case表达式都不匹配，则执行标记为“default：”的语句块，如果没有"default:"标签，则switch整个语句都跳过。在之前的例子中，“default：”标签都出现在switch末尾，位于所有case标签之后，当然这是最合理也是最常用的写法。实际上，“default:”标签可以放在switch语句内任何地方。

5.循环。

为了理解条件语句，可以将javascript中的代码想成一条条分支路径。循环语句（looping statement）就是程序路径的一个回路，可以让一部分代码重复执行。javascript中有四种循环语句：while、do/while、for、for/in下面几节会一次讲解他们。其中最常用的循环就是数组元素的遍历，（7.6会详细讨论这种循环和使用数组类定义的特殊循环方法。）

i.while

if语句是一种基本的控制语句，用来选择执行程序的分支语句。和if一样，while语句也是一个基本的循环语句，它的语法如下：

代码如下:

while (expression)

statement

在执行while语句之前，javascript解释器首先计算expression的值，如果它的值是假值，那么程序将跳过循环体中的逻辑statement转而执行程序中的下一条语句。如果它的值是真值，则执行循环体statement内的逻辑，然后再计算表达式expression的值，种循环会一直持续下去，知道expression的值为假值为止。换一种说法 就是表达式为expression是真值的时候则循环执行statement，注意，使用while(true)则会创建一个死循环。

通常来说，我们不想让javascript反复执行同一操作。在几乎每一次循环中，都会有一个或多个变量随着循环而迭代改变。正是由于改变了变量这些变量，因此每次循环执行的statement的操作也不尽相同，而且，如果改变变量在expression中用到，那么每次循环表达式的值也不同。这一点非常重要，负责初始值为真值的表达式永远是真值，循环也不会结束，下面的这个示例所示while循环输出0-9值。

代码如下:

var count = 0;

while (count < 10) {

console.log(count);

count++;

}

可以发现，在这个例子中，变量count的初始值为0，在循环的过程中，它的值每次都递增1，当循环执行了十次。表达式的值就编程了false，这时while就会结束，javascript解释器将执行程序下一条语句。大多循环都有一个像count这样的计数器变量。尽管计数器常用i j k这样的变量名，但如果想让代码的可读性更强，就应当使用更具体的语法名。

ii.do/while

do/while循环和while循环非常相似，只不过它是在循环的尾部而不是顶部检测循环表达式，这就意味这循环体至少执行一次。do/while循环的语法如下：

代码如下:

do

statement

while(expression);

do/while循环并不像while循环那么常用。这是因为在实践中想要循环至少执行一次的情况并不常见。下面是一个do/while循环的例子

代码如下:

function printArray(a) {

var len = a.length,

i = 0;

if (len == 0)

console.log("空数组");

else

do {

console.log(a[i]);

} while (++i < len);

}

printArray([1,5,2,6])

在do/while循环和普通while循环之间有两点语法方面的不同之处。首先，do循环要求必须使用关键字do来标识循环的开始，用while变标识循环的结尾并进入循环条件判断；其次，和while循环不同，do循环使用分号结尾的。如果while的循环体使用花括号括起来，则while循环也不使用分号结尾。

iii.for

for语句提供了一种比while更方便的循环语句控制结构。for语句对常用的循环模式做了一些简化。大部分的循环都具有特定的计数器变量。在循环开始之前要初始化这个变量，然后在每次循环之前检查下它的值。最后，计数器变量做自增操作，否则就在循环结束后、下一次判断前做修改。在这类循环中，计数器的三个关键操作是初始化、检测和更新。for语句就将这三部操作明确声明为循环语法的一部分，各自使用一个表达式来表示。for语句的语法如下：

代码如下:

for (initialize; test; increment)

statement

intialize、test、increment三个表达式之间使用分号分隔，他们负责初始化操作、循环条件判断和计数器变量的更新。将它们放在循环的第一行会更容易理解for循环正在做什么，而且也可防止忘记初始化或者递增计数器变量。

要解释for循环是怎么样工作的，最简单方法就是列出一个与之等价的while循环

代码如下:

initialize

while (test) {

statement

increment;

}

换句话说，initialize表达式只在循环 开始之前执行一次。初始化表达式应当具有副作用(通常是一条赋值语句)。javascript同样允许初始化表达式中带有var变量声明语句，这样的话就可以声明并初始化一个变量。每次循环之前会执行test表达式，并判断表达式的结果来决定是否执行循环体。每次循环之前会执行test表达式，并判断其结果是否来执行循环体，如果test结果为真值，则执行循环体中的statement。最后，执行increment表达式。同样为了有用起见，这里的increment表达式也必须有副作用。通常来讲，它不是一个赋值表达式就是一个由“++”、“--”运算符构成的表达式。

上文的while循环可以使用for循环来从写

代码如下:

for (var count = 0; count < 10; count++)

console.log(count)

当然，有些循环更加复杂，而且循环中一次迭代多个变量。在javascript，这种情况必须用到逗号运算符，它将初始化表达式和自增表达式合并入一个表达式中以用于for循环。

代码如下:

var i, j;

for (i = 0, j = 10; i < 10; i++, j--)

console.log(i * j);

到目前为止，在示例代码中的循环变量都是数字。当然是数字是最常用的，但不是必须的。下面这段代码就使用for循环来遍历表数据结果，并返回链表中最后一个对象（也就是第一个不包含next属性的对象）

代码如下:

function tail(o) { //返回链表的最后一个节点对象

for (; o.next; o = o.next) /*empty*/ //根据判断o.next是不是真值来执行遍历

return o;

}

需要注意的是，这段代码不包含initialize表达式，for循环中的那三个表达式中的人和一个都可以忽略，但两个分号必不可少。如果省略test表达式，那么将是一个死循环。同样和while(ture)类型，死循环的令一种写法是for(;;)。

iiii.for/in

for/in语句使用for关键字，但它和常规的for循环是不同的一类循环。for/in循环的语法如下

代码如下:

for (variable in object)

statement

variable通常是一个变量名，也可以是一个可以产生左值的表达式或者一个通过var语句声明的变量。总之是一个适用于赋值表达式左侧的值。object是一个表达式，这个表达式的计算结果是一个对象。同样，statement是一个语句或语句块，它构成了循环的主体。

使用for循环来遍历数组元素是非常简单的

代码如下:

var a = [1, 3, 5, "44"];

for (var i = 0; i < a.length; i++) //i代表了数组元素的索引

console.log(a[i]) //输出每个数组的元素

而for/in循环则是用来方便的遍历对象成员属性

代码如下:

for (var p in o) //将属性的名字赋值给变量p

console.log(o[p]); //输出每一个属性的值

在执行 for/in语句的过程中，javascript解释器首先计算object表达式。如果表达式为null或undefined，javascript解释器将跳过循环并执行后续的代码。如果表达式等于一个原始值，这个原始值将会转换为与之对于的包装对象（wapper object）(3.6节)。否则，expression本身已经是对象了。javascript会依次枚举对象的属性来执行循环。然而在每次循环之前，javascript都会计算variable表达式的值，并将属性名（一个字符串）赋值给它。

需要注意的是，只要for/in循环中，varibale的值可以当做赋值表达式的左值，它可以是任意表达式。每次循环都会计算这个表达式，也就是说每次循环它计算的值可能不同。例如，可以使用下面的这段代码将所有对象属性复制到一个数组中：

代码如下:

var o = {x: 1,y: 2,z: 3};

var a = [],i = 0;

for (a[i++] in o) /*empty*/;

document.write(a)//=> x,y,z

javascript数组只不过是一种特殊的对象，因此，for/in循环可以像枚举对象属性一样枚举数据索引。例如在上面的代码之后添加这段代码，就可以枚举数据索引0,1,2:

代码如下:

var o = {x: 1,y: 2,z: 3};

var a = [],i = 0;

for (a[i++] in o) /*empty*/;

document.write(a)//=> x,y,z将对象属性复制到一个数组中

for(i in a)

document.write(i) //=>枚举数据索引 0 1 2

其实，for/in循环并不会遍历对象的所有属性，只有“可枚举”（enumerable）的属性才会遍历到（参照6.7）。由于javascript语言核心所定义的内置方法就不是“可枚举的”。比如，所有的对象都有toString()，但for/in循环并不枚举toString()这个属性。除了内置的方法之外，还有很多内置对象的属性是不可枚举的（nonenumberable）。而代码中定义的所有属性和方法都是可枚举的（6.7节会讲到，但ECMAScript5中有特殊手段可以使属性变为不可枚举）。

对象可以继承其它对象的属性，那行继承自定义属性（6.2.ii）也可以使用for/in枚举出来。

如果for/in的循环体删除了还未枚举的属性，那么这个属性将不会再枚举。如果循环体定义了对象的 新属性，这些属性通常也不会枚举到（不过。javascript有些实现可以枚举那么些在循环体中增加的属性）。

属性枚举的顺序

ECMAScript规范并没有指定for/in循环按照何种顺序来枚举对象的属性。但实际上，主流的浏览器厂商javascript实现是按照属性定义的先后顺序来枚举简单对象的属性，先定义的属性先枚举。如果使用对象直接量的形式创建对象，则将按照直接量中属性的出现顺序枚举。（有一些网和javascript库是依赖这种枚举顺序的，而浏览器厂商大多不修改这个顺序），在下面的情况下，枚举顺序取决于具体的实现（并非交互）

1.对象继承了可枚举属性

2.对象具有整数数组索引的属性

3.使用delete删除了对象已有的属性

4.使用Object.defineProperty()或者类似的方法改变了对象属性

6.跳转

javascript中令一类语句是跳转语句（jump statement）。从语句理解，它可以使javascript执行从一个位置跳转到令一个位置。

break语句是跳转到循环或其他的语句结束。continue语句是终止本次循环的执行并开始下一次循环的执行。javascript中的语句可以命名或带有标签，break和continue可以标识目标循环或者其它语句标签。

return语句可以让解释器跳出函数体的执行。并提供本次调用的返回值。throw语句触发或者抛出一个异常，它是与try/catch/finally语句一同使用的，这些语句指定了处理异常代码逻辑。这是一种复杂的跳转语句，当抛出一个异常的时候，程序将跳至最近的闭合异常辰星，这个异常程序可以是在同一个函数中或者更高层的调用栈中。

接下来，描述每一种跳转语句

i.标签语句

语句是可以添加标签的，标签是由语句前的标识符和冒号组成：

identifier:statement

通过给语句定义标签，就可以在程序中任何地方通过标签名来引用这条语句。可以对多条语句定义标签，尽管只有给语句块定义标签时它才有更有用，比如循环语句或条件判断语句。通过给循环定义一个标签名，可以在循环体内部使用break和continue来退出循环或者直接挑战到下一个循环开始。break和continue是javascript中唯一可使用语句标签的语句（本章接下来会讲述）。下面的例子，其中while循环定义了一个标签，continue语句使用了这个标签：

代码如下:

mainloop: while (token != null) {

//忽略这里代码...

continue mainloop; //跳转到下一次循环

//忽略这里的代码...

}

这里做标签的indentifier必须是一个合法的javascript标识符，而不能是一个保留字。标签的命名空间和变量或函数的命名空间是不同的，因此可以使用同一个标识符作为语句标签和作为变量名或函数名。语句标签只在它所起作用的语句（当然可以在它的子句）内是有定义的。一个语句标签不能和它内部的语句标签重名，但在两个代码不相互嵌套的情况下是可以出现同名语句标签的。带有标签的语句还可以带有标签，也就是说，任何语句可以有很多个标签。

ii.break

单独使用break语句的作用是立即退出最内存的循环或switch语句。它的语法如下：

break;

由于它能够使循环和switch语句退出，因此这种形式的break只能出现在这类语句中才是合法的。

我们在switch语句的例子中已经见到果break语句。在循环中，无论出于什么原因，只要不想继续执行整个循环，就可以用break提前退出。当循环终止条件非常复杂时，要函数体内使用break语句实现这样些条件判断的做法要比直接在循环表达式中写出这个复杂的终止条件做法简单的多。

下面的例子中循环遍历整个数组元素来查找某个特定的值，当整个数组遍历完成后正常退出循环，如果找到 了需要查找的数组元素，则使用break语句退出循环：

代码如下:

for (var i = 0; i < a.length; i++) {

if (a[i] == target) break;

}

javascript中同样允许break关键字后跟随一个语句标签，（只有标识符，没有冒号）

break labelname;

当break和标签一块使用时，程序将跳转到这个标签所识别的语句块的结束，或者直接终止这个闭合语句块的执行。当没有任何闭合语句块指定break所用的标签，这时会产生一个语法错误。当使用这种形式的break语句时，带标签的语句不应该是循环或者switch语句，因为break语句可以“跳出”任何闭合的语句块。这里的语句可以是由花括号组起来的一组语句，使用同一个标签来识别一组语句。

break关键字和labelname之间不能换行。因为javascript可以给语句自动补全省略掉的分号，如果break关键字和标签之间有换行，javascript解释器会认为你在使用break不带标签的最简形式，因此会在break后补充分号.

当你希望通过break来跳出非就近的循环体或者switch语句时，就会用到带标签的break语句。下面是示例代码：

代码如下:

var matrix = getData(); //从某处获得一个二维数组

//将矩阵中所有元素进行求和

var sum = 0,

success = false;

//从签名处开始，以便在报错时推出程序。

compure_sum: if (matrix) {

for (var x = 0; x < matrix.length; x++) {

var row = matrix[x];

if (!row) break compure_sum;

for (var y = 0; y < row.length; y++) {

var cell = row[y];

if (isNaN(cell)) break compure_sum;

sum += cell;

}

}

success = true;

}

//break语句跳转至此

//如果success =false条件到达这里，说明我们给出的矩阵中有错误

//否则对矩阵中所有的元素进行求和

最后，需要注意的是，不管break语句带不带标签，它的控制权都无法越过函数的边界。比如：对于一条带标签的函数定义语句来说，不能通过函数内部通过这个标签来跳转到函数外部.

iii.continue语句

continue语句和break语句非常类似，但它不退出循环，而是转而执行下一次循环。continue语句的语法和break的语句语法一样简单

continue;

continue语句会也会带有标签

continue lebname;

不管continue语句带不带标签，它只能在循环体使用，在其它地方使用将会 报语法错误。

当执行到continue语句的时候，当前的循环逻辑就终止了，随即执行下一次循环，在不同类型的循环中，continue的行为也有区别

1. 在while循环中，在循环开始处指定expression会重复检测，如果检测结果为true，循环体会从头执行。

2. 在do/while循环中，程序的执行至今跳转到循环的结尾处，这时会重新判断循环条件，之后才会继续下一次循环。

3. 在for循环中，首先会计算自增表达式，然后再检测test表达式，用以判断是否执行循环体。

4. 在for/in循环中，循环开始遍历下一个属性名，这个属性名赋给了指定的变量。

需要注意continue语句在while和for循环中的区别，while循环直接进入下一轮的循环条件判断，但for循环首先计算器increment表达式，然后判断循环条件。之前的章节讨论了和while循环“等价”的for循环行为。但由于continue在这两种循环中行为表现不同，因此使用while循环不可能完美的模拟等价的for循环。

下面这段代码展示了不带标签的continue语句，产生一个错误的时候跳过当前循环的后续逻辑

代码如下:

for (i = 0; i < data.length; i++) {

if (!data[i]) continue; //不能处理undefined数据

total += data[i];

}

和break语句类似，带标签的continue语句可以用在嵌套的循环中，用以跳出层次嵌套的循环体逻辑。同样和break语句类似，在continue语句和labname之间不能有换行。

iiii.return

回想一下，函数调用的一种表达式，而且所有的表达式都有值。函数中的return语句即是指函数调用后的返回值。这里是return语句的语法：

return expression;

return语句只能在函数体内出现，如果不是的话会报语法错误。当执行到return语句的时候，函数终止执行，并返回expression的值给调用程序。例如：

代码如下:

function square(x) {return x * x} //一个包含return的语句函数

square(4) //执行为16

如果没有return语句，则函数调用仅依次执行函数体内的每一条语句直到函数结束，最后返回调用程序。这种情况下，调用表达式的结果是undefined。return语句经常作为函数内最后的一条语句出现，但并不是说一定一定要放在函数的最后，即使在执行return语句的时候还有很多代码没有执行到，这时候函数也还返回调用程序。

return语句可以单独使用而不必带有expression，这样的话函数也会想调用程序返回undefined.例如：

代码如下:

//如果参数是null或者undefined则立即返回

if (!o) return;

//其它逻辑

由于javascript可以自动插入分号，因此，return关键字和它后面的表达式之间不能有换行。

iiiii.throw语句

所谓异常（excepion）是当发生了某种异常情况或错误时产生的一个信号。抛出异常，就是用信号通知发生了错误或异常状况。捕获异常是指处理这个信号，抛出异常，就是用信号通知发生了错误或异常状况。捕获异常是指处理这个信号，即采取必要的手段从异常中汇丰。在javascript中，当产生运行时错误或者程序使用throw语句时就会显式的抛出异常。使用try/catch/finally语句可以捕获异常，下一节会对它作详细介绍。

throw语句的语法如下：

throw expression

expression的值可以是任意类型的。可以抛出一个代表错误码的数组，或者包含可错误消息的字符串。当javascript解释器抛出异常的时候，通常采用Eeeor类型或其子类型，当然也可以使用它们。一个error对象有一个那么熟悉表示错误类型，一个message属性用来传递构造函数的字符串（参照第三部分的Error类），在下面的例子中，当使用非法参数调用函数时就抛出一个Error对象：

代码如下:

function fa(x) {

//如果输入的参数是非法的，则抛出一个异常

if (x < 0) throw new Error("x不能是负数。");

//否则计算出一个值，正常地返回它

for (var f = 1; x > 1; f *= x, x--) /*empty*/;

return f;

}

当抛出异常时，javascript解释器会立即停止当前正在执行的逻辑，并跳转至就近的异常处理程序。异常处理程序用try/catch/finally语句的catch从句编写的。如果抛出的异常没有一条关联catch从句 ，解释器会检测更高层的闭合代码块，看它是否关联相关的异常处理程序。以此类推 ，直到扎到一个异常处理的程序为止。

如果抛出的异常函数没有处理它的try/catch/finally语句，异常将向上传播到调用该函数的代码。这样的话，异常就会沿着javascript方法的词法结构和调用栈向上传播。如果没有找到任何异常处理的程序，javascript将吧异常当成程序错误来处理，并报告给用户。

iiiiii.try/catch/finally语句

try/catch/finally语句是javascript的异常处理机制。其中try从句定义了需要处理的异常所在代码块。catch语句跟随在try从句之后，当try块从某处发送了异常时，调用了catch内的代码逻辑。catch从句跟随finnlly块，后者防置了清理代码，不管try块中是否产生了异常，finnally块内的逻辑总会执行。尽管catch和finally都是可选的，但try从句只杀二者之一与组成完整的语句。try、catch和finally语句块都需要花括号括起来，这里的花括号是必须的。即使从句中只有一条语句也不能省略花括号。

下面的代码说明了try/catch/finlly的语法和使用目的：

代码如下:

try{

//通常来讲，这里的代码会从头执行到尾而不会产生任何问题，

//但有时会抛出一个异常，要么是由throw语句直接抛出异常

//要么通过调用一个方法间接抛出异常

}

catch(e){

//当且仅当try抛出了异常，才会执行这里的代码

//这里可以通过局部变量e来获得对Error对象或者抛出的其它值的引用

//这里的代码可以基于某种原因处理这个异常 ，也可以忽略这个异常。

//还可以通过throw语句重新抛出异常

}

finally{

//不管try语句块是否抛出看异常，这里的逻辑总会执行，终止try的语句块方式有：

//1）正常终止，执行完语句块的最后一条语句

//2）通过break，continue或return语句终止

//3）抛出一个异常，异常被catch从句捕获

//4）抛出一个异常，异常未被捕获，继续向上传播

}

我们注意到，关键字catch后跟随了一对圆括号，圆括号内是一个标识符。这个标识符和函数参很像。当捕获一个异常时，把这个异常相关的值（比如Error对象）赋值给这个参数。和普通的变量不同，这条catch子句中的标识符具有块级作用域，它只在catch语句块 内有定义。

这里有一个关于try/catch语句更实际的例子，这里使用了前面章节中提到factorial()方法，并使用客户端javascript方法prompt()和alert()来输入和输出

代码如下:

try {

//要求用户输入一个数字

var n = Number(prompt("请输入一个正整数", ""));

//假设输入是合法的，计算这个阶乘

var f = factorial(n);

//显示结果

alert(n + "!=" + f);

} catch (ex) {

//如果输入不合法，将执行这里的逻辑

document.write(ex); //告诉用户发送了什么。

}

这里的try/catch语句并不包含finally从句。尽管finally不像catch那样经常使用，但有时候它还是非常有用。然而，我们需要更详尽的解释它的行为。不管try语句块中的代码执行完成了多少，只要try语句中有一部分代码执行了，finally从句就会执行。它通常在try从句的代码后用于清理工作。

关注下面这个例子

代码如下:

try {

print("Outer try running..");

try {

print("Nested try running...");

throw "an error";

} catch (e) {

print("Nested catch caught " + e);

throw e + " re-thrown";

} finally {

print("Nested finally is running...");

}

} catch (e) {

print("Outer catch caught " + e);

} finally {

print("Outer finally running");

}

// Windows Script Host 作出该修改从而得出 WScript.Echo(s)

function print(s) {

document.write(s);

}

输出：

代码如下:

Outer try running..

Nested try running...

Nested catch caught an error

Nested finally is running...

Outer catch caught an error re-thrown

Outer finally running

7.其它语句类型。

本节讨论剩余的三种javascript语句：width，debugger和use strict

i.with语句

3.10讨论了作用域链（scope chain），一个可以按序检索的对象列表，通过它可以进行变量名的解析。width语句可以用来临时扩展作用域链：它具体有如下语法：

with (object)

statement

这条语句将object添加到作用域链头部，然后执行statement，最后把作用域链恢复到原始状态。

在严格模式下（5.7.iii）是禁止使用width的，在非严格模式下也是不推荐使用width语句的，尽可能的避免使用width语句。那些使用width语句的javascript非常难优化，而且比没有使用width的语句，它运行速度更慢。

在对象嵌套层次很深的时候，常会使用with语句来简化代码的编写。例如客户端javascript中，可能使用下面的这种表达式来访问表单的一个html元素

document.forms[0].address.value

如果这段代码多次出现，则可以使用with将form对象添加至作用域链的顶层。

代码如下:

with(document.forms[0]){

//直接访问表单元素

name.value="";

address.value="";

email.value ="";

}

这种方法简化了大量的输入，不用再为每个变量添加document.forms[0]前缀。这个临时对象挂载在作用域链上，当javascript需要解析诸如address标识符时，就会在这个对象中查找。当然，不使用with的语句代码可以写成这样。

代码如下:

var f = document.forms[0];

f.name.value = "";

f.adress.value = "";

f.email.value = "";

不要忘记，只有在查找标识符的时候才能用到作用域链，创建新的变量时候不使用它，看一下下面的代码：

代码如下:

with(o) x = 1;

如果对象o有一个属性x，那么这行代码给这个属性赋值1。如果o没有定义属性x，这段代码和不使用with的代码x=1是一模一样的。它给一个局部变量或者全局变量x赋值，或者创建全局对象的一个新属性。with语句提供了一种读取o属性的快捷方法，但并不会创建o的属性。

ii.debugger语句

debugger语句通常什么也不做。然而，在调试程序可用并运行的时候，javascript解释器将会（非必须）以调试模式运行。实际上，这条语句产生一个断点（breakpoint），javascript代码执行会停止在断点的位置，这时可用使用调速器输出变量的值，检查调用栈等。

例如加上调用函数f()的时候使用了未定义的参数，因此f()抛出一个异常，但无法定位到到底哪里出了异常。为了有助于调试这个问题，需要修改f()：

代码如下:

function f(o){

if (o === undefined) debugger; //这段代码用来临时调试

console.log(1) //函数的其它部分

}

f();

这时候，当调用f()没有传入参数，程序将停止执行，这时候通过调用调速器检测调用栈并找出错误的原因。

在ECMAScirpt5中，debugger语句已经正式加入到专门语言里，但在很长的一段时间里，主浏览器的厂商已经将其实现了。注意，可用的调速器是远远不够的，debugger语句不会启动调试器。但如果调试器已经在运行，这条语句才会正在产生断点。例如，使用Firefox插件firebug，首先启动firebug，这样debugger语句才能工作。

iii.“use strict”

“use strict”是ECMASCript5引入的一条指令。指令不是语句（但非常接近于语句），“use strict”和普通语句之前有两个重要区别：

1.它不包含任何语言的关键字，指令仅仅是一个包含一个特殊字符串直接量的表达式（可以是使用单引号也可以是双引号）。

2.它只能出现在脚本代码的开始或者函数体的开始、任何实体语句之前。但它不必一定出现在脚本的首行或者函数体内的首行。因为“use strict”指令之前之后或之前都可能有其它字符串直接量的表达式语句，并且javascript的具体实现可能将它们解析为解释器自有的指令。在脚本或者函数体内第一条常规语句之后，字符串直接量表达式语句只当做普通的表达式语句对待，它们不做指令解析，它们也没有任何副作用。

使用“use strict”指令的目的是说明（脚本或函数中）后续代码解析为严格代码(strict code)。如果顶层（不在任何函数内）代码使用了“use strict”指令，那么它们就是严格代码。如果函数体定义处的代码是严格代码或者函数体使用了“use strict”指令，那么函数体的代码也是严格代码。如果eval()调用所处的代码是严格代码或者eval()要执行的字符串使用了“scrict code”指令，则eval()内的代码是严格代码。

严格代码以严格模式执行。ECMAScript5中的严格模式是该语言的一个受限的子集。它修正了语言的重要缺陷，并提供健壮的差错功能和增强安全机制。严格模式和非严格模式区别如下（前三条尤其重要）

•严格模式中禁止使用with语句

•严格模式中，所有的变量要先声明，如果给一个未声明的变量、函数、函数参数、catch从句参数或全局的对象的属性赋值。就会抛出一个引用错误异常（在非严格模式中，这种隐式声明全局变量的方法是给全局变量新添加一个新属性）

•严格模式中，调用的函数（不是方法）中的一个this值是undefined。（在非严格模式中，调用的函数中的this值总是全局变量）。可以利用这种特性来判断javascript实现是否支持严格模式。

代码如下:

var hasStrictMode = (function() {

"use strict";

return this === undefined

}());

•同样，在严格模式中，当通过call()和apply()来调用函数时，其中的this值就是通过call()或apply()传第一个参数（在非严格模式中，null和undefined值被全局对象转换为对象的非对象值锁代替）

•在严格模式中，给只读属性赋值和给不可扩展的对象创建成员都将抛出一个类型错误异常（在非严格模式中，这些操作只是简单的操作失败，不会报错）。

•在严格模式中，传入eval()代码不能再调用辰星所在的上下文中声明变量或定义函数，在非严格模式中是可以这样做的。相反，变量和函数的定义是在eval()创建的作用域中，这个作用域在eval()返回时就弃用了。

•在严格模式中，函数里的arguments对象拥有传入函数值的静态副本。在非严格模式中，agreements对象具有“魔术般”的行为，arguments里的数组元素和函数都指向同一个值的引用。

•在严格模式中，当delete运算符后面跟随非法的标识符（比如变量、函数、函数参数时）将会抛出一个语法错误，（在非严格模式下，这种delete什么也没做，并返回false）

•在严格模式中，在一对象直接量中定义两个或多个同名属性将产生一个语法错误（非严格模式下不会报错）

•在严格模式下，不允许八进制整数直接量。（以0为前缀，而不是0x为前缀）在非严格模式中是允许直接八进制直接量的

•在严格模式下，标识符eval和arguments当做关键字，他们的值是不能更改的。不能给这些标识符赋值，也不能把它们声望为变量，用做函数名，用做函数参数或用做catch块的标识符。

•在严格模式中限制了对调用栈的检测能力，在严格的模式的函数中，arguments，caller和arguments.callee都会抛出一个类型错误异常。严格模式的函数同样具有caller和arguments属性，当访问这两个属性时抛出类型错误异常。

8.javascript语句小结：

javascript语句语法：

语句语法用途

breakbreak[label];退出最内侧循环或者退出switch语句，又或退出label指定的语句

casecase expression：在switch语句标记一条语句

continuecontinue [label];重新开始最内层的循环或从新开始label指定的循环

debuggerdebugger;断点器调试

defaultdefault;在switch标记默认语句

do/whiledo statement while(expression);while循环的一种替代形式

empty;什么都不做

forfor(init;test;incr)statement一种简写的循环

for/infor(var in object)statement遍历一个对象属性

functionfunction name([param[],...]){body}声明一个函数

if/elseif (expr)statement1[else statement2]执行statement1或者statement2

labellabel:statement给statement指定一个名字：label

returnreturn [expression];从函数返回一个值

switchswitch(expression){statements}用case或者“default：”语句标记多个分支语句

throwthrow expression抛出异常

trytry {statements}

[catch {hander satements}]

[finally {cleanup satements}]捕获异常

use strict"use strict"对脚本和函数使用严格模式

varavr name=[=expr][,...]声明并初始化一个或多个变量

whilewhile (expression) statement基本的循环结构

withwith(object) statement扩展作用域链（不赞成使用）

三 : 读于丹《论语心得》有感

近日拜读了于丹的《论语心得》后，感触颇深……

我想《论语》给予我们现代人的意义就在于让那种古典的精神力量在现代的规则之下圆润地融合成一种有效的成分，让我们的生命在智慧光芒的照耀下，让我们每个人真正建立起有效率、有价值的人生，无愧于自己的一生。

《论语心得》中共讲述了七道，但我印象最深的就是“天地人之道”。

天地人之道是《论语心得》中的第一道，读这一道时，我的感触也是最大的。

我们现在常说，天时地利人和是国家兴隆、事业成功的基础。但人的力量如此强大的原因，就在于把天之大、地之厚的精华融入人的内心，使天地人达到完美结合的程度，结成一个整体，所以，只有当天地之气凝聚在一个人的内心的时候，他的强大，无坚不摧。天人合一就是人在自然中的和谐，就是大地上万物和谐而快乐的共同成长，仅此简单而已。读到这里，我想，在当今社会，竞争如此激烈，我们应该如何为人呢？只要你的胸怀无限大，许多事情就小了，原来如此，就是“忠恕”二字啊！简单的说，就是要做好自己，同时要想到别人；拓展一点说，“恕”字就是讲你不要强人所难，不要给别人造成伤害。言外之意是假如他人给你造成了伤害，你也应该宽容。但是，真正做到宽容，又谈何容易呢？有很多时候，一件事情已经过去了，而我们还老是在那(www.61k.com]儿想，这么可恶的事，我怎么能原谅它呢？然后就在一次又一次的自我咀嚼中，一次又一次再受伤害。这就是孔子告诉我们的，该放下时且放下，你宽容了别人，其实是给自己留下了一片海阔天空。《论语》告诉我们的，不仅遇事要拿得起放得下，还应该尽自己的能力去帮助那些需要帮助的人，所谓“予人玫瑰，手有余香”，给予比获取更能使我们的心中充满幸福感。

关爱别人，就是仁；了解别人，就是智，就这么简单。那么，怎样做一个有仁爱之心的人呢？孔子说：“己欲立而立人，己欲达而达人。能近取譬，可谓仁之方也已。”你自己想要有所树立，马上就想到也要让别人有所树立；你自己想要实现理想马上也要想到帮助别人实现理想。能够从身边小事做起，推己及人，这就叫“仁义”。

读完这一道，联想起生活中的自己，不禁羞愧万分。现实生活中的自己自私、蛮横、无理、霸道，这跟书中相差了多远啊！我仔细的考虑了，我以后一定要做到宽容、关心爱护他人等。这样，自己的人生不是才会更完美吗？

我想圣贤的意义就在于，他以简约的语言道出人生大道，而后世的子孙或蒙昧地，或自觉地，或痛楚地，或欢欣地，一一去实践，从而形成以个民族的精神。

赵普曾说：“半部《论语》治天下，”而我此刻只是略知皮毛而已，但我的心灵却迈上了一个新台阶……

贵州省六盘水市六枝特区第二中学初三：黄春喜

四 : 书评读兰曦亮《随心所语》有感

我是在《中国孟津网》获悉兰曦亮先生所著《随心所语》书讯的，以前我在《教育探索》上读过兰先生的文章，出于对先生才学的敬重，便试着在网上留言，希望能劳惠赠。没想到这么快，作者就托我镇中心校的领导捎来了新著，并亲题了赠言，真是令人万分感动。此书装帧精美，一看见就顿生爱意，读了几篇后，就再也舍不得放下，若问我当时阅读时的感受，我想借用林黛玉小姐《咏菊》中的“口角噙香”一词来形容，是再合适不过了。下面，我就给自己布置一篇作文——读兰曦亮《随心所语》有感。

文如其人，言为心声。了解、判断一个人，最好是读他的书，一个人就是一本书，一本书就是一个人。兰先生的《随心所语》，大都是亲历亲叙，有感而发，流露出的个人信息大抵是：年逾花甲，上世纪七十年代初上高中，有回乡务农的生活经历，当过民师，后考上豫西师范，当教师，调入教育局当机关干部。由于我们年纪相仿，青年时代经历相似，所记往事，如感同身受，历历在目，故常常引起感情上的共鸣，尤其是记人叙事的《尊师篇》《敬贤篇》《励志篇》《游历篇》。从作品中，我看得出，作者对中学时代那种火热的学习、劳动生活充满了无限的怀念之情，对一代伟人毛泽东无比的崇敬和景仰，作者崇仰真理，热爱生活，崇尚人世间一切真善美的事物，写焦裕禄，激情澎湃，热情讴歌；记贤内助，情与事并联，情与理交融。对家乡，对邻里，对师长，对同学，对亲人，字里行间无不蕴含着一种浓浓的情、深深的爱，我爱先生的文章，喜爱他那清新隽永、质朴简洁的语言、灵动流畅富有个人风格的文字，更看重文字背后作者深刻的思想、大爱的胸襟以及对现实社会深切的关注和思考。

当今社会，喧嚣浮躁，物欲横流，很多人是口袋富有，脑袋贫乏，然而，兰曦亮先生却能经得起诱惑，耐得住寂寞，长年读书，勤奋治学，笔耕不辍，以自己的知识、才情、品格和气质，倾诉深情，“随心所语”，读之如浴春风般的温暖，如品高山流水般的通灵，由此，我想起了我县教育专家陈志强的《异域见闻》，想起了我十分敬爱的孟津知名作家李凯斌先生的《北邙绿韵》，熟人的、文笔好的作品，他的语言就像是流在你心田里一道清亮的甘泉，向你深情倾诉着自己的过去，自己的人生。俗话说，人过留名，雁过留声。我想一个人，来世一趟，若想留点生命的痕迹，还是要当效兰先生和以上两作家，把有价值的作品出版发行，为我人杰地灵的河洛大地，为我文化底蕴深厚的孟津名县，留下一个文化人的微名。

五 : 读于丹论语心得之心得

论语》，我在中学时候就曾通读过了，那时候受阶级斗争为纲的影响，对孔夫子的世界观和理论抱着一种审视的态度，有些地方甚至用讥笑的眼光看。如孔夫子的“自行束樇而上，吾未尝不诲焉”,觉得迂得可以。用这样的心情读书，得到的收获可想而知。今年初丁检在会上推荐读《于丹论语心得》，于是在网上下载了认真看，看了后，有了严肃的思考和心得。于丹是北京大学的一位女教授，她以读《论语》为引领，把高深的道理寓于生动通俗的语言中，抓住了论语的核心要义，剖析并展开来，结合我们当前的社会，很有说服力和感染力。

对《论语》重新认识的体会主要有三方面。一是把握自我，不为外界表象所迷惑。 忠孝礼仪是《论语》对“士人”的基本标准和要求。以前的人一听到“忠孝”，立刻肃然起敬，乃至于“流涕”。但文革后我们根据学到的理论对这些看法有了变化，对“忠”，认为是愚忠，封建礼教的产物，“孝”是封建社会家长专制的工具，“礼”是伪善。于是，我们没有了文化行为标准，没有判断是非的镜子，除了法律因素外，我们的工作关系、家庭关系、同事关系、上下级关系、社会关系，如何处理好？马克思主义上没有，法律上除了基本准则外也没有。于是，种种千奇百怪的事情出现在我们身边。有些掌握了机密的国家工作人员通敌，出卖国家机密，背叛了党和人民；有的不孝敬父母，欺诈老人的钱财；生意场上，有的不讲诚信，要么货到不拿款，要么款到不发货；官场上，买官买官，拉帮结派，做一些昧着良心的事情，乃至贪污受贿。搞得来使人们对什么事情该做，什么事情不该做；什么事情是好的，什么事情是坏的，都不能作出正确的判断了。其实，《论语》早就把这问题解决了，只是我们以前没有注意到而已，处理好各项关系，就是要讲求“忠孝”。对党，对国家，对事业，对领导，要“忠”；对朋友，对工作，要“诚”，对父母，对老人要“孝”，对子女，对孩子要“悌”，对他人，乃至敌人，要有“礼”。把忠深深植入到心中，不是说说了事，有时候要用生命来解读，有时候要用几十年的苦难解读。西汉时苏武出使匈奴，单于爱其才，要其归顺，苏武拒绝。单于为了瓦解苏武意志，将苏武发到北海牧羊，一去就是十九年。苏武“渴饮雪，饥吞毡”，没有忘记自己的身份和使命，始终将汉武帝赐的使节拿在手上。十九年后，单于儿子即位，突发善心将苏武放归汉朝。汉武帝开始听说的是苏武已经投降匈奴，大为震怒。后来得知真相后，非常感动，动员了全京城军民出城迎接苏武。苏武仍拿着当年汉武帝赐的使节，衣着褴褛，仪态从容，他的赤胆忠心感动了所有的人。

二是 安贫乐道，淡薄名利思想。我们工资收入不高是多年的事实，我们都已经“习惯了”。但有的人却很不适应，有的甚至口出狂言。所谓“靠山吃山，靠树吃树”，“撑死胆大的，饿死胆小的”、“马无夜草不肥，人无横财不富”等等，言论既已如此，行为上必然出现偏差。所以看见一些“勾兑”现象，也就不奇怪了。但任何事情都有个度，超越了度，事物本质就发生了变化。“法律允许范围内”、“违纪”、“违法”悬殊往往在一线间，有的人偏就喜欢在这钢丝上走，思想根源上还是不能正确看待“安贫乐道”思想。每个人的一生中都难免有缺憾和不如意，也许我们无力改变这个事实，而我们可以改变的是看待这些事情的态度。《论语》的精华之一，就是告诉我们，如何用平和的心态来对待生活中的缺憾与苦难。我认为人要真正获得自在、宁静、最要紧的就是安贫乐道。孔子的学生颜回家境贫寒，住漏雨破屋，三天两头缺粮，“瓦灶绳床”，都还朝不保夕，还得经常依靠子贡的周济。孔子称赞颜回能在贫困中“人不堪其忧，回也不改其乐”。清朝有个清官任满回家时候，因为没有收受贿赂，觉得不好意思，在行李里装了很多石头，以示“宦囊丰富”，居然还被人举报，上面居然还派员“调查”，结果查出了一个清官。笑话之余，这个清官清政不留名，体现了安贫乐道思想。我们不排斥富裕，我们不崇尚贫穷，但如果在富贵中，要学子贡一样，要同情、周济贫困的人，并且不要名利。如果在贫困中，不能怨天尤人，要有安贫乐道精神。

三是爱人犹如爱己，敬人犹如敬己。 孔子很重视日常生活中的礼节。当做官的人，穿丧服的人，还有盲人路过他面前，他一定要站起来；如果他要从这些人面前经过，他就小步快走，这表示对这些人的一种尊敬。现代人一般都希望能得到他人的关爱、得到他人的尊敬。但自己付出了什么呢？却很少去思考。有的人挺起个冬瓜一样的大肚，唯我至上、目空一切，任何人都不在眼里；有的人“出口成脏”，开口就是粗话脏话，不管他人接受不接受；有的人不讲社会公德，随地乱丢脏物，公共场所旁若无人地喧哗、吸烟、吐痰； “爱人者人恒爱之，敬人者人恒敬之”，自己心中没有别人，很难得到别人的尊重。特别是生活中本来有诸多不如意的人，忧患多于欢乐的人，更不容易做到自尊、自爱，并对他人的付出。美国原总统里根说他在中国的一次经历是他一生中最受教育的事。里根访华到西安，当然是微服私访式。看见街边有个小女孩卖甘蔗，里根突然想买根甘蔗来吃，一根甘蔗一毛钱，里根没零钱，拿出一张10元“大团结”付钱，小姑娘找不起，涨红了脸。那时候中国还没有开始改革开放，人们生活水平不高，对卖甘蔗的来说，10元相当于巨款了。里根也知道这个事实，于是以一种“周济”的心情，“美国式的宽容”，摇手说不要了，然后怀着一种对第三世界国家作了贡献的满足离开。没料到一会儿小姑娘叫喊着，迅速追上来，把该补给的钱补给里根。里根后来说，他感到了自己的感情贫乏和空虚，他以一种施舍的心去施舍，反而到是自尊自强的中国小女孩对他进行了施舍。使他先前的施舍成了一种不尊重他人，不礼貌的行为。里根之所以受人尊敬，除了总统因素外，他以尊重他人心做事，尊重的对象不光是经济巨头、国家首脑，对一个普通老百姓也注意到细节，这些都值得我们去学习。因此我们任何时候都要保持一颗诚敬的心，真心赞扬他人，真诚对待他人，真心接受他人的好意。对待不友好的人，要“以德报恩，以直抱怨”。用《论语》精神指导我们的行为。

读于丹论语心得之心得_于丹论语心得下载

看于丹论语心得，重新认真领悟古老理论精华，心里产生许多共鸣。在多年忽视文化、漠视文化之后，终于发现文化的重要性；在感受了人生百态、生活艰辛之后，更深刻感受到文化的精神，文化的魅力，文化调节社会行为的作用。但要真正达到论语的境界并不容易，还要靠自己继续深入学习，勇敢实践。以前只要一谈论语，或者引用一句古话，马上有人说“宝气”，更不用说身体力行了。“君子敏于行而讷于言”，我们应该重新解读论语，重新认识论语，让论语成为一面镜子，时时对照自己的行为

本文标题：读于丹论语心得有感-读于丹的书 有感
本文地址： http://www.61k.com/1137718.html