[转]NUnit学习笔记 VS.net 200五篇起名

一、简介
  NUnit是1款堪与JUnit齐名的开源的回归测试框架,供.net开垦人士做单元测试之用,能够从www.nunit.org网址上免费获取,最新版本2.二.陆。NUnit
二.二.陆有5个下载文件,那里用的是NUnit-二.二.六-net-2.0.msi。下载后双击该文件,然后按提示实行设置,那样系统中就有着NUnit环境了。
2、配置类库
  开辟工具笔者使用的是微软的Visual Studio.net
2007(以下简称vs),打开后点击菜单“文件”->“新建项目”,张开“新建项目”对话框:

原文:http://www.cnblogs.com/yanhaijing/p/3685304.html

起名 1

那是自身所精通的最完全最精简的JavaScript基础教程。

在该对话框中,“项目连串”小编选择的是“Visual
Basic”,借使想使用C#或者J#,请自行接纳“其余语言”下的“Visual
C#”或“Visual
J#”,反正操作差不离,上边也都会介绍到,可是VC就免谈了;“模板”小编选的是“调控台应用程序”,您也足以选别的“模板”,小编看的事例创造的就是“类库”;名称请自行设定,VB、C#、J#类型小编都建了,分别起名叫NUnitVB、NUnitCS和NUnitJS,设置好后,点击“明确”按钮。此时项目虽已开立,但未有保存,请点击“文件”->“全部保存”,展开“保存项目”对话框:

那篇文章带您赶紧走进JavaScript的世界——前提是你有壹部分编制程序经验的话。本文试图描述那门语言的最小子集。小编给那么些子集起名称叫做“JavaScript简易教程”,并推举准备深刻阅读细节和高等技能以前的新手阅读。心急吃不了热豆腐。小说的末梢建议如何特别学习

起名 2

警示:下边是自身所讲述的平整集和特级施行。小编爱不释手整洁清晰(例如,你能够随时通过上面包车型客车目录飞速导航)。规则是无懈可击的,但不可制止——每一个人的接头分化。

因此“浏览”按钮设置“位置”,笔者设置的是本机G:\MDZPCK\Microsoft\MySY。
  下边点击菜单“项目”->“增多引用”,展开“增加引用”对话框:

目录

1. 本文约定
2. 语言的性质
3. 语法
4. 变量和赋值
5.
6. 布尔
7. 数字
8. 字符串
9. 语句
10. 函数
11. 异常处理
12. 严格模式
13. 变量作用域和闭包
14. 对象和继承
15. 数组
16. 正则表达式
17. 数学
18. 标准库的其他功能
19. 下一步学什么?

起名 3

本文约定(Conventions used in this blog post)

在“.NET”选项卡中找到组件名叫nunit.framework的1项,点击“明确”开关,此时在档次中就足以采纳NUnit类库了。
3、编写用于测试的类
  用于测试的类相当粗略,名字为Book,唯有id和name多少个属性,这两日性格将独家用于多少个用例当中。
上边开头编写制定,请点击菜单“项目”->“增加类”,张开“加多新项”对话框:

命令行交互(Command line interaction)

每当本人介绍2个新定义,笔者都会尝试通过JavaScript命令行进行出现说法。像下边那样:

> 3 + 4
  7

高出号前面的文本是用户输入内容。别的的都以JavaScript引擎的出口内容。其余,也足以运用console.log()来向调节台打字与印刷数据(那措施能够在当先二分之1JavaScript引擎中央银行事,包括Node.js).

起名 4

寻觅文书档案(Finding documentation)

有时你看到有的函数或措施有超链接,你应当明了他俩的干活原理。如若没有,能够在Mozilla
Developer
Network
 (MDN)上查看细节,你也得以运用谷歌(Google)在MDN上追寻文书档案。例如,上面是经过谷歌(Google)搜索数组的push()方法的事例:

mdn array push

在该对话框中,“类”模板被暗许选中,请将名称修改为Book.vb或Book.cs、Book.jsl,然后点击“增加”开关。
  类成立后,供给修改代码,VB代码如下:
  Public Class Book
    Dim pid As String = Nothing
    Dim pname As String = Nothing

语言的属性(The nature of the language)

本节对JavaScript的习性简介,以救助您了然1些疑问。

    Property id() As String
      Get
        Return pid
      End Get
      Set(ByVal Value As String)
        pid = Value
      End Set
    End Property

JavaScript 和 ECMAScript(JavaScript versus ECMAScript)

编程语言称为JavaScript,语言专业称为ECMAScript。他们有例外名字的来头是因为“Java”已经被登记为商标(属于
Oracle)。最近,唯有Mozilla被行业内部同意接纳“JavaScript”名称,因为很久从前他们等到一份许可。因而,开放的语言专业有着分化的
名字。当前的JavaScript版本是ECMAScript 5,ECMAScript
陆当前是开发版

    Property name() As String
      Get
        Return pname
      End Get
      Set(ByVal Value As String)
        pname = Value
      End Set
    End Property
  End Class
代码相比较轻巧,没什么可说的吗?上面是C#代码:
  using System;
  using System.Collections.Generic;
  using System.Text;

影响(Influences)

JavaScript之父,Brendan Eich
别无选取必须急忙创设一门语言。(只怕,更倒霉,Netscape将利用任何技巧)。他借鉴了几门其余语言:

  • JavaScript借鉴了Java的语法和怎样区分原始值和对象
  • JavaScript的函数设计受Scheme和AWK的诱导——他们(函数)都以率先类(first-class)对象,并且在语言广东中国广播公司泛利用。闭包使她们形成强大的工具。
  • Self影响了JavaScript独一无2的面向对象编制程序(OOP)风格。它的核心思想(在此地我们尚非亲非故系)非凡优雅,基于此创造的言语相当少。但3个大约的方式(见前边)照顾大多数用例。JavaScript面向对象编制程序的杀手级天性是您能够平素创立对象。不要求先创制类或任何类似的东西。
  • Perl和Python影响了JavaScript字符串,数组和正则表达式的操作。

JavaScript直到ECMAScript
三才参加格外处理,那表达了干吗那门语言常常活动调换类型和平时静默战败:它最初不可能抛出13分。

