NO END FOR LEARNING

Writing blog if you feel tired | 学海无涯 苦写博客

JavaScript中你需要了解的基本知识(一)

| Comments

对于初学JavaScript的人很容易去关注如何快速使用它,而忘记学好一门语言,应该首先掌握的基本知识,我就是这样。但是基础知识才是真正掌握一门语言最关键的部分,特别是JavaScript这个看上去好像和C++、Java相同,但实际上完全不是一回事的语言。

作用域

在编程语言中,作用域控制着变量与参数的可见性及生命周期,是一个很基本的问题。

但是和类C语言不同,JavaScript没有块级别作用域。

所谓块级作用域,即在一个代码块中定义的所有变量在代码块的外部都是不可见的,定义在代码块中的变量在代码块执行结束后会被释放掉。

Java中print方法中的a肯定是未定义的变量,编译器会标红,因为a是if块中的局部变量。

1
2
3
4
5
6
public static void main(String args[]) {
  if(true){
      int a = 0;
  }
  System.out.print(a);
}

但是在JavaScript中,a变量就可以被访问。

1
2
3
4
if(true){
  var a = 1;
}
console.log(a);

JavaScript是由函数限定变量的作用域,意味着定义在函数中的参数和变量在函数外部是不可见的,而函数内可以访问函数外部的变量。

1
2
3
4
5
6
var carName = 'byd';

function visitName() {
  console.log(carName);
}
visitName();

JavaScript允许延迟声明变量,但是对于JavaScript缺少块级别作用域,所以这是个悲剧,推荐的做法是在函数的开头声明所有需要使用的变量。

词法作用域和作用域链

JavaScript是一种解释性语言。在解释过程中,JavaScript引擎是严格按照作用域来执行的。JavaScript语法采用的是词法作用域,也就是说JavaScript的变量和函数作用域是在定义时决定的,而不是执行时决定的,由于词法作用域决定于代码结构,所以JavaScript解释器只需要通过静态分析就能确定每个变量、函数的作用域,这种作用域也称为静态作用域。

JavaScript解释器通过作用域链把多个嵌套的作用域串联在一起,并借助这个链条帮助JavaScript解释器检索变量的值。这个作用域链相当于一个索引表,通过编号来存储它们的嵌套关系。当JavaScript解释器检索变量的值,会按照这个索引编号进行快速查找,直到找到全局对象为止,如果没有找到值,则传递一个undefined。

看下面这个比较经典的例子

1
2
3
4
5
6
7
8
var carName = 'byd';

function visitName() {
  console.log(carName);
    var carName = 'bmw';
    console.log(carName);
}
visitName();

第一个输出结果:undefined

第二个输出结果:bmw

原因就是它的作用域由静态分析决定,他在visitName中找到carName。所以当遇到第一个console.log(carName),它并没有到外层的作用域去寻找。

全局变量和全局对象

JavaScript中,在所有函数之外声明的变量为全局变量,而在函数内部声明的变量(通过var关键字)为局部变量。

全局变量在所有的作用域中都是可见的。这样一种特殊的变量,就算不是在JavaScript语言中,也是不受欢迎的。

但是在JavaScript中实在太容易就创建一个全局变量,所以要格外小心。

JavaScript中定义全局变量的方式有三种:

1.在任何函数之外定义一个var语句变量。

2.直接给全局对象添加一个属性,全局对象是全局变量和全局函数的容器。

3.没有使用var关键字声明的变量,它在任何作用域中被使用的时候,都会被当做全局变量(与上面介绍的作用域链相关)。

关于第3种情况:JavaScript有一种特性叫做隐式全局变量,不管一个变量有没有用过,JavaScript解释器反向遍历作用域链来查找该变量的var声明,如果没有找到,解释器则假定该变量是全局变量,如果该变量用于了赋值操作的话,之前如果不存在的话,解释器则会自动创建它。

上面提到了一个全局对象的概念,在Web浏览器中,全局对象的名称是windows。全局对象是预定义的对象,作为JavaScript的全局函数和全局属性的占位符。通过使用全局对象,可以访问所有其他所有预定义的对象(例如,document(浏览器容器下))、函数(例如,parseInt())和属性。

