我们创建数组也许会这样,金沙js娱乐场官方网站使用字面量语法(literal

当我们创建NSString对象时,Objective-C提供了非常简单的方式去创建NSString,当我们创建NSString对象时,Objective-C提供了非常简单的方式去创建NSString,使用字面量语法(literal,Objective-C以语法繁杂而著称,使用字面量语法(literal,Objective-C以语法繁杂而著称,不用 Foundation 框架也能写出 Objective-C,使用字面量语法(literal

金沙js娱乐场官方网站 2

第三条、多用字面量语法,少用与之等价的方法,字面等价

首先,当我们创建NSString对象时,Objective-C提供了非常简单的方式去创建NSString。这就是字符串字面量。语法如下:

NSString *s = @"This is a test";

如果不这样的话,那么我们需要alloc、init然后去创建了。


还有NSNumber,用于存储整数浮点数,原来我们可能用:

NSNumber *number = [NSNumber numberWithInt:1];

现在我们可以直接:

NSNumber *number = @1;

NSArray,我们创建数组也许会这样:

NSArray *arr = [NSArray arrayWithObjects:@"112",@"2323",@"str",nil];

当我们使用字面量数组时:

NSArray *animals = @[@"cat",@"dog",@"pig"];

而且取数据也比较简单,原来我们取数据是:

NSString *s = [arr objectAtIndex:1];

当我们使用了字面量数组后,我们只需要:

NSString *s = animals[1];

取变得更加方便。但是需要注意:如果元素为nil,则会抛出异常

其实他的效果就等同于先创建一个数组,然后将中括号里面的元素再添加进去。

其实字面变量只是一种语法糖(也成糖衣语法:是指计算机语言中与另外一套语法等效但是使用起来更加方便的语法),下面是个有趣的问题:

比如有三个数据:

id obj1 =

id obj2 =

id obj3 = 

如果我们使用常规的方法

NSArray *arr = [NSArray arrayWithObjects:obj1,obj2,obj3,nil];

然后使用字面量数组:

NSArray *arr= @[obj1,obj2,obj3];

此时如果obj2为空,而其他两者不为空,那么对于我们常规创建的方法,数组中只有obj1,而对于字面量数组则会报错。常规创建只有obj1的原因是arrayWithOObjects方法会依次处理各个参数,直到发现nil为止。所以obj2是nil函数就执行结束了。


字面量字典

传统的创建方式可能是:

NSDictionary *dic = [NSDictionary dictionaryWithObjectsAndKeys:@"Scott",@"name",@"boy",@"gender",@"beijing",@"address",nil];

如果使用字面量字典,创建方式如下:

NSdictionary *dic = @{@"name":@"Scott",@"gender":@"boy",@"address":@"beijing"};

与数组一样,一旦值为nil,便会抛出异常。

同样的,原来的取方法为:

NSString *gender = [dic objectForKey:@"gender"];

现在我们只需要:

NSString *gender = dic[@"gender"];

当然也可以按照上面的取字面量字典的值。如果是可变的数组或者字典,可以采用下标来进行改变:

mutalbeArr[1] = @"chicken";
mutableDic[@"name"] = @"Scott Zhang";

字面量变量就简单介绍这么多吧。


总结:

①、一定要注意在字典或者数组的时候值为nil会抛出异常,一定要保证值不包含nil.

首先,当我们创建 NSString
对象时,Objective-C提供了非常简单的方式去创建NSStr…

与数组一样,一旦值为nil,便会抛出异常。

若使用字面量,则是:

要点##


应该使用字面量语法来创建字符串、数值、数组、字典。与创建此类对象的常规方法相比,这么做更加简明扼要。

应该通过取下标操作来访问数组下标或字典中的键所对应的元素。

用字面量语法创建数组或字典时,若值中有nil,则会抛出异常。因此,务必确保值里不含nil。

                                                                                                          ----Duke呀

  字面量数组

  数组是常用的数据结构。如果不使用字面量语法,那么就要这样来创建数组:

1 NSArray *animals = [NSArray arrayWithObjects:@"cat", @"dog", @"mouse", @"badger", nil];

  而使用字面量语法来创建则是:

1 NSArray *animals = @[@"cat", @"dog", @"mouse", @"badger"];

  上面这种做法不仅简单,而且还利于操作数组。数组的常见操作就是取某个下标所对应的对象,这用字面量来做更为容易。如果不用字面量,那么通常会用“objectAtIndex:”
方法:

1 NSString *dog = [animals objectAtIndex:1];

  若使用字面量,则是:

1 NSString *dog = [animals objectAtIndex:1];

  这也叫做“取下标”操作(subscripting),与使用字面量语法的其他情况一样,这种方式也更为简洁、更易理解,而且与其他语言中依下标来访问数组元素时所用的语法类似。

  不过,用字面量语法创建数组时要注意,若数组元素对象中有
nil,则会抛出异常,因为字面量语法实际上是一种“语法糖”,其效果等于是先创建了一个数组,然后把方括号内的所有对象都加到这个数组中。

  在改用字面量语法来创建数组是就会遇到这个问题。下面这段代码分别以两种语法创建数组:

1     id object1 = /* ... */;
2     id object2 = /* ... */;
3     id object3 = /* ... */;
4     
5     NSArray *arrayA = [NSArray arrayWithObjects:object1, object2, object3, nil];
6     NSArray *arrayB = @[object1, object2, object3];

  如果 object1 与 object3 都指向有效的 Objective-C 对象,而 object2 是
nil,那么字面量语法创建数组 arrayB 时会抛出异常。arrayA
虽然能创建出来,但是其中却只含有 object1
一个对象。原因在于,“arrayWithObjects:”方法会依次处理各个参数,直到发现
nil 为止,由于 object2 是 nil,所以该方法会提前结束。

  这个微妙的差别表明,使用字面量语法更为安全。抛出异常令程序终止执行,这比创建好数组之后才发现元素个数少了要好。向数组中插入
nil 通常说明程序有错,而通过异常可以更快的发现这个错误。

此时如果obj2为空,而其他两者不为空,那么对于我们常规创建的方法,数组中只有obj1,而对于字面量数组则会报错。常规创建只有obj1的原因是arrayWithOObjects方法会依次处理各个参数,直到发现nil为止。所以obj2是nil函数就执行结束了。

 

字面数值##


有时需要把整数、浮点数、布尔值封入Objective-C对象中。这种情况下可以用NSNumber类,该类可处理多种类型的数值。若是不用字面量,那么就需要按下述方式创建实例:
NSNumber *someNumber = [NSNumber numberWithInt:1];

上面这行代码创建了一个数字,将其值设为整数1。然而使用字面量能令代码更为整洁:

NSNumber *someNumber = @1;

大家可以看到,字面量语法更为精简。不过它还有很多好处。能够以NSNumber实例表示的所有数据类型都可使用该语法。例如:

NSNumber intNumber = @1;
NSNumber floatNumber = @2.5f;
NSNumber doubleNumber = @3.14159;
NSNumber boolNumber = @YES;
NSNumber *charNumber = @’a’;

字面量语法也适用于下述表达式:

int x = 5;
float y = 6.32f;
NSNumber *expressionNumber = @(x * y);

以字面量来表示数值十分有用。这样做可以令NSNumber对象变得整洁,因为声明中只包含数值,而没有多余的语法成分。

  Objective-C 以语法繁杂著称。不过从 Objective-C 1.0
起,有一种非常简单的方式能创建 NSString
对象。这就是“字符串字面量”(string literal),其语法如下:

NSArray *animals = @[@"cat",@"dog",@"pig"];

 

字面量字典##


“字典”(Dictionary)是一种映射型数据结构,可向其中添加键值对。与数组一样,Objective-C代码也经常用到字典。其创建方式如下:

NSDictionary *personData =
    [NSDictionarydictionaryWithObjectsAndKeys:
        @"Matt", @"firstName",
        @"Galloway", @"lastName",
        [NSNumber numberWithInt:28], @"age",
        nil];

这样写令人困惑,因为其顺序是<对象>,<键>,<对象>,<键>。这与通常理解的顺序相反,我们一般认为是把“键”映射到“对象”。因此,这种写法不容易读懂。如果改用字面量语法,就清晰多了:

NSDictionary *personData =
    @{@"firstName" : @"Matt",
      @"lastName" : @"Galloway",
      @"age" : @28};

上面这种写法更简明,而且键出现在对象之前,理解起来较顺畅。此范例代码还说明了使用字面量数值的好处。字典中的对象和键必须都是Objective-C对象,所以不能把整数28直接放进去,而要将其封装在NSNumber实例中才行。使用字面量语法很容易就能做到这一点,只需给数字前加一个@字符即可。

与数组一样,用字面量语法创建字典时也有个问题,那就是一旦有值为nil,便会抛出异常。不过基于同样的原因,这也是个好事。假如在创建字典时不小心用了空值对象,那么“dictionaryWithObjectsAndKeys:”方法就会在首个nil之前停下,并抛出异常,这有助于查错。

字典也可以像数组那样用字面量语法访问。按照特定键访问其值的传统做法是:

NSString *lastName = [personData objectForKey:@"lastName"];

与之等效的字面量语法则是:

NSString *lastName = personData[@"lastName"];

这样写也省去了冗赘的语法,令此行代码简单易读。

  可变数组与字典

  通过取下标操作,可以访问数组中某个下标或字典中某个键所对应的元素。如果数组与字典对象是可变的(mutable),那么也能通过下标修改其中的元素值。修改可变数组与字典内容的标准做法是: 

1     [mutableArray replaceObjectAtIndex:1 withObject:@"dog"];
2     [mutableDictionary setObject:@"Galloway" forkey: @"lastName"];

  若换用取下标操作来写,则是:

1     mutableArray[1] = @"dog";
2     mutableDictionary[@"lastName"] = @"Galloway";
NSString *s = animals[1];

大家想想:如果object1与object3都指向了有效的Objective-C对象,而object2是nil,那么会出现什么情况呢?按字面量语法创建数组arrayB时会抛出异常。arrayA虽然能创建出来,但是其中却只含有object1一个对象。原因在于,“arrayWithObjects:”方法会依次处理各个参数,直到发现nil为止,由于object2是nil,所以该方法会提前结束。

局限性##


字面量语法有个小小的限制,就是除了字符串以外,所创建出来的对象必须属于Foundation框架才行。如果自定义了这些类的子类,则无法用字面量语法创建其对象。要想创建自定义子类的实例,必须采用“非字面量语法”(nonliteral
syntax)。然而,由于NSArray、NSDictionary、NSNumber都是业已定型的“子族”(class
cluster,参见第9条),因此很少有人会从其中自定义子类,真要那样做也比较麻烦。而且一般来说,标准的实现已经很好了,无须再改动。创建字符串时可以使用自定义的子类,然而必须要修改编译器的选项才行。除非你明白这样做的后果,否则不鼓励使用此选项,用NSString就足够了。

使用字面量语法创建出来的字符串、数组、字典对象都是不可变的(immutable)。若想要可变版本的对象,则需复制一份:

NSMutableArray *mutable = [@[@1, @2, @3, @4, @5] mutableCopy];

这么做会多调用一个方法,而且还要再创建一个对象,不过使用字面量语法所带来的好处还是多于上述缺点的。

  字面数值

  有时需要把整数、浮点数、布尔值封入 Objective-C
对象中。这种情况下可以用 NSNumber
类,该类可处理多种类型的数值。若是不用字面量,那么就需要按下述方式创建实例:

1 NSNumber *someNumber = [NSNumber numberWithInt:1];

  上面这行代码创建了一个数字,将其值设为整数
1。然而使用字面量能令代码更为整洁:

1 NSNumber *someNumber = @1;

   可以看到,字面量语法更为精简。不过它还有很多好处。能够以 NSNumber
实例表示的所有数据类型都可使用该语法。例如:

1     NSNumber *intNumber = @1;
2     NSNumber *floatNumber = @2.5f;
3     NSNumber *doubleNumber = @3.14159;
4     NSNumber *boolNumber = @YES;
5     NSNumber *charNumber = @'a';

  字面量语法也适用于下述表达式:

1     int x = 5;
2     float y = 6.32f;
3     NSNumber *expressionNumber = @(x * y);

  以字面量来表示数值十分有用。这样做可以令 NSNumber
对象变的整洁,因为声明中只包含数值,而没有多余的语法成分。

NSString *s = [arr objectAtIndex:1];

金沙js娱乐场官方网站 1

Objective-C以语法繁杂而著称。事实上的确是这样。不过,从Objective-C
1.0起,有一种非常简单的方式能创建NSString对象。这就是“字符串字面量”(string
literal),其语法如下:
NSString *someString = @”Effective Objective-C 2.0”;

  • 应该使用字面量语法来创建字符串、数值、数组、字典。与创建此类对象的常规方法相比,这么做更加简明扼要。
  • 应该通过取下标操作来访问数组下标或字典中的键所对应的元素。
  • 用字面量语法创建数组或字典时,若值中有
    nil,则会抛出异常。因此,务必确保值里不含 nil。

同样的,原来的取方法为:

字面量字典

编写Objective-C程序时,总会用到某几个类,它们属于Foundation框架。虽然从技术上来说,不用Foundation框架也能写出Objective-C代码,但实际上却经常要用到此框架。这几个类是NSString、NSNumber、NSArray、NSDictionary。从类名上即可看出各自所表示的数据结构。

1 NSString *someString = @"Effective Objective-C 2.0";

首先,当我们创建NSString对象时,Objective-C提供了非常简单的方式去创建NSString。这就是字符串字面量。语法如下:

字面数值

如果不用这种语法的话,就要以常见的alloc及init方法来分配并初始化NSString对象了。在版本较新的编译器中,也能用这种字面量语法来声明NSNumber、NSArray、NSDictionary类的实例。使用字面量语法(literal
syntax)可以缩减源代码长度,使其更为易读。

  编写 Objective-C 程序时,总会用到某几个类,它们属于 Foundation
框架。虽然从技术上来说,不用 Foundation 框架也能写出 Objective-C
代码,但实际上却经常要用到此框架。

现在我们只需要:

在改用字面量语法来创建数组时就会遇到这个问题。下面这段代码分别以两种语法创建数组:

字面量数组##


数组是常用的数据结构。如果不使用字面量语法,那么就要这样来创建数组:

NSArray *animals =
    [NSArray arrayWithObjects:@"cat", @"dog",
                             @"mouse", @"badger", nil];

而使用字面量语法来创建则是:

NSArray *animals = @[@"cat", @"dog", @"mouse", @"badger"];

上面这种做法不仅简单,而且还利于操作数组。数组的常见操作就是取某个下标所对应的对象,这用字面量来做更为容易。如果不用字面量,那么通常会用“objectAtIndex:”方法:

NSString *dog = [animals objectAtIndex:1];

若使用字面量,则是:

NSString *dog = animals[1];

这也叫做“取下标”操作(subscripting),与使用字面量语法的其他情况一样,这种方式也更为简洁、更易理解,而且与其他语言中依下标来访问数组元素时所用的语法类似。

不过,用字面量语法创建数组时要注意,若数组元素对象中有nil,则会抛出异常,因为字面量语法实际上只是一种“语法糖”(syntactic
sugar),其效果等于是先创建了一个数组,然后把方括号内的所有对象都加到这个数组中。抛出的异常会是这样:

*** Terminating app due to uncaught exception
'NSInvalidArgumentException', reason: '***
-[__NSPlaceholderArray initWithObjects:count:]: attempt to
insert nil object from objects[0]'

在改用字面量语法来创建数组时就会遇到这个问题。下面这段代码分别以两种语法创建数组:

id object1 = /* ... */;
id object2 = /* ... */;
id object3 = /* ... */;

NSArray *arrayA = [NSArray array WithObjects:
                       object1, object2, object3, nil];
NSArray *arrayB = @[object1, object2, object3];

大家想想:如果object1与object3都指向了有效的Objective-C对象,而object2是nil,那么会出现什么情况呢?按字面量语法创建数组arrayB时会抛出异常。arrayA虽然能创建出来,但是其中却只含有object1一个对象。原因在于,“arrayWithObjects:”方法会依次处理各个参数,直到发现nil为止,由于object2是nil,所以该方法会提前结束。

这个微妙的差别表明,使用字面量语法更为安全。抛出异常令应用程序终止执行,这比创建好数组之后才发现元素个数少了要好。向数组中插入nil通常说明程序有错,而通过异常可以更快地发现这个错误。

  字面量字典

  “字典”(Dictionary)
是一种映射型数据结构,可向其中添加键值对。与数组一样, Objective-C
代码也经常用到字典。其创建方式如下:

1     NSDictionary *personData = [NSDictionary dictionaryWithObjectsAndKeys:@"Matt", @"firstName", @"Galloway", @"lastName", [NSNumber numberWithInt:28], @"age", nil];

  这样写令人困惑,因为其顺序是<对象>,<键>,<对象>,<键>。这与通常理解的顺序相反,我们一般认为是把“键”映射到“对象”。因此这种写法不容易读懂。如果改用字面量语法,就清晰多了:

1 NSDictionary *personData = @{@"firstName": @"matt", @"lastName": @"Galloway", @"age": @28};

  上面这种语法更简明,而且键出现在对象之前,理解起来比较顺畅。此范例代码还说明了使用字面量数值的好处。字典中的对象和键必须都是
Objective-C 对象,所以不能把整数 28 直接放进去,而要将其封装在 NSNumber
实例中才行。使用字面量语法很容易就能做到这一点,只需要给数字前加一个 @
字符即可。

  与数组一样,用字面量语法创建字典时也有一个问题,那就是一旦值为
nil,便会抛出异常。不过基于同样的原因,这也是个好事。假如在创建字典时不小心用了空值对象,那么“dictionaryWithObjectsAndKeys:”
方法就会在首个 nil 之前停下,并抛出异常,这有助于查错。

  字典也可以像数组那样用字面量语法访问。按照特定键访问其值的传统做法是:

1 NSString *lastName = [personData objectForKey:@"lastName"];

  与之等效的字面量语法则是:

1 NSString *lastName = personData[@"lastName"];

  这样写也省去了冗赘的语法,令此代码简单易读。

NSArray *arr = [NSArray arrayWithObjects:@"112",@"2323",@"str",nil];

数组是常用的数据结构。如果不使用字面量语法,那么就要这样来创建数组:

可变数组与字典##


通过取下标操作,可以访问数组中某个下标或字典中某个键所对应的元素。如果数组与字典对象是可变的(mutable),那么也能通过下标修改其中的元素值。修改可变数组与字典内容的标准做法是:

[mutableArray replaceObjectAtIndex:1 withObject:@"dog"];
[mutableDictionary setObject:@"Galloway"forKey:@"lastName"];

若换用取下标操作来写,则是:

mutableArray[1] = @"dog";
mutableDictionary[@"lastName"] = @"Galloway";

  这个几个类是
NSString、NSNumber、NSArray、NSDictionary。从类名上即可看出各自所表示的数据结构。

取变得更加方便。但是需要注意:如果元素为nil,则会抛出异常

上面这种做法不仅简单,而且还利于操作数组。数组的常见操作就是取某个下标所对应的对象,这用字面量来做更为容易。如果不用字面量,那么通常会用“objectAtIndex:”方法:

  局限性

  字面量语法有个小小的限制,就是除了字符串以外,所创建出来的对象必须属于
Foundation
框架才行。如果自定义了这些类的子类,则无法用字面量语法创建其对象。要想创建自定义子类的实例,必须采用“非字面量语法”(nonliteral
syntax)。然而,由于 NSArray、NSDictionary、NSNumber
都是也已定型的“子族”(class
cluster),因此很少有人会从其中自定义子类,真要那样做也比较麻烦。而且一般来说,标准的实现已经很好了,无须再改动。创建字符串时可以使用自定义的子类,然而必须要修改编译器的选项才行。除非你明白这样做的后果,否则不鼓励使用此选项,用
NSString 就足够了。

  使用字面量语法创建出来的字符串、数组、字典对象都是不可变的(immutable)。若想要可变版本的对象,则需要复制一份:

1 NSMutableArray *mutable = [@[@1, @2, @3, @4, @5] mutableCopy];

  这么做会多调用一个方法,而且还要再创建一个对象,不过使用字面量语法所带来的好处还是多于上述缺点的。

END


 

  本条要点:(作者总结)

如果我们使用常规的方法

金沙js娱乐场官方网站 2

  如果不用这种语法的话,就要以常见的 alloc 及 init 方法来分配并初始化
NSString 对象了。在版本较新的编译器中,也能用这种字面量语法来声明
NSNumber、NSArray、NSDictionary 类的实例。使用字面量语法(literal
syntax)可以缩短源代码长度,使其更为易读。

NSNumber *number = @1;

局限性

总结:

1
2
3
4
5
6
7
id object1 = /* ... */;
id object2 = /* ... */;
id object3 = /* ... */;

NSArray *arrayA = [NSArray array WithObjects:
                       object1, object2, object3, nil];
NSArray *arrayB = @[object1, object2, object3];