二头,JavaScript有诸多怪癖,并且确实过多功能(块级变量成效域(block-sciped
variables),模块(modules)支持子类型(subtyping)等)。另一方面,它有几个越发庞大的特征,允许你弥补地点的标题。在别的语言中,你要上学语言特征。在JavaScript中,你供给平日读书方式代表。

  namespace NUnitCS
  {
    public class Book
    {
      private string pid = null;
      private string pname = null;

深入阅读(Further reading)

      public string id
      {
        get
        {
          return pid;
        }

语法(Syntax)

那节介绍部分JavaScript的着力语法规则。

        set
        {
          pid = value;
        }
      }

话语和表明式(Statements versus expressions)

领会JavaScript的语法,那促进掌握(简单来讲),它有五个基本点的语法类型:语句和表达式。

  • 讲话平日“做一点事情”。程序是一组语句系列。举个例子,上面表明(制造)四个变量
    foo:

    var foo;
    
  • 表明式发生值。他们平常位于赋值操作的邮政编码,函数参数,等。举个例子:

    3 * 7
    

话语和表达式之间的分别最佳通过实例证实,JavaScript(像Java)有两种差别的法门贯彻if-then-else。一种是用言语:

var x;
if (y >= 0) {
    x = y;
} else {
    x = -y;
}

 

另一种是表明式:

var x = y >= 0 ? y : -y;

您能够将后者作为函数参数(但前者不行):

myFunction(y >= 0 ? y : -y)

 

末段,每当JavaScript期待三个说话,你也足以用叁个表达式代替。例如:

foo(bar(7, 1));

foo(…);是贰个言语(也号称表达式语句),bar(7,
1)是多少个表明式。他们都落成函数调用。

      public string name
      {
        get
        {
          return pname;
        }

流程序调控制语句和语句块(Control flow statements and blocks)

流程序调整制语句,其语句体能够是单条语句。举五个例证:

if (obj !== null) obj.foo();
    while (x > 0) x--;

只是,任何语句总能被语句块替代,花括号包括零或多条语句。因而,你也得以如此写:

起名 5

if (obj !== null) {
    obj.foo();
}

while (x > 0) {
    x--;
}

起名 6

在本文中,大家只是用后一种方式。

        set
        {
          pname = value;
        }
      }
    }
  }
也没怎么可说的呢?下面是J#代码:
  package NUnitJS;

分号(Semicolons)

分号在JavaScript中是可选的。但简单他们唯恐带来出人意料的结果,所以自身建议你不用那么做。

正如上边所看到的,分号作为言语的末段,但语句块不供给。仅有一种景况下您将看到块前边有根据地:函数表明式前边的函数体块。表明式作为言语的尾声,后边是分号:

var x = 3 * 7;
var f = function () { };

 

  public class Book
  {
    private String pid = null;
    private String pname = null;

注释(Comments)

JavaScript有三种注释情势:单行注释和多行注释。单行注释以//初阶,以换行符结尾:

x++; // 单行(single-line)注释

 

多行注释用/**/包裹

/* 
 这是多行注释
 多行哦
 */

 

    /** @property */
    public void set_id(String value)
    {
      pid = value;
    }
    /** @property */
    public String get_id()
    {
      return pid;
    }

深刻阅读

    /** @property */
    public void set_name(String value)
    {
      pname = value;
    }
    /** @property */
    public String get_name()
    {
      return pname;
    }
  }
能够看看,J#代码与VB和C#代码有个别分裂,因为J#的语法是从Java演化过来的,所以其品质在概念时被拆成了set_XXX和get_XXX那样的几个主意。但仅有set_XXX和get_XXX那样的多个格局还不够,还须要运用@property指令进行认证。尽管用不用@property指令在调用时也没怎么分别,但您能够品味将变量pid和pname更名称叫id和name,重新编写翻译;而后再将@property指令去掉,再重复编写翻译。真的不同。
从那之后,用于测试的类编排成功了。
四、编写测试用例
  那里只用了二个类实行测试,名字为BookTest,在此以前那样的类大概必要持续NUnit.Framework.TestCase类,但前天只供给对该类应用TestFixture属性实行标志就可以,而无须承袭了。BookTest类包括多个用例,分别对相应类的testId和testName方法,即每一个方法落成了多个测试用例。注意,在NUnit中,这一个用来兑现测试用例的章程有二种手腕进行标志:贰个是以testXXX的格式来命名,二个是使用Test属性实行标记。其它,BookTest还有Init和Dispose那多少个主意,并分别采纳SetUp和TearDown属性来拓展标记,前者在种种测试方法初叶在此以前实践,多用来做开始化;后者在各类测试方法达成今后推行,多用来清理能源。注意,那七个格局的称谓并从未什么样范围,但必须用SetUp和TearDown属性实行标志。其它,NUnit还提供了TestFixtureSetUp和TestFixtureTearDown属性,功效与SetUp和TearDown类似,但前者是在具备用例实施从前做开端化、之后做清理,而后者是在各样用例推行此前做早先化、之后做清理。上面初阶编写制定BookTest。
  点击菜单“项目”->“增多类”,张开“加多新项”对话框,将名称改为BookTest.vb或BookTest.cs、BookTest.jsl,然后点击“加多”按键创立该类。修改代码,VB代码如下:
  Imports NUnit.Framework

变量和赋值(Variables and assignment)

JavaScript中的变量在动用从前必须先注明:

var foo;  // 声明变量“foo”

 

  <TestFixture()> _
  Public Class BookTest
    Dim bo As Book = Nothing

赋值(Assignment)

您能够在生命变量的同时给它赋值:

var foo = 6;

你也足以给业已存在的变量重新赋值:

 foo = 4;  // 更改变量的值

 

    <SetUp()> _
    Public Sub Init()
      Console.WriteLine(“测试起始!”)
      bo = New Book
      Console.WriteLine(“book对象被起始化!”)
    End Sub

复合赋值操作符(Compount assignment operators)

有过多适合赋值操作符,例如+=。上面包车型大巴多少个赋值操作等价:

x += 1;
x = x + 1;

 

    <Test()> _
    Public Sub testId()
      bo.id = “00一” ‘设置id属性的值为
      ’使用Assert查看id属性的值是还是不是为
      Assert.AreEqual(“001”, bo.id)
      Console.WriteLine(“id属性被测试!”)
    End Sub

标志符和变量名(Identifiers and variable names)

标记符便是东西的名字,在JavaScript中他们饰演分裂的语法剧中人物。例如,变量的称谓是二个标记符。

大约上,标识符的首先个字符能够是任何Unicode字符,加元标识符($)或下划线(_)。后边的字符能够是自由字符和数字。由此,下边全是合法的标记符:

arg0
_tmp
$elem
π

有个别标志符是“保留主要字”——他们是语法的一局部,无法用作变量名:

arguments break case catch class const continue debugger default delete do else enum eval export extends false finally for function if implements import in instanceof interface let new null package private protected public return static super switch this throw true try typeof var void while with yield

从才具上讲,下边八个标志符不是保留字,但也不应有作为变量名:

Infinity NaN undefined

    <Test()> _
    Public Sub testName()
      bo.name = “ASP” ‘设置name属性的值为ASP
      ’使用Assert查看name属性的值是或不是为JSP,那是个料定出现谬误的测试
      Assert.AreEqual(“JSP”, bo.name)
      Console.WriteLine(“name属性被测试!”)
    End Sub

深刻阅读

    <TearDown()> _
    Public Sub Dispose()
      Console.WriteLine(“book对象将被清理!”)
      bo = Nothing
      Console.WriteLine(“测试停止!”)
    End Sub
  End Class