看下面这个例子,通过三种方式创建全局变量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
var carName = 'byd';

function defineGlobalVariable() {
    window.carPrice = 90000;
    carCount = 2;
}
defineGlobalVariable();

function print() {
    console.log(carName);
    console.log(carPrice);
    console.log(carCount);
}

print();

对象

在JavaScript中,只有对象,一切都是对象。

首先要明确一点,JavaScript是面向对象的语言,但是它与C++、Java的面向对象不同。JavaScript不是基于类的面向对象,而是基于原型的面向对象,在JavaScript中没有类的概念。

在基于类的面向对象中,要创建对象,首先要有类。类是对象的抽象描述。类为它们的实例定义了严格不变的结构(属性)和严格不变的行为(方法)。

在基于原型的面向对象中,是动态可变的对象。他们可以很容易地改变(添加,删除,修改)自己的属性。在对对象的属性赋值的时候,如果某些属性不存在,则创建它并且将赋值与它进行初始化,如果它存在,就更新它。

JavaScript里的对象是无类型的,它是属性的容器,是一系列属性的集合,而每一个属性包含名字和值(键值对)。(是不是有点像Map)

属性的名字和属性的值没有限制,它可以是Number、String、Boolean或者另一个对象或者一个函数。

为什么属性可以是一个函数。原因是在JavaScript中,函数也是对象。

JavaScripty原生对象

Object|Number|String|Boolean|Date|Array|RegExp

Function

1
new Function ([arg1[, arg2[, ... argN]],] functionBody)

在JavaScript中,一个函数实际上是一个Function对象。

1
2
var fn = new Function("arg1", "arg2", "return arg1 * arg2;");
alert(fn(2, 3));//6

对象字面量

在JavaScript中创建对象有三种方式:

1.通过Object创建

2.通过自定义对象构造器创建

3.对象字面量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
var audiCar = new Object();
audiCar.name = 'audi';
console.log(audiCar.name);

function bmwCar(name) {
    this.name = name;
}
var myBmwCar = new bmwCar('bmw');
console.log(myBmwCar.name);

//字面量模式
var bydCar = {
    name: 'byd'
};
console.log(bydCar.name);

从上面的代码可以看出,字面量写法的一个明显优势是,它的代码更少。

JavaScript中的字面量模式更加简洁、有表现力,而且在定义对象时不容易出错。

如果调用Object()创建对象,解析器需要顺着作用域链从当前作用域开始查找,直到找到全局Object()构造函数为止,如果你在某个域中创建了一个Object()方法就会有问题。

这里有一篇关于JavaScript创建对象的三种方式的介绍,是翻译自JavaScript Pattern。里面有更多关于为什么使用字面量定义对象更好。 https://github.com/TooBug/javascript.patterns/blob/master/chapter3.markdown

函数

因为函数是对象,所以它们可以像任何其他的值一样被使用。函数可以保存在变量、对象和数组(数组也是对象)中。函数可以被当做参数传递给其他函数,函数也可以在返回函数。而且,因为函数是对象,所以函数可以拥有方法。

函数字面量(函数表达式)

定义函数有两种常用方法:

1.函数声明

2.函数字面量(函数表达式)

1
2
3
4
5
6
7
8
9
function getCarName() {
    return "byd";
}
console.log(getCarName());

var getCarPrice = function () {
    return 90000;
};
console.log(getCarPrice());

这两种写法相差无几,实际项目中都是可行的,我们可能也没有发现什么错误。但是,他们是有区别的,JavaScript解析器对函数声明和函数表达式并不是一视同仁的。

对于函数声明,JavaScript解析器会在预解析阶段优先读取函数声明的代码,以确保函数能够被引用到;而对于函数表达式,只有在执行到相应的语句时才进行解析。

在实际中,具体表现在:当使用函数声明的形式来定义函数时,可将调用放在函数声明之前,而使用函数表达式,这样做的话会报错。如下例:

1
2
3
4
5
6
7
8
9
10
11
runCar();

function runCar() {
    console.log("run car");
}

runTrain();

var runTrain = function () {
    console.log("run train");
};

一起学学Spring Batch(二)

| Comments

所有的Batch处理都可以以一种最简单的方式描述,那就是读取大量的数据,然后进行某种方式的计算或者变形,最后输出写入到某个存储系统中。Spring Batch提供了三个简单的接口来帮助执行大量数据的读写,分别是ItemReader、ItmeWriter和ItermProcessor,你可以说它们是抽象出来的一种简单概念,它们同样也是针对不同类型数据的输入、输出和处理的方法。

我们最常用到的数据类型有三种:数据库、XML和Flat文件。为了能够清晰的描述Batch处理的流程,我们采用Flat这种文件作为输入和输出数据源,排除数据库操作和XML文件解析的带来的理解上的复杂度。

“Flat文件是一种包含没有相对关系结构的记录的文件。这个类型通常用来描述文字处理、其他结构字符或标记被移除了的文本。在任何事件中,许多用户把保存成“纯文本(text only)”类型的Microsoft Word文档叫做“Flat File(flat file)”。Flat File的另一种形式是包含了用ASCII码记录的,每个表单元由逗号分隔,用行表示记录组的文件。这种文件页叫做用逗号分隔数值(CSV)的文件.”

这里给出一个例子,从一个csv格式的flat文件中读取英语、数学、文学的分数,然后计算平均分,将结果写入另一个csv格式文件。

首先是两个Model,分别是输入的数据模型ExamScore和输出的数据模型AverageScore。

ExamScore.java
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
29
30
31
32
33
34
35
36
37
38
39
40
41
package me.zeph.spring.batch.model;

public class ExamScore {
  private int id;
  private int english;
  private int math;
  private int literature;

  public int getId() {
      return id;
  }
  
  public void setId(int id) {
      this.id = id;
  }

  public int getEnglish() {
      return english;
  }

  public void setEnglish(int english) {
      this.english = english;
  }

  public int getMath() {
      return math;
  }

  public void setMath(int math) {
      this.math = math;
  }

  public int getLiterature() {
      return literature;
  }
  
  public void setLiterature(int literature) {
      this.literature = literature;
  }
  
}
AverageScore.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package me.zeph.spring.batch.model;

public class AverageScore {

  private int id;
  private double score;

  public int getId() {
      return id;
  }

  public void setId(int id) {
      this.id = id;
  }

  public double getScore() {
      return score;
  }

  public void setScore(double score) {
      this.score = score;
  }

}

然后是Processor,这里实现ItemProcessor接口。在process方法中传入输入数据模型,返回输出数据模型。

ScoreProcessor.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package me.zeph.spring.batch.processor;

import me.zeph.spring.batch.model.AverageScore;
import me.zeph.spring.batch.model.ExamScore;
import org.springframework.batch.item.ItemProcessor;

public class ScoreProcessor implements ItemProcessor<ExamScore, AverageScore> {

  public static final double COUNT = 3.0;

  @Override
  public AverageScore process(ExamScore examScore) throws Exception {
      AverageScore averageScore = new AverageScore();
      averageScore.setId(examScore.getId());
      averageScore.setScore(calculateAverageScore(examScore));
      return averageScore;
  }

  private double calculateAverageScore(ExamScore examScore) {
      return (examScore.getEnglish() + examScore.getLiterature() + examScore.getMath()) / COUNT;
  }
}

和上篇文章的一样,在spring-batch-beans.xml中定义了关于Sping Batch的一些基础Bean。

spring-batch-beans.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
           http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">

    <bean id="transactionManager" class="org.springframework.batch.support.transaction.ResourcelessTransactionManager"/>

    <bean id="jobRepository" class="org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean">
        <property name="transactionManager" ref="transactionManager"/>
    </bean>

    <bean id="jobLauncher" class="org.springframework.batch.core.launch.support.SimpleJobLauncher">
        <property name="jobRepository" ref="jobRepository"/>
    </bean>

</beans>