此处Init和Dispose方法没什么好说的,正是实施了对book对象的开头化和清理,然则testId和testName必要验证一下。前者是在对bo的id属性进行测试,首先赋值为”00一”,然后使用Assert的AreEqual方法查看id属性中存放的值是不是是期待的值,由于自家的期待值也是”00壹”,所以举办后这几个用例应该是大功告成的;后者则是对bo的name属性实行测试,也是率先赋值为”ASP”,然后利用Assert的AreEqual方法查看其值是还是不是是期待的,由于自家专门将期待值设定为有史以来不容许的”JSP”,由此这一个用例实践后会出现3个不当。但请留心,由于本人是特地要让测试现身谬误,所以将期待值设定成了不可能的值,如若你是测试职员,请千万不要这么做,否则1经其他地方导致了错误,很轻易给协调产生不须求的麻烦。
  下边简要介绍一下上面用到的静态类NUnit.Framework.Assert。该类重要包涵二十二个法子:
  一.AreEqual()和AreNotEqual()方法,用来查看七个目标的值是不是等于或不等,与目的相比中央银行使的Equals()方法类似。
  二.Are萨姆e()和AreNotSame()方法,用来比较多个对象的引用是不是等于或不等,类似于经过“Is”或“==”相比几个对象。
  叁.Contains()方法,用来查阅对象是否在集合中,集合类型应与System.Collections.IList包容。示例:
    Dim o As New Object
    Dim al As New ArrayList
    al.Add(o)
    Assert.Contains(o, al)
  4.Greater()和Less()方法,用来相比八个数值的分寸,前者也等于过量号(>),后者也便是小于号(<)。
  伍.IsInstanceOfType()和IsNotInstanceOfType()方法,用来决断目的是还是不是相称于钦命项目。示例:
    Dim t As Type = New Object().GetType
    Dim s As String = “”
    Assert.IsInstanceOfType(t, s)
鉴于Object是.net中持有品类的基类,String类型包容于Object,由此那一个示例是力所能及运行通过的。而上面那些示例运维将是失利的:
    Dim t As Type = New ArrayList().GetType
    Dim s As String = “”
    Assert.IsInstanceOfType(t, s)
  六.IsAssignableFrom()和IsNotAssignableFrom()方法,用来剖断目的是不是是钦点类型的实例。示例:
    Dim t As Type = New Object().GetType
    Dim s As String = “”
    Assert.IsAssignableFrom(t, s)
其壹示例与从前的以身作则是如出1辙的,但鉴于字符串s不是Object类型的,由此不可能运行通过。而上面这一个实例能够运维通过:
    Dim t As Type = New String(“”).GetType
    Dim s As String = “”
    Assert.IsAssignableFrom(t, s)
  七.IsFalse()和IsTrue()方法,用来查阅变量是是还是不是为false或true,假诺IsFalse()查看的变量的值是false则测试成功,借使是true则战败,IsTrue()与之相反。
  捌.IsNull()和IsNotNull()方法,用来查看对象是或不是为空和不为空。
  玖.IsEmpty()和IsNotEmpty()方法,用来判定字符串或集合是或不是为空白或从不成分,当中集合类型应与ICollection包容。
  十.IsNaN()方法,用来剖断钦点的值是或不是不是数字。
  11.Fail()方法,意为战败,用来抛出错误。作者个人感觉有四个用途:首先是在测试驱动开垦中,由于测试用例都是在被测试的类以前编写,而写成时又不通晓其正确与否,此时就能够使用Fail方法抛出荒唐实行模拟;其次是抛出意外的失实,比如要测试的内容是从数据库中读取的数码是不是科学,而产生错误的缘故却是数据库连接战败。
  1二.Ignore()方法,意为忽略,用来忽略后续代码的实行,用途可以参照Fail()方法。
此外,NUnit还提供了1个专用于字符串的静态类NUnit.Framework.
StringAssert,该类首要包蕴四个措施:
  一.Contains()方法,用来查阅钦定的第三个字符串中是或不是带有了第2个字符串。
  2.StartsWith ()和EndsWith
()方法,分别用来查阅钦赐的首先个字符串是或不是位于第二个字符串的起来和最终。
  3.AreEqualIgnoringCase()方法,用来相比较五个字符串是还是不是等于。
  下边再看一下C#代码:
  using System;
  using System.Collections.Generic;
  using System.Text;
  using NUnit.Framework;

值(Values)

JavaScript有全部大家希望的编制程序语言值类型:布尔,数字,字符串,数组等。JavaScript中的全数值都有品质。每一种属性有三个键(或名字)和贰个值。思念记录的域(田野先生s
of record)。你可以利用点(.)操作符读取属性:

value.propKey

举个例证:字符串“abc”有总体性lenght(长度)。

 > var str = 'abc';
 > str.length
   3

上边的代码也可以写成上面那样:

> 'abc'.length
  3

点操作符也可以用来给属性赋值:

 > var obj = {};  // 空对象
 > obj.foo = 123; // 创建属性“foo”,设置它为123
   123
 > obj.foo
   123

您也足以因而它(.)调用方法:

> 'hello'.toUpperCase()
  'HELLO'

地点,我们在值“hello”上面调用方法 toUpperCase()。

  namespace NUnitCS
  {
    [TestFixture]
    public class BookTest
    {
      Book book = null;

原始类型值和对象(Primitive values versus objects)

JavaScript定义了差异值之间的区分:

  • 原始值包涵:boolean,number,string,null和undefined,
  • 具有别的的值都以指标。实际上对象被定义为——全数不为原始类型的值。

两者之间的基本点分化在于他们是何等被相比较的:每3个目的有1个独一无二的标记,并且仅和温馨相等:

起名 7

> var obj1 = {};  // 一个空对象
> var obj2 = {};  // 另一个空对象
> obj1 === obj2
  false
> obj1 === obj1
  true

起名 8

反倒,全数原始值只要编码值一样就被感觉是平等的:

> var prim1 = 123;
> var prim2 = 123;
> prim1 === prim2
  true

接下去的两节介绍原始值和指标的越来越多细节。

      [SetUp]
      public void Init()
      {
        Console.WriteLine(“测试起初!”);
        book = new Book();
        Console.WriteLine(“book对象被起初化!”);
      }

原始类型值(Primitive values)

上面包车型地铁全是原始类型值(简称:原始值):

  • 布尔类型:true,false
  • 数字类型:1736,1.351
  • 字符串类型'abc',``"abc"
  • 两个“无值(non-values)”:undefined,null

原始值的特点:

  • 值做相比时:“内容”做比较。

    > 3 === 3
      true
    > 'abc' === 'abc'
      true
    
  • 没辙改观:值的性质不可能更改,无法增加和移除属性。

    > var str = 'abc';
    > str.foo = 3; // try to create property `foo` ⇒ no effect
    > str.foo  // unknown property
      undefined 
    

    (获取未知属性总重回undefined)

  • 原始值的聚集是原则性的(fixed set of
    values):
    您不可能自定义原始值。

      [Test]
      public void testId()
      {
        book.id = “001”; //设置id属性的值为
        //使用Assert查看id属性的值是还是不是为
        Assert.AreEqual(“001”, book.id);
        Console.WriteLine(“id属性被测试!”);
      }

对象(Objects)

富有非原始值(non-primitive)的值都以目的。最常见的三种对象类型是:

  • 简单来讲对象(类型是Object)能通过对象字面量创制:

    {
        firstName: 'Jane',
        lastName: 'Doe'
    }
    

    地点的指标有五个属性:firstName属性的值是“Jane”,lastName属性的值是“Doe”。

  • 数组(类型是
    Array)能由此数组字面量成立:

    [ 'apple', 'banana', 'cherry' ]
    

    上面的数组有多少个成分,能够因而数字索引访问。例如“apple”的目录是0.

  • 正则表明式对象(类型是
    RegExp)能通过正则表明式字面量成立。

    /^a+b+$/
    

     

指标的特点:

  • 正如的是援引:正如的是标记符,每一种值有谈得来的标志符。

    起名 9

    > {} === {}  // 两个不同的空对象
      false
    
    > var obj1 = {};
    > var obj2 = obj1;
    > obj1 === obj2
      true
    

    起名 10

     

  • 暗许能够更换。

     > var obj = {};
     > obj.foo = 123;
     > obj.foo
       123
    

     

  • 用户可扩展(user-extensible):你能够因此构造函数定义新的靶子类型。

数组怀有的数据结构(如)都以指标,但并不是颇具的对象都是数据结构。例如:正则表达式是指标,但不是一个数据结构。

      [Test]
      public void testName()
      {
        book.name = “ASP”; //设置name属性的值为ASP
        //使用Assert查看name属性的值是还是不是为JSP,那是个料定出现谬误的测试
        Assert.AreEqual(“JSP”, book.name);
        Console.WriteLine(“name属性被测试!”);
      }

undefined 和 null(undefined and null)

稍加有个别不需求,JavaScript有三个“无值(non-values)”:undefined 和
null。

  • undefined的意趣是“未有值(no value)”。为初步化的变量是undefined:

    > var foo;
    > foo
      undefined
    

    假设你读取不设有的属性,将重临undefined:

    > var obj = {}; // 空对象
    > obj.foo
      undefined
    

    未传递的参数也是undefined:

    > function f(x) { return x }
    > f()
      undefined
    

     

  • null的情致是“未有指标(no
    object)”。它被用来表示对象的无值(参数,链上的靶子等)。

一般特性形下您应当把undefined和null看成是等价的,假若他们意味着同样意义的无值的话。检查他们的1种艺术是透过严刻相比较:

if (x === undefined || x === null) {
    ...
}

另一种在实际上中利用的措施是感到undefined 和 null
都是false

if (!x) {
    ...
}

警戒:false,0,NaN 和 “” 都被当作false。

      [TearDown]
      public void Dispose()
      {
        Console.WriteLine(“book对象将被清理!”);
        book = null;
        Console.WriteLine(“测试结束!”);
      }
    }
  }
举重若轻好说的吗?下边看J#代码:
  package NUnitJS;

卷入档次(Wrapper types)

对象类型的实例Foo(包蕴内建品种,例如Array和此外自定义类型)从目的Foo.prototype上获得情势。你能够通过读这一个法子但不调用它的艺术注明那点:

> [].push === Array.prototype.push
  true

反倒,原始类型是从来不项指标,所以每一个原始类型有四个关系类型,称之为包装档次:

  • 布尔值的包装档次是 Boolean。布尔值从Boolean.prototype上收获格局:

    > true.toString === Boolean.prototype.toString
      true
    

     

    专注包装档次的名字第多少个假名是大写的B。假若在JavaScript中布尔值的门类能够访问,那么它可能会被产生布尔对象。

  • 数字值的卷入档次是Number。

  • 字符串值的包装档次是String。

包裹档次也有实例(他们的实例是目的),但不常用。相反,包装档次有其余用途:假如你将她们作为函数调用,他们得以将值转变为原始类型。

> Number('123')
  123
> String(true)
  'true'

 

  import System.*;
  import NUnit.Framework.*;

通过typeof 和 instanceof 将值分类(Categorizing values via typeof and instanceof)

有七个操作符能够用来将值分类:typeof 首要用来操作原始值,instanceof
首要用来创设对象。

typeof 使用办法如下:

typeof «value»

它回到描述 value “类型”的3个字符串。例如:

起名 11

> typeof true
  'boolean'
> typeof 'abc'
  'string'
> typeof {} // 空对象字面量
  'object'
> typeof [] // 空数组字面量
  'object'

起名 12

下标列出了装有typeof的结果:

 

操作数 结果
undefined 'undefined'
null 'object'
Boolean value 'boolean'
Number value 'number'
String value 'string'
Function 'function'
All other values 'object'

有三个东西和大家所说的原始值和目的是冲突的:

  • 函数的项目是“function”而不是“object”。鉴于函数(类型为“function”)是指标(类型是指标)的子类型,那不是3个谬误。
  • null的花色是“object”。那是1个bug,但从未被修复,因为修复后会破坏现成的代码。

instanceof行使方式如下:

«value» instanceof «Constr»

一旦 value 是三个目的,并且value
是由协会函数Constr创制的(思索:类)。例如:

起名 13

> var b = new Bar();  // 通过构造函数Bar创建对象
> b instanceof Bar
  true
> {} instanceof Object
  true
> [] instanceof Array
  true
> [] instanceof Object  // 数字是对象的子类型
  true

起名 14

 

  /** @attribute TestFixture() */
  public class BookTest
  {
    Book book = null;

深远阅读

    /** @attribute SetUp() */
    public void Init()
    {
      Console.WriteLine(“测试发轫!”);
      book = new Book();
      Console.WriteLine(“book对象被开始化!”);
    }

布尔(Booleans)

布尔类型原始值包涵true和false。上边包车型客车操作符爆发布尔值:

  • 2元逻辑运算符:&&(与),||(或)
  • 前缀逻辑运算符:!(非)
  • 等值运算符:=== !== == !=
  • 比较运算符(字符串或数字):> >= < <=

    /** @attribute Test() */
    public void testId()
    {
      book.set_id(“00壹”); //设置id属性的值为001
      //使用Assert查看id属性的值是或不是为00一
      Assert.AreEqual(“001”, book.get_id());
      Console.WriteLine(“id属性被测试!”);
    }

真值和假值(Truthy and falsy)

每当JavaScript希望多少个布尔值时(例如:if语句的规则),能够使用其余值。它将被精晓(转变)为true或false。上面的值被清楚为false:

  • undefinednull
  • 布尔: false
  • 数字: -0NaN
  • 字符串: ''

有着其余值被认为true。被理解为false的值成为假值(falsy),被清楚为true的值成为真值(truthy)。能够使用Boolean作为函数测试值被掌握为何。

起名 15

> Boolean(undefined)
  false
> Boolean(0)
  false
> Boolean(3)
  true

起名 16

 

    /** @attribute Test() */
    public void testName()
    {
      book.set_id(“ASP”); //设置name属性的值为ASP
      //使用Assert查看name属性的值是或不是为JSP,那是个自然出现谬误的测试
      Assert.AreEqual(“JSP”, book.get_name());
      Console.WriteLine(“name属性被测试!”);
    }

2元逻辑运算符(Binary logical operators)

JavaScript中的二元逻辑运算符是短路运算——如若第壹个操作数能够分明结果,第叁个操作数将不被注明。例如,在底下的代码中,函数foo()不会被调用。

false && foo()
true  || foo()

除此以外,二元逻辑运算符再次回到操作数中的贰个——大概是1个布尔值,也大概不是。一张真值表用来调控回到哪个值:

  • 与:即使第三个操作数是假值,再次回到首个。不然再次来到第一个操作数。

    > NaN && 'abc'
      NaN
    > 123 && 'abc'
      'abc'
    
  • 或:即便第二个操作数是真值,再次来到第三个。否则,再次来到第一个操作数。

    > 'abc' || 123
      'abc'
    > '' || 123
      123
    

     

    /** @attribute TearDown() */
    public void Dispose()
    {
      Console.WriteLine(“book对象将被清理!”);
      book = null;
      Console.WriteLine(“测试停止!”);
    }
  }