重点是下面一个xml文件spring-batch-jobs.xml,在这个里面定义所有关于Batch Job的具体内容。

spring-batch-jobs.xml
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:batch="http://www.springframework.org/schema/batch"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
           http://www.springframework.org/schema/batch
           http://www.springframework.org/schema/batch/spring-batch-2.2.xsd">

    <import resource="spring-batch-beans.xml"/>

    <bean id="csvFileReader" class="org.springframework.batch.item.file.FlatFileItemReader">
        <property name="resource" value="file:/Users/twer/Documents/gradle-project/spring-batch-example/src/main/resources/reader_file.csv"/>
        <property name="lineMapper" ref="lineMapper"/>
    </bean>

    <bean id="lineMapper" class="org.springframework.batch.item.file.mapping.DefaultLineMapper">
        <property name="lineTokenizer" ref="lineTokenizer"/>
        <property name="fieldSetMapper" ref="fieldSetMapper"/>
    </bean>

    <bean id="lineTokenizer" class="org.springframework.batch.item.file.transform.DelimitedLineTokenizer">
        <property name="delimiter" value=","/>
        <property name="names" value="id,english,math,literature"/>
    </bean>

    <bean id="fieldSetMapper" class="org.springframework.batch.item.file.mapping.BeanWrapperFieldSetMapper">
        <property name="targetType" value="me.zeph.spring.batch.model.ExamScore"/>
    </bean>

    <bean id="csvFileProcessor" class="me.zeph.spring.batch.processor.ScoreProcessor"/>

    <bean id="csvFileWriter" class="org.springframework.batch.item.file.FlatFileItemWriter">
        <property name="resource" value="file:/Users/twer/Documents/gradle-project/spring-batch-example/src/main/resources/writer_file.csv"/>
        <property name="lineAggregator" ref="lineAggregator"/>
    </bean>

    <bean id="lineAggregator" class="org.springframework.batch.item.file.transform.DelimitedLineAggregator">
        <property name="delimiter" value=","/>
        <property name="fieldExtractor" ref="fieldExtractor"/>
    </bean>

    <bean id="fieldExtractor" class="org.springframework.batch.item.file.transform.BeanWrapperFieldExtractor">
        <property name="names" value="id,score"/>
    </bean>

    <batch:job id="fileTransfer">
        <batch:step id="step">
            <batch:tasklet>
                <batch:chunk reader="csvFileReader" processor="csvFileProcessor" writer="csvFileWriter" commit-interval="1"/>
            </batch:tasklet>
        </batch:step>
    </batch:job>

</beans>

让我们来一起分析一下上面这个xml配置。

FlatFileItemReader是Flat文件的读取类,可以按行读取输入文件。这里传入两个参数,LineMapper和Resource。

Resource顾名思义,用来指定数据源。

LineMapper用于将文件中的每行数据映射到对应的数据模型,这里使用DefaultLineMapper。LineMapper中传入两个参数,分别是行分词器LineTokenizer和域映射器FieldSetMapper。

对应的LineTokenizer采用基于分隔符的分词器,而对应的FieldSetMapper需要传入待映射的数据模型类型。

对于FlatFileItemWriter,同样要配置对应的输出源Resource和行聚合器lineAggregator。

对于lineAggregator这里同样采用基于分隔符的聚合器DelimitedLineAggregator,需要给聚合器配置对应的分隔符(比如“,”)和域提取器BeanWrapperFieldExtractor。

在域提取器BeanWrapperFieldExtractor中配置要被提取的值。

最后就是定义具体的Batch Job。

spring-batch-jobs.xml
1
2
3
4
5
6
7
<batch:job id="fileTransfer">
        <batch:step id="step">
            <batch:tasklet>
                <batch:chunk reader="csvFileReader" processor="csvFileProcessor" writer="csvFileWriter" commit-interval="1"/>
            </batch:tasklet>
        </batch:step>
</batch:job>

运行结果:上面是输入,下面是输出

1,100,80,80
2,100,70,80
3,100,80,70

1,86.66666666666667
2,83.33333333333333
3,83.33333333333333