改好后,点击菜单“调节和测试”->“运维调节和测试”或按F伍键运营程序。等等,main函数里头好象一句代码也没写过啊啊?没有错,一句也没写,可是你照做就足以了。在探望黑屏壹闪之后,编码工作成就。
五、运行NUnit
  编码达成后,就可以选拔NUnit测试了。NUnit有二种分界面,壹种是命令行的,一种是可视化的,小编使用的就是继承者。点击“开端”菜单->“全体程序”->“NUnit-Net-二.0
二.二.六”->“NUnit-Gui”,张开NUnit的可视化分界面:

等值运算符(Equality operators)

在JavaScript中检查评定相等,你能够行使严厉相等(===)和严酷不等(!==)。大概您也得以应用非严俊相等(==)和非严厉不等(!=)。经验规则:总是用严谨运算符,假装非严苛运算符不设有。严谨相等更安全。

起名 17

深深阅读

点击菜单“File”->“Open”,张开刚才运转生成的可推行文件:

数字(Numbers)

JavaScript中的全部数字都以浮点型(纵然当先50%的JavaScript引擎内部也选用整数)。至于为啥这么设计,查看那里(每一个JavaScript开垦者应该领会的浮点知识)。

> 1 === 1.0
  true

 

特殊数字:

  • NaN (“不是三个数字 not a number”): 错误值。

    > Number('xyz')  // 'xyz' 不能被转换为数字
      NaN
    
  • Infinity:也是最大错误值(溢出).

    > 3 / 0
      Infinity
    > Math.pow(2, 1024)  // 数字太大了
      Infinity
    

    Infinity 有时很有用,因为它比别的其余数字都大。同样,-Infinity 比其余任何数字都小。

  • JavaScript有两个零,+0
    和 -0。它一般不让你看看,并简要将五个零都展现为0:

    > +0
      0
    > -0
      0
    

     

    Therefore, it is best to pretend that there is only a single zero
    (as we have done when we looked at falsy values:
    both -0 and +0 are falsy).

起名 18

运算符(Operators)

JavaScript中有下列算数运算符

  • 加: number1 + number2
  • 减: number1 - number2
  • 乘: number1 * number2
  • 除: number1 / number2
  • 求模: number1 % number2
  • 自增: ++variablevariable++
  • 自减: --variablevariable--
  • 负值: -value
  • 改变为数字: +value

全局对象Math通过函数提供越多算数运算操作。

JavaScript中也有位运算符(例如:位与
&)。

此刻就足以应用BookTest类对Book类举办测试了。请首先选用testId,点击“Run”按键,运转结果如下图:

深远阅读

在2ality有一系列博文介绍那些剧情,例如:

起名 19

字符串(Strings)

字符串能够直接通过字符串字面量创设。那一个字面量被单引号或双引号包裹。反斜线(\)转义字符并且产生局地调控字符。例如:

起名 20

'abc'
"abc"

'Did she say "Hello"?'
"Did she say \"Hello\"?"

'That\'s nice!'
"That's nice!"

'Line 1\nLine 2'  // 换行
'Backlash: \\'

起名 21

能够通过方括号访问单个字符:

> var str = 'abc';
> str[1]
  'b'

length属性是字符串的字符数量。

> 'abc'.length
  3

提示:字符串是不可变的,倘诺你想更换现成字符串,你供给创设2个行的字符串。

testId前的灰点变绿,而且进程条显示为绿条,那标识运营成功。下边再选取BookTest,点击“Run”按键,运转结果如下图:

字符串运算符(String operators)

字符串能够因此加号操作符(+)拼接,借使中间八个操作数为字符串,会将另1个操作数也转移为字符串。

> var messageCount = 3;
> 'You have '+messageCount+' messages'
  'You have 3 messages'

连日来举办拼接操作能够应用 += 操作符:

起名 22

> var str = '';
> str += 'Multiple ';
> str += 'pieces ';
> str += 'are concatenated.';
> str
  'Multiple pieces are concatenated.'

起名 23

 

起名 24

字符串方法(String methods)

 字符串有过多可行的方法。例如:

起名 25

> 'abc'.slice(1)  // 复制子字符串
  'bc'
> 'abc'.slice(1, 2)
  'b'

> '\t xyz  '.trim()  // 移除空白字符
  'xyz'

> 'mjölnir'.toUpperCase()
  'MJÖLNIR'

> 'abc'.indexOf('b')  // 查找字符串
  1
> 'abc'.indexOf('x')
  -1

起名 26

 

testId前的点照旧是浅紫蓝,但testName前的点是新民主主义革命,而且进程条展现为红条,那标记testName中存在错误。可是那么些荒唐是估计之内的,假如不想看看,可以在vs准将testName()方法中的”JSP”改成”ASP”,然后再次运转。此时并非重新起动NUnit,NUnit会自动加载重新编写好的文书。此时再运维BookTest,进程条已不是石青,而是淡紫白了。
六、说明
  本文是对《NUnit学习笔记》的改正,NUnit和Visual
Studio.net都应用了新本子。NUnit
二.二.陆对二.2.0张开了众多恢宏,那从对NUnit.Framework.Assert和NUnit.Framework.StringAssert的介绍就能够看出来。
  别的,这里只是对NUnit举行了简短的介绍,NUnit还提供了越多的效果,相关内容能够参照其文档。可是是英文的啊。

深切阅读

语句(Statements)

条件(Conditionals)

if语句通过布尔条件决定试行那些分支:

起名 27

    if (myvar === 0) {
        // then
    }

    if (myvar === 0) {
        // then
    } else {
        // else
    }

    if (myvar === 0) {
        // then
    } else if (myvar === 1) {
        // else-if
    } else if (myvar === 2) {
        // else-if
    } else {
        // else
    }

起名 28

 

上面包车型地铁switch语句,furit的值决定相当分支被执行。

起名 29

    switch (fruit) {
        case 'banana':
            // ...
            break;
        case 'apple':
            // ...
            break;
        default:  // 所有其他情况
            // ...
    }

起名 30

 

循环(Loops)

for 循环的格式如下:

for(初始化; 当条件成立时循环; 下一步操作)

 

例子:

    for (var i=0; i < arr.length; i++) {
        console.log(arr[i]);
    }

当条件建立即while循环继续循环它的循环体。

    // 和上面的for循环相等
    var i = 0;
    while (i < arr.length) {
        console.log(arr[i]);
        i++;
    }

当规则建立即,do-while循环继续循环。由于尺度放在循环体之后,所以循环中华全国体育总会是被至少至少实行1回。

    do {
        // ...
    } while(条件);

 

在具备的巡回中:

  • break中断循环
  • continue伊始2个新的循环迭代

函数(Functions)

概念函数的1种办法是经过函数注解:

    function add(param1, param2) {
        return param1 + param2;
    }

上边的代码定义三个名号叫做add的函数,有四个参数param一和param二,并且再次回到参数的和。上边是你如何调用这一个函数:

    > add(6, 1)
      7
    > add('a', 'b')
      'ab'

另一种定义add()函数的法子是透过函数表明式:

    var add = function (param1, param2) {
        return param1 + param2;
    };

函数表达式爆发3个值,因而得以一贯将函数作为参数字传送递给其余函数:

someOtherFunction(function (p1, p2) { ... });

 

函数评释升高(Function declarations are hoisted)

函数注脚会被进级,他们全被移位到方今功用域早先之处。那允许你在函数申明在此以前调用它们:

    function foo() {
        bar();  // 没问题,bar被提升
        function bar() {
            ...
        }
    }

只顾:虽然变量表明也会被提升,但赋值的经过不会被提高:

    function foo() {
        bar();  // 有问题,bar是undefined
        var bar = function () {
            // ...
        };
    }

特殊变量arguments(The special variable arguments)

在JavaScript中您能够调用任意函数并传递任意数量的参数——语言绝不会抱怨。那能够干活,可是,使全数参数可访问须求通过独特变量
arguments。arguments 看起来像数组,但它并未有数组的主意。

起名 31

    > function f() { return arguments }
    > var args = f('a', 'b', 'c');
    > args.length
    3
    > args[0]  // 获取索引为0的元素
    'a'

起名 32

 

太多或太少参数(Too many or too few arguments)

让我们经过下边包车型大巴函数研究JavaScript中传递太多或太少参数时怎么处理(函数
toArray在后面提到)

    function f(x, y) {
        console.log(x, y);
        console.log(toArray(arguments));
    }

多出的参数将被忽视(能够透过arguments访问):

    > f('a', 'b', 'c')
    a b
    [ 'a', 'b', 'c' ]

贫乏的参数将是undefined:

    > f('a')
    a undefined
    [ 'a' ]
    > f()
    undefined undefined
    []

 

可选参数(Optional parameters)

上边是贰个广大情势,给参数设置默许值:

    function pair(x, y) {
        x = x || 0;  // (*)
        y = y || 0;
        return [ x, y ];
    }

在(*)那行,假若x是真值(除了:null,undefined
等),||操作符再次来到x。不然,它回到第2个操作数。

起名 33

    > pair()
    [ 0, 0 ]
    > pair(3)
    [ 3, 0 ]
    > pair(3, 5)
    [ 3, 5 ]

起名 34

 

强制数量(Enforcing an arity)

要是你想强制参数的数码,你能够检验arguments.length:

    function pair(x, y) {
        if (arguments.length !== 2) {
            throw new Error('Need exactly 2 arguments');
        }
        ...
    }

 

将arguments 调换为数组(Converting arguments to an array)

arguments
不是一个数组,它只是是类数组(array-like):它有贰个length属性,并且你能够通过方括号索引格局访问它的要素。但是,你不可能移除成分,或在它上边调用任何数组方法。由此,有时你要求将其转移为数组。那正是下边函数的职能。

    function toArray(arrayLikeObject) {
        return [].slice.call(arrayLikeObject);
    }

 

深深阅读

尤其处理(Exception handling)

相当处理最广泛的措施像下边那样:

起名 35

    function throwException() {
        throw new Error('Problem!');
    }

    try {
        throwException();
    } catch (e) {
        console.log(e);  // 错误:信息
        console.log(e.stack);  // 非标准,但大部分浏览器支持
    }

起名 36

try分支包裹易出错的代码,假若try分支援内地建设部抛出格外,catch分支将会实施。

深深阅读

从严格局(Strict mode)

严加方式开启检查评定和1些别样方法,是JavaScript形成更卫生的言语。推荐应用严峻格局。为了展开严俊方式,只需在JavaScript文件或script标签第一行加多如下语句:

'use strict';

你也能够在各个函数上采纳性开启严酷形式,只需将下边的代码放在函数的起先:

    function functionInStrictMode() {
        'use strict';
    }

上面包车型地铁两小节看下严刻格局的叁大受益。

强烈错误(Explicit errors)

让大家看二个例证,严厉格局给我们鲜明的失实,不然JavaScript总是静默退步:上面包车型地铁函数
f() 实施一些非法操作,它试图改造全部字符串都有个别只读属性——length:

    function f() {
        'abc'.length = 5;
    }

当你调用上边的函数,它静默失利,赋值操作被略去忽略。让我们将 f()
在严刻形式下运作:

    function f_strict() {
        'use strict';
        'abc'.length = 5;
    }

将来浏览器报给大家有的荒谬:

    > f_strict()
    TypeError: Cannot assign to read only property 'length' of abc

 

不是方法的函数中的this(this in non-method functions)

在严酷格局下,不作为方法的函数中的this值是undefined:

    function f_strict() {
        'use strict';
        return this;
    }
    console.log(f_strict() === undefined);  // true

在非严俊形式下,this的值是被称作全局对象(global
object)(在浏览器里是window):

    function f() {
        return this;
    }
    console.log(f() === window);  // true

 

不再自动创制全局变量(No auto-created global variables)

在非严酷形式下,假使您给不存在的变量赋值,JavaScript会自动成立一个全局变量:
   

    > function f() { foo = 5 }
    > f()  // 不会报错
    > foo
    5

在从严格局下,那会发生三个荒谬:

    > function f_strict() { 'use strict'; foo2 = 4; }
    > f_strict()
    ReferenceError: foo2 is not defined

 

深入阅读

变量成效域和闭包(Variable scoping and closures)

在JavaScript中,你必须通过var证明变量,在您利用它们此前:

    > var x;
    > x = 3;
    > y = 4;
    ReferenceError: y is not defined

您能够用一条var语句注脚和初步化七个变量:

var x = 1, y = 2, z = 3;

但我建议每种变量使用一条语句。因而,我将地方的口舌重写为:

    var x = 1;
    var y = 2;
    var z = 3;

出于进步(见下文),最棒在函数顶部注脚变量。

变量和函数效能域(Variables are function-scoped)

变量的功能域总是整个函数(没有块级效用域)。例如:

起名 37

    function foo() {
        var x = -3;
        if (x < 0) {  // (*)
            var tmp = -x;
            ...
        }
        console.log(tmp);  // 3
    }

起名 38

我们能够看出tmp变量不仅在(*)所在行的语句块,它在全方位函数内都存在。

变量升高(Variables are hoisted)

变量证明会被进步:表明会被移到函数的顶部,但赋值进度不会。举个例子,在下边包车型客车函数中(*)行任务注解了3个变量。

    function foo() {
        console.log(tmp); // undefined
        if (false) {
            var tmp = 3;  // (*)
        }
    }

在里头,下面的函数被实践像上面那样:

起名 39

    function foo() {
        var tmp;  // declaration is hoisted
        console.log(tmp);
        if (false) {
            tmp = 3;  // assignment stays put
        }
    }

起名 40

闭包(Closures)

各样函数保持和函数体内部变量的接连,甚至离开创立它的成效域之后。例如:

    function createIncrementor(start) {
        return function () {  // (*)
            return start++;
        }
    }

在(*)行发轫的函数在它创设时保留上下文,并在当中保存三个start活动值:

起名 41

    > var inc = createIncrementor(5);
    > inc()
    5
    > inc()
    6
    > inc()
    7

起名 42

闭包是八个函数加上和其出力域链的链接。因而,createIncrementor()
重返的是三个闭包。

IIFE:模拟块级功用域(IIFE: Simulating block scoping)

有时你想效仿一个块,例如你想将变量从全局功用域隔断。完毕那个工作的形式叫做
IIFE(当下举行函数表明式(Immediately
Invoked Function Expression)):

    (function () {  // 块开始
        var tmp = ...;  // 非全局变量
    }());  // 块结束

地方你会看到函数表明式被及时实施。外面包车型地铁括号用来阻止它被解析成函数申明;唯有函数表明式能被立即调用。函数体爆发二个新的作用域并使
tmp 变为局地变量。

闭包达成变量共享(Inadvertent sharing via closures)

上面是个精粹难点,倘诺您不知底它那它会让你费尽怀恋。因而,先浏览下,先对难点有个大约的询问。

闭包保持和外部变量的连日,有时只怕和你想像的行为不雷同:

起名 43

    var result = [];
    for (var i=0; i < 5; i++) {
        result.push(function () { return i });  // (*)
    }
    console.log(result[1]()); // 5 (不是 1)
    console.log(result[3]()); // 5 (不是 3)

起名 44

(*)行的重临值总是当前的i值,而不是当函数被创设时的i值。当循环甘休后,i的值是伍,那是干吗数组中的全数函数的重返值总是同样的。即使你想捕获当前变量的快速照相,你可以行使
IIFE:

    for (var i=0; i < 5; i++) {
        (function (i2) {
            result.push(function () { return i2 });
        }(i));  // 复制当前的i
    }

 

深深阅读

指标和后续(Objects and inheritance)

和全部的值类型1律,对象有总体性。事实上,你能够将对象当作一组属性的集结,种种属性是1对(键和值)。键是字符串,值能够是任意JavaScript值。到近期截至,大家只有见过键是标识符的属性,因为点操作符处理的键必须为标志符。在那节,你讲见到另壹种格局属性的主意,能将任意字符串作为键。

单个对象(Single objects)

在JavaScript中,你可以一向创立对象,通过对象字面量:

起名 45

    var jane = {
        name: 'Jane',

        describe: function () {
            'use strict';
            return 'Person named '+this.name;
        }
    };

起名 46

上边的指标有多少个属性:name 和 describe。你能读(“get”)和
写(“set”)属性:

    > jane.name  // get
    'Jane'
    > jane.name = 'John';  // set
    > jane.newProperty = 'abc';  // 自动创建

品质是函数如 describe
可以被作为方法调用。当调用他们时得以在它们之中通过this引用对象。

    > jane.describe()  // 调用方法
    'Person named John'
    > jane.name = 'Jane';
    > jane.describe()
    'Person named Jane'

in 操作符用来检验3个属性是不是存在:

    > 'newProperty' in jane
    true
    > 'foo' in jane
    false

您若您读取二个不存在的属性,你将赢得undefined值。由此地点的五个反省也得以像上面那样:

    > jane.newProperty !== undefined
    true
    > jane.foo !== undefined
    false

delete操作符用来删除二个性能:

    > delete jane.newProperty
    true
    > 'newProperty' in jane
    false

任意键属性(Arbitrary property keys)

性格的键能够是任意字符串。到如今截止,大家来看的目的字面量中的和点操作符后的质量关键字。按那种方法你只好利用标识符。假若你想用别的任意字符串作为键名,你不可能不在指标字面量里丰裕引号,并运用方括号获取和设置属性。

    > var obj = { 'not an identifier': 123 };
    > obj['not an identifier']
    123
    > obj['not an identifier'] = 456;

方括号允许你动态总计属性关键字:

    > var x = 'name';
    > jane[x]
    'Jane'
    > jane['na'+'me']
    'Jane'

引用方法(Extracting methods)

借使你引用1个方法,它将错过和指标的连日。就其自身来讲,函数不是艺术,在那之中的this值为undefined(严苛方式下)。

    > var func = jane.describe;
    > func()
    TypeError: Cannot read property 'name' of undefined

消除办法是选用函数内置的bind()方法。它创造1个新函数,其this值固定为给定的值。

    > var func2 = jane.describe.bind(jane);
    > func2()
    'Person named Jane'

格局内部的函数(Functions inside a method)

各样函数都有3个诡异变量this。假使你在措施内部嵌入函数是很不便于的,因为您不能够从函数中访问方法的this。上边是三个事例,大家调用forEach循环3个数组:

起名 47

    var jane = {
        name: 'Jane',
        friends: [ 'Tarzan', 'Cheeta' ],
        logHiToFriends: function () {
            'use strict';
            this.friends.forEach(function (friend) {
                // 这里的“this”是undefined
                console.log(this.name+' says hi to '+friend);
            });
        }
    }

起名 48

调用 logHiToFriends 会产生错误:

    > jane.logHiToFriends()
    TypeError: Cannot read property 'name' of undefined

有二种艺术修复那难题。#壹:将this存储在不一致的变量。

起名 49

    logHiToFriends: function () {
        'use strict';
        var that = this;
        this.friends.forEach(function (friend) {
            console.log(that.name+' says hi to '+friend);
        });
    }

起名 50

#二:forEach的第二个参数允许提供this值。

    logHiToFriends: function () {
        'use strict';
        this.friends.forEach(function (friend) {
            console.log(this.name+' says hi to '+friend);
        }, this);
    }

在JavaScript中等高校函授数表明式平常被视作函数参数。时刻小心函数表明式中的this。

构造函数:对象工厂(Constructors: factories for objects)

近日停止,你只怕认为JavaScript的指标仅是键值的投射,通过JavaScript对象字面量可以得出那几个理念,看起来很像别的语言中的地图/字典(map/dictionary)。但是,JavaScript对象也帮助真正含义上的面向对象天性:承袭(inheritance)。本节会完全疏解JavaScript中持续的工作原理,但会给您以此为初叶的粗略形式。假若你想获得越来越多知识,请查阅那篇小说“JavaScript
inheritance by
example
”。

除此而外作为“真正”的函数和艺术,函数还在JavaScript中饰演第二种角色:借使因而new操作符调用,他们会成为构造函数,对象的工厂。构造函数是对其他语言中的类的回顾模拟。约定俗称,构造函数的第一个字母大写。例如:

起名 51

    // 设置实例数据
    function Point(x, y) {
        this.x = x;
        this.y = y;
    }
    // 方法
    Point.prototype.dist = function () {
        return Math.sqrt(this.x*this.x + this.y*this.y);
    };

起名 52

我们看出构造函数分为两片段:首先,Point函数设置实例数据。其次,Point.prototype属性包括对象的点子。前者的数额是各样实例私有的,前面包车型大巴多少是装有实例共享的。

咱们通过new操作符调用Point:

    > var p = new Point(3, 5);
    > p.x
    3
    > p.dist()
    5.830951894845301

p是Point的2个实例:

    > p instanceof Point
    true
    > typeof p
    'object'

深入阅读

数组(Arrays)

数组是数组成分的行列,能由此整数索引方法数组成分,数组索引从0起首。

数组字面量(Array literals)

数组字面量创立数组很有利:

> var arr = [ 'a', 'b', 'c' ];

地点的数组有四个因素:分别是字符串“a”,“b”,
“c”。你能够经过整数索引访问它们:

    > arr[0]
    'a'
    > arr[0] = 'x';
    > arr
    [ 'x', 'b', 'c' ]

length属性总代表三个数组有稍许项成分。

    > arr.length
    3

而外它也得以用来从数组上移除尾巴部分成分:

    > arr.length = 2;
    > arr
    [ 'x', 'b' ]

in操作符也得以在数组上干活。

    > 1 in arr // arr在索引为1处是否有元素?
    true
    > 5 in arr // arr在索引为5处是否有元素?
    false

值得注意的是数组是目标,由此能够有指标属性:

    > arr.foo = 123;
    > arr.foo
    123

 

数组方法(Array methods)

数组有数不完方法。举些例子:

起名 53

    > var arr = [ 'a', 'b', 'c' ];

    > arr.slice(1, 2)  // 复制元素
    [ 'b' ]
    > arr.slice(1)
    [ 'b', 'c' ]

    > arr.push('x')  // 在末尾添加一个元素
    4
    > arr
    [ 'a', 'b', 'c', 'x' ]

    > arr.pop()  // 移除最后一个元素
    'x'
    > arr
    [ 'a', 'b', 'c' ]

    > arr.shift()  // 移除第一个元素
    'a'
    > arr
    [ 'b', 'c' ]

    > arr.unshift('x')  // 在前面添加一个元素
    3
    > arr
    [ 'x', 'b', 'c' ]

    > arr.indexOf('b')  // 查找给定项在数组中的索引,若不存在返回-1
    1
    > arr.indexOf('y') 
    -1

    > arr.join('-')  // 将元素拼接为一个字符串
    'x-b-c'
    > arr.join('')
    'xbc'
    > arr.join()
    'x,b,c'

起名 54

 

遍历数组(Iterating over arrays)

有三种艺术能够遍历数组元素。当中多个最重大的是 forEach 和 map。

forEach遍历整个数组,并将目前因素和它的目录传递给一个函数:

    [ 'a', 'b', 'c' ].forEach(
        function (elem, index) {  // (*)
            console.log(index + '. ' + elem);
        });

地方代码的输出

    0. a
    1. b
    2. c

注意(*)行的函数参数是可粗略的。例如:它能够唯有多个参数 elem。

map创立1个新数组,通过给每种存在数组成分应用贰个函数:

    > [1,2,3].map(function (x) { return x*x })
    [ 1, 4, 9 ]

 

长远阅读

正则表达式(Regular expressions)

JavaScript内建协理正则表明式。他们被双斜线分隔:

    /^abc$/
    /[A-Za-z0-9]+/

 

办法 test():测试是还是不是同盟(Method test(): is there a match?)

    > /^a+b+$/.test('aaab')
    true
    > /^a+b+$/.test('aaa')
    false

 

方式 exec():相配和捕获组(Method exec(): match and capture groups)

    > /a(b+)a/.exec('_abbba_aba_')
    [ 'abbba', 'bbb' ]

归来的数组第二项(索引为0)是完好相配,捕获的率先个分组在第一项(索引为1),等。有一种办法能够频仍调用获取具有相称。

情势 replace():寻觅并替换(Method replace(): search and replace)

    > '<a> <bbb>'.replace(/<(.*?)>/g, '[$1]')
    '[a] [bbb]'

replace的率先个参数必须是正则表明式,并且打开全局搜索(/g
标识),不然仅第一个门户差不多项会被轮换。有一种艺术使用一个函数来计量替换项。

长远阅读

数学(Math)

Math是1个有算数功用的靶子。例如:

起名 55

    > Math.abs(-2)
    2

    > Math.pow(3, 2)  // 3^2
    9

    > Math.max(2, -1, 5)
    5

    > Math.round(1.9)
    2

    > Math.cos(Math.PI)  // 预定义常量π
    -1

起名 56

 

标准库的其余成效(Other functionality of the standard library)

JavaScript标准库相对简便易行,但有好些个其余东西你能够利用:

  • Date:日子构造函数,主要意义有转移和创立日期字符串,访问日期组成都部队分(年,小时等)。
  • JSON:一个指标,成效是改变和生成JSON数据。
  • console.* 方法:浏览器的具体方法,不是语言成分的片段,但她们也得以在Node.js中工作。

下一步学什么?

在你学会了那篇作品的基础教程后,你能够转到大多数章节末尾提到的尖端教程。其余,笔者提议你看下边包车型大巴财富:

欢迎举报

本身尝试找到JavaScript的一个最理想子集。作者成功了吧?必要增加和删除1些东西啊?若是您是三个JavaScript新手,笔者专门想听听你的思想:当读那篇小说的时候是10分轻松明白呢?或是你在少数地点卡住?

原文:http://www.2ality.com/2013/06/basic-javascript.html

Q群推荐

CSS家园
18827505一,Web开拓者(前后端)的净土,欢迎风乐趣的同室出席起名 57

GitHub家园
2259322八二,Git/GitHub爱好者的净土,欢迎有意思味的校友参与起名 58

码农之家 20314570柒,码农们的净土,欢迎风乐趣的同学到场起名 59

作者:颜海镜

原文:http://yanhaijing.com

微博:@颜海镜

本文版权归笔者和今日头条共有,欢迎转发,但未经小编同意必须保留此段证明,且在小说页面显明地点给出原作连接,不然保留追究法律权利的职分。

谢谢您的读书,纵然您对自笔者的博客所讲述的始末风乐趣,请继续关切笔者的后续博客,笔者是颜海镜

开源项目

  • data.js
    是带有新闻布告的多少主导,笔者把他称为活的多寡。
  • Painter
    是1款基于HTML五的绘图程序。
  • 翻脸方块
    是1款休闲益智小游戏,适合全数人群。
  • 翻一下
    是一款休闲益智小游戏,适合所有人群。

捐赠

起名 60帐号:yanhaijing@yeah.net

分类:
javascript

标签: javascript

好文要顶 关心自小编 收藏该文 起名 61
起名 62

起名 63

颜海镜
关注 – 58
粉丝 – 387

+加关注

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图