summaryrefslogtreecommitdiffhomepage
path: root/es-es
diff options
context:
space:
mode:
authorDavid Hsieh <davidhsiehlo@gmail.com>2015-10-19 14:54:53 -0700
committerDavid Hsieh <davidhsiehlo@gmail.com>2015-10-19 14:54:53 -0700
commit6616ee7156f2e631e18b13d0e19eb29041eec1bf (patch)
tree1f112e6a25894b20314fbeccc1decfbc1d523185 /es-es
parent6c0652bc9c3615df8a62791110c2d02c867b4615 (diff)
Reduced line lengths larger than 80 characters
Diffstat (limited to 'es-es')
-rw-r--r--es-es/objective-c-es.html.markdown349
1 files changed, 211 insertions, 138 deletions
diff --git a/es-es/objective-c-es.html.markdown b/es-es/objective-c-es.html.markdown
index fc769188..c5532c0f 100644
--- a/es-es/objective-c-es.html.markdown
+++ b/es-es/objective-c-es.html.markdown
@@ -38,7 +38,8 @@ int main (int argc, const char * argv[])
{
// Crear un autorelease pool para manejar la memoria al programa
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
- // Si se utiliza el conteo automático de referencias (ARC), utiliza @autoreleasepool:
+ // Si se utiliza el conteo automático de referencias (ARC),
+ // utiliza @autoreleasepool:
@autoreleasepool {
// Utiliza NSLog para imprimir líneas a la consola
@@ -53,13 +54,14 @@ int main (int argc, const char * argv[])
long myPrimitive2 = 234554664565;
// Declaraciones de objetos
- // Pon el * como prefijo de los nombre de las variables para declaraciones de
- // objetos de tipos fuertes
+ // Pon el * como prefijo de los nombre de las variables para declaraciones
+ // de objetos de tipos fuertes
MyClass *myObject1 = nil; // Tipo fuerte
id myObject2 = nil; // Tipo débil
// %@ es un objeto
// 'description' es una convención para mostrar el valor de los objetos
- NSLog(@"%@ and %@", myObject1, [myObject2 description]); // imprime => "(null) y (null)"
+ NSLog(@"%@ and %@", myObject1, [myObject2 description]);
+ // imprime => "(null) and (null)"
// String
NSString *worldString = @"World";
@@ -216,7 +218,8 @@ int main (int argc, const char * argv[])
int ii = 0;
while (ii < 4)
{
- NSLog(@"%d,", ii++); // ii++ incrementa ii en la misma línea, luego de utilizar su valor
+ NSLog(@"%d,", ii++); // ii++ incrementa ii en la misma línea, luego de
+ // utilizar su valor
} // imprime => "0,"
// "1,"
// "2,"
@@ -242,7 +245,8 @@ int main (int argc, const char * argv[])
// "2,"
// "3,"
- // Objeto de ciclos For. Puede ser utilizado con cualquier tipo de objecto de Objective-C
+ // Objeto de ciclos For. Puede ser utilizado con cualquier tipo de objecto de
+ // Objective-C
for (id item in values) {
NSLog(@"%@,", item);
} // imprime => "0,"
@@ -256,7 +260,8 @@ int main (int argc, const char * argv[])
// Tus declaraciones aquí
@throw [NSException exceptionWithName:@"FileNotFoundException"
reason:@"File Not Found on System" userInfo:nil];
- } @catch (NSException * e) // utiliza: @catch (id exceptionName) para atrapar todos los objetos
+ } @catch (NSException * e) // utiliza: @catch (id exceptionName) para atrapar
+ // todos los objetos
{
NSLog(@"Exception: %@", e);
} @finally
@@ -265,7 +270,8 @@ int main (int argc, const char * argv[])
} // imprime => "Exception: File Not Found on System"
// "Finally. Time to clean up."
- // Los objetos NSError son útiles para argumentos de función para los errores de usuario.
+ // Los objetos NSError son útiles para argumentos de función para los
+ // errores de usuario.
NSError *error = [NSError errorWithDomain:@"Invalid email." code:4 userInfo:nil];
///////////////////////////////////////
@@ -305,20 +311,27 @@ int main (int argc, const char * argv[])
// @property tipo nombre; <= declaración de propiedades
// -/+ (tipo) Declaración de método; <= Declaración de método
// @end
-@interface MyClass : NSObject <MyProtocol> // NSObject es la clase de objeto base de Objective-C.
+@interface MyClass : NSObject <MyProtocol> // NSObject es la clase de objeto
+ // base de Objective-C.
{
- // Declaraciones de variables de instancia (puede existir en el archivo de interfaz o de implementación)
+ // Declaraciones de variables de instancia (puede existir en el archivo de
+ // interfaz o de implementación)
int count; // Acceso protegido por defecto.
- @private id data; // Acceso privado (Más conveniente de declarar en el archivo de implementación)
+ @private id data; // Acceso privado (Más conveniente de declarar en el
+ // archivo de implementación)
NSString *name;
}
-// Notación conveneinte para acceso público de las variables para generar un método setter
-// Por defecto, el nombre del método setter 'set' seguido del nombre de variable @property
+// Notación conveneinte para acceso público de las variables para generar un
+// método setter
+// Por defecto, el nombre del método setter 'set' seguido del nombre de
+// variable @property
@property int propInt; // Nombre del método 'setter' = 'setPropInt'
@property (copy) id copyId; // (copy) => Copia el objeto durante la asignación
// (readonly) => No se le puede asignar un valor fuera de @interface
-@property (readonly) NSString *roString; // utiliza @synthesize en @implementation para crear un accesor
-// Puedes personalizar el nombre del getter y del setter en lugar de utilizar el nombre por defecto "set".
+@property (readonly) NSString *roString; // utiliza @synthesize en
+ // @implementation para crear un accesor
+// Puedes personalizar el nombre del getter y del setter en lugar de utilizar
+// el nombre por defecto "set".
@property (getter=lengthGet, setter=lengthSet:) int length;
// Métodos
@@ -334,23 +347,23 @@ int main (int argc, const char * argv[])
// Métodos de constructor con argumentos
- (id)initWithDistance:(int)defaultDistance;
-// Los nombres de los métodos de Objective-C son muy descriptivos. Siempre nombra los métodos
-// de acuerdo con sus argumentos
+// Los nombres de los métodos de Objective-C son muy descriptivos.
+// Siempre nombra los métodos de acuerdo con sus argumentos
@end // Define el final de la interfaz
-// Para acceder a las variables públicas desde el archivo de implementación, @property genera
-// un método setter automáticamente. El nombre del método es 'set' seguido de un nombre de variable
-// @property:
+// Para acceder a las variables públicas desde el archivo de implementación,
+// @property genera un método setter automáticamente. El nombre del método
+// es 'set' seguido de un nombre de variable @property:
MyClass *myClass = [[MyClass alloc] init]; // Crea una instancia del objeto MyClass
[myClass setCount:10];
NSLog(@"%d", [myClass count]); // imprime => 10
// O utilizando los métodos getter y setter personalizados en @interface:
[myClass lengthSet:32];
NSLog(@"%i", [myClass lengthGet]); // imprime => 32
-// Por conveniencia, puedes utilizar la notación de punto para asignar y acceder a las variables
-// de una instancia de objeto.
+// Por conveniencia, puedes utilizar la notación de punto para asignar y
+// acceder a las variables de una instancia de objeto.
myClass.count = 45;
NSLog(@"%i", myClass.count); // imprime => 45
@@ -363,13 +376,14 @@ MyClass *myClass = [[MyClass alloc] init]; // Crea una instancia de objeto Mycla
NSString *stringFromInstanceMethod = [myClass instanceMethodWithParameter:@"Hello"];
// Selectors
-// Una forma dinámica de representar métodos. Utilizados para llamar métodos de una clase,
-// pasar métodos a través de funciones para avisar a otras clases para que lo llamen, y
-// para guardar métodos como una variable.
-// SEL es el tipo de dato. @selector() devuelve un selector del nombre de método proveído
-// methodAparameterAsString:andAParameterAsNumber: es un nombre para un método en MyClass
+// Una forma dinámica de representar métodos. Utilizados para llamar métodos
+// de una clase, pasar métodos a través de funciones para avisar a otras clases
+// para que lo llamen, y para guardar métodos como una variable.
+// SEL es el tipo de dato. @selector() devuelve un selector del nombre de
+// método proveído methodAparameterAsString:andAParameterAsNumber: es un nombre
+// para un método en MyClass
SEL selectorVar = @selector(methodAParameterAsString:andAParameterAsNumber:);
-if ([myClass respondsToSelector:selectorVar]) { // Revisa si la clase contiene un método
+if ([myClass respondsToSelector:selectorVar]) { // Revisa si la clase contiene el método
// Debe de poner todos los argumentos de método en un solo objeto para mandar una
// función performSelector.
NSArray *arguments = [NSArray arrayWithObjects:@"Hello", @4, nil];
@@ -390,8 +404,8 @@ if ([myClass respondsToSelector:selectorVar]) { // Revisa si la clase contiene u
_count = 5; // Hace referencia a "int count" de la interfaz de MyClass
// Accede variables definidas en el archivo de implementación:
distance = 18; // Hace referencia a "long distance" de la implementación de MyClass
-// Para utilizar una variable @property en el archivo de implementación, utiliza @synthesize
-// para crear una variable de acceso:
+// Para utilizar una variable @property en el archivo de implementación, utiliza
+// @synthesize para crear una variable de acceso:
@synthesize roString = _roString; // _roString ahora está disponible en @implementation
// Lamado antes de llamar algún método o instanciar cualquier objeto
@@ -406,7 +420,8 @@ distance = 18; // Hace referencia a "long distance" de la implementación de MyC
// del objeto es cero
- (void)dealloc
{
- [height release]; // Si no utilizas ARC, asegúrate de liberar las variables de objeto de las clases
+ [height release]; // Si no utilizas ARC, asegúrate de liberar las variables de
+ // objeto de las clases
[super dealloc]; // y llama el método dealloc de la clase padre
}
@@ -414,7 +429,8 @@ distance = 18; // Hace referencia a "long distance" de la implementación de MyC
// Este es el constructor por defecto que es llamado cuando el objeto es inicializado.
- (id)init
{
- if ((self = [super init])) // 'super' es utilizado para acceder a los métodos de la clase padre.
+ if ((self = [super init])) // 'super' es utilizado para acceder a los
+ // métodos de la clase padre.
{
self.count = 1; // 'self' es utilizado para que el objeto se llame a sí mismo.
}
@@ -466,18 +482,20 @@ distance = 18; // Hace referencia a "long distance" de la implementación de MyC
///////////////////////////////////////
// Categorías
///////////////////////////////////////
-// Una categoría es un grupo de métodos diseñados para extender una clase. Te permiten agregar
-// nuevos métodos a una clase existente por propósitos de organización. Éstos no deben de ser
-// confundidos con subclases.
-// Las subclases existen para CAMBIAR la funcionalidad de un objeto mientras que las categorías
-// le AGREGAN funcionalidad de un objeto.
+// Una categoría es un grupo de métodos diseñados para extender una clase.
+// Te permiten agregar nuevos métodos a una clase existente por propósitos
+// de organización. Éstos no deben de serconfundidos con subclases.
+// Las subclases existen para CAMBIAR la funcionalidad de un objeto mientras
+// que las categoríasle AGREGAN funcionalidad de un objeto.
// Las categorías te permiten:
// -- Agregar métodos a una clase existente por propósitos de oganización.
-// -- Extender clases de objetos de Objective-C (ejemplo: NSString) para agregar tus propios métodos.
+// -- Extender clases de objetos de Objective-C (ejemplo: NSString) para
+// agregar tus propios métodos.
// -- Agregar la habilidad de crear métodos protegidos y privados para las clases.
-// NOTA: No sobreescribas los métodos de las clases base en una categoría aunque tengas la habilidad
-// de poder hacerlo. Sobreescribir métodos puede causar errores en la compilación después entre
-// diferentes categorías y puede arruinar el propósito de las categorías de solo AGREGAR funcionalidad.
+// NOTA: No sobreescribas los métodos de las clases base en una categoría
+// aunque tengas la habilidad de poder hacerlo. Sobreescribir métodos puede
+// causar errores en la compilación después entre diferentes categorías y
+// puede arruinar el propósito de las categorías de solo AGREGAR funcionalidad.
// Utiliza subclass para sobreescribir métodos.
// Aquí una clase base simple, Car.
@@ -508,17 +526,20 @@ distance = 18; // Hace referencia a "long distance" de la implementación de MyC
@end
-// Ahora, si quisieramos crear un objeto Truck (Camión), crearíamos una subclase de Car (Carro) como
-// si le cambiaramos de funcionalidad de Car para que se comporte como un camión. Pero digamos que
-// únicamente queremos agregar funcionalidad al Car (Carro) existente. Un buen ejemplo sería limpiar
-// el carro. Así que crearíamos una cateog®iea para agregar los métodos de limpieza:
+// Ahora, si quisieramos crear un objeto Truck (Camión), crearíamos una
+// subclase de Car (Carro) como si le cambiaramos de funcionalidad de Car
+// para que se comporte como un camión. Pero digamos que únicamente queremos
+// agregar funcionalidad al Car (Carro) existente. Un buen ejemplo sería
+// limpiar el carro. Así que crearíamos una cateog®iea para agregar los
+// métodos de limpieza:
// Archivo @interface: Car+Clean.h (NombreBaseDeClase+NombreDeCategoria.h)
#import "Car.h" // Asegúrate de improtar la clase que deseas extener.
-@interface Car (Clean) // El nombre de la categoría está dentro de (), seguido del nombre de la
- // clase base
+@interface Car (Clean) // El nombre de la categoría está dentro de (),
+ // seguido del nombre de la clase base
-- (void)washWindows; // Nombres de los nuevos métodos que le agregamos a nuestro objeto Car
+- (void)washWindows; // Nombres de los nuevos métodos que le agregamos
+ // a nuestro objeto Car
- (void)wax;
@end
@@ -537,10 +558,12 @@ distance = 18; // Hace referencia a "long distance" de la implementación de MyC
@end
-// Cualquier instancia del objeto Car tiene la habilidad de utilizar una categoría. Todo lo
-// que necesitan es importarlo:
-#import "Car+Clean.h" // Importa todas las diferentes categorías que necesites utilizar
-#import "Car.h" // También debes de importar la clase base para su funcionalidad original
+// Cualquier instancia del objeto Car tiene la habilidad de utilizar una
+// categoría. Todo lo que necesitan es importarlo:
+#import "Car+Clean.h" // Importa todas las diferentes categorías que
+ // necesites utilizar
+#import "Car.h" // También debes de importar la clase base para su
+ // funcionalidad original
int main (int argc, const char * argv[]) {
@autoreleasepool {
@@ -554,23 +577,27 @@ int main (int argc, const char * argv[]) {
return 0;
}
-// Objective-C no tiene declaraciones para métodos protegidos, pero los puedes simular.
-// Crea una categoría conteniendo todos los métodos protegidos, luego importa ÚNICAMENTE
-// al archivo @implementation de una clase que pertenece a la clase Car.
-@interface Car (Protected) // Nombrando la categoría 'Protected' para recordar que los métodos
- // están protegidos
+// Objective-C no tiene declaraciones para métodos protegidos, pero los puedes
+// simular. Crea una categoría conteniendo todos los métodos protegidos,
+// luego importa ÚNICAMENTE al archivo @implementation de una clase que
+// pertenece a la clase Car.
+@interface Car (Protected) // Nombrando la categoría 'Protected' para
+ // recordar que los métodos están protegidos
-- (void)lockCar; // Los métodos enlistados aquí solo puedens ser creados por objetos Car
+- (void)lockCar; // Los métodos enlistados aquí solo puedens ser creados
+ // por objetos Car
@end
-// Para utilizar los métodos protegidos, importa la categoría, luego implementa sus métodos:
-#import "Car+Protected.h" // Recuerda, importa únicamente el archivo de @implementation
+// Para utilizar los métodos protegidos, importa la categoría,
+// luego implementa sus métodos:
+#import "Car+Protected.h" // Recuerda, importa únicamente el archivo
+ // de @implementation
@implementation Car
- (void)lockCar {
- NSLog(@"Car locked."); // Las instancias de Car no puede utilizar lockCar porque no se
- // encuentra en @interface
+ NSLog(@"Car locked."); // Las instancias de Car no puede utilizar
+ // lockCar porque no se encuentra en @interface
}
@end
@@ -578,8 +605,8 @@ int main (int argc, const char * argv[]) {
///////////////////////////////////////
// Extensiones
///////////////////////////////////////
-// Las Extensions te permiten sobreescribir atributos de propiedades de acceso público y métodos de
-// un @interface
+// Las Extensions te permiten sobreescribir atributos de propiedades de
+// acceso público y métodos de un @interface
// Archivo @interface: Shape.h
@interface Shape : NSObject
@@ -588,17 +615,21 @@ int main (int argc, const char * argv[]) {
- (int)getNumOfSides;
@end
-// Puedes sobreescribir la variable numOfSides o el métodos getNumOfSlides para modificarlos con una
-// extensión:
+// Puedes sobreescribir la variable numOfSides o el métodos getNumOfSlides
+// para modificarlos con una extensión:
// Archivo @implementation: Shape.m
#import "Shape.h"
-// Las extensiones se encuentran en el mismo archivo que el archivo de @implementation
-@interface Shape () // () después del nombre de la clase base declara una extensión
-
-@property (copy) NSNumber *numOfSides; // Hacer numOfSlides copy en lugar de readonly.
--(NSNumber)getNumOfSides; // Hacer que getNumOfSides devuelva un NSNumber en lugar de un int.
--(void)privateMethod; // También puedes crear una nuevos métodos privados dentro de las
- // extensiones
+// Las extensiones se encuentran en el mismo archivo que el archivo
+// de @implementation
+@interface Shape () // () después del nombre de la clase base declara
+ // una extensión
+
+@property (copy) NSNumber *numOfSides; // Hacer numOfSlides copy en lugar
+ // de readonly.
+-(NSNumber)getNumOfSides; // Hacer que getNumOfSides devuelva un NSNumber
+ // en lugar de un int.
+-(void)privateMethod; // También puedes crear una nuevos métodos privados
+ // dentro de las extensiones
@end
// @implementation principal:
@@ -606,8 +637,8 @@ int main (int argc, const char * argv[]) {
@synthesize numOfSides = _numOfSides;
--(NSNumber)getNumOfSides { // Todas las declaraciones dentro de extensions deben de ser
- // dentro de @implementation
+-(NSNumber)getNumOfSides { // Todas las declaraciones dentro de extensions
+ // deben de ser dentro de @implementation
return _numOfSides;
}
-(void)privateMethod {
@@ -619,36 +650,44 @@ int main (int argc, const char * argv[]) {
///////////////////////////////////////
// Protocolos
///////////////////////////////////////
-// Un protocolo declara métodos que pueden ser implementados por cualquier otra clase
-// Los protocolos no son clases. Simplementen define una interfaz que otros objetos
-// deben de implementar.
+// Un protocolo declara métodos que pueden ser implementados por cualquier otra
+// clase. Los protocolos no son clases. Simplementen define una interfaz que
+// otros objetos deben de implementar.
// Archivo @protocol: "CarUtilities.h"
-@protocol CarUtilities <NSObject> // <NSObject> => Nombre de otro protocolo que se incluye en éste
- @property BOOL engineOn; // La clase que lo adopta debe de utilizar @synthesize para todas las
- // @properties definidas
+@protocol CarUtilities <NSObject> // <NSObject> => Nombre de otro protocolo
+ // que se incluye en éste
+ @property BOOL engineOn; // La clase que lo adopta debe de utilizar
+ // @synthesize para todas las @properties definidas
- (void)turnOnEngine; // y todos los métodos definidos
@end
// A continuación una clase ejemplo que implementa el protcolo
#import "CarUtilities.h" // Importar el archivo @protocol.
@interface Car : NSObject <CarUtilities> // El nombre del protocolo dentro de <>
- // No necesitas los nombres de @property o métodos aquí para CarUtilities. Estos solo
- // es requerido por @implementation.
-- (void)turnOnEngineWithUtilities:(id <CarUtilities>)car; // También Puedes utilizar protocolos como datos.
+ // No necesitas los nombres de @property o métodos aquí para CarUtilities.
+ // Estos solo es requerido por @implementation.
+- (void)turnOnEngineWithUtilities:(id <CarUtilities>)car; // También Puedes
+ // utilizar protocolos
+ // como datos.
@end
-// El @implementation necesita que se implementen @properties y métodos del protocolo.
+// El @implementation necesita que se implementen @properties y métodos
+// del protocolo.
@implementation Car : NSObject <CarUtilities>
-@synthesize engineOn = _engineOn; // Crear una declaración @synthesize para el @property engineOn.
+@synthesize engineOn = _engineOn; // Crear una declaración @synthesize para el
+ // @property engineOn.
-- (void)turnOnEngine { // Implementa turnOnEngine como quieras. Los protocolos no definen
- _engineOn = YES; // cómo implementas un método, con tal de que lo implementes.
+- (void)turnOnEngine { // Implementa turnOnEngine como quieras. Los
+ // protocolos no definen
+ _engineOn = YES; // cómo implementas un método, con tal de que lo implementes.
}
-// Puedes utilizar un protocolo como data mientras sepas quee métodos y variables tiene implementado.
+// Puedes utilizar un protocolo como data mientras sepas quee métodos y variables
+// tiene implementado.
- (void)turnOnEngineWithCarUtilities:(id <CarUtilities>)objectOfSomeKind {
[objectOfSomeKind engineOn]; // Tienes acceso a las variables
[objectOfSomeKind turnOnEngine]; // y los métodos del objeto
- [objectOfSomeKind engineOn]; // Puede o no puede ser YES. La clase lo implementa como se quiera.
+ [objectOfSomeKind engineOn]; // Puede o no puede ser YES. La clase lo
+ // implementa como se quiera.
}
@end
@@ -659,18 +698,23 @@ Car *carInstance = [[Car alloc] init];
if ([carInstance engineOn]) {
NSLog(@"Car engine is on."); // imprime => "Car engine is on."
}
-// Asegúrate de revisar si un objeto de tipo 'id' implementa un protocolo antes de llamar a sus métodos:
+// Asegúrate de revisar si un objeto de tipo 'id' implementa un protocolo antes
+// de llamar a sus métodos:
if ([myClass conformsToProtocol:@protocol(CarUtilities)]) {
NSLog(@"This does not run as the MyClass class does not implement the CarUtilities protocol.");
} else if ([carInstance conformsToProtocol:@protocol(CarUtilities)]) {
NSLog(@"This does run as the Car class implements the CarUtilities protocol.");
}
-// Las categorías también pueden implementar protcolos: @interface Car (CarCategory) <CarUtilities>
-// Puedes implementar varios protocolos: @interface Car : NSObject <CarUtilities, CarCleaning>
-// NOTA: Si dos o más protocolos dependen entre sí, asegúrate de declararlos de manera adelantada:
+// Las categorías también pueden implementar protcolos: @interface Car
+// (CarCategory) <CarUtilities>
+// Puedes implementar varios protocolos:
+// @interface Car : NSObject <CarUtilities, CarCleaning>
+// NOTA: Si dos o más protocolos dependen entre sí, asegúrate de declararlos
+// de manera adelantada:
#import "Brother.h"
-@protocol Brother; // Declaración adelantada. Sin ésto, el compilador tira un error.
+@protocol Brother; // Declaración adelantada. Sin ésto, el compilador
+ // tira un error.
@protocol Sister <NSObject>
@@ -678,10 +722,11 @@ if ([myClass conformsToProtocol:@protocol(CarUtilities)]) {
@end
-// Ver si el problema es que Sister depende de Brother, y Broteher dependa de Sister.
+// Ver si el problema es que Sister depende de Brother,
+// y Brother dependa de Sister.
#import "Sister.h"
-@protocol Sister; // Estas líenas detienen la recursión, solucionando el problema.
+@protocol Sister; // Estas líneas detienen la recursión, resolviendo el problema.
@protocol Brother <NSObject>
@@ -693,23 +738,30 @@ if ([myClass conformsToProtocol:@protocol(CarUtilities)]) {
///////////////////////////////////////
// Bloques
///////////////////////////////////////
-// Los bloques son declaraciones de código, tal como una función, pueden ser utilizados como data
-// A continuación un bloque simple con un argumento entero que devuelve un el argumento más 4.
+// Los bloques son declaraciones de código, tal como una función, pueden
+// ser utilizados como data.
+// A continuación un bloque simple con un argumento entero que devuelve
+// un el argumento más 4.
int (^addUp)(int n); // Declarar una variable para almacenar el bloque.
-void (^noParameterBlockVar)(void); // Ejemplo de una declaración de variable de bloque sin argumentos.
-// Los bloques tienen acceso a variables del mismo ámbito. Pero las variables son solo readonly
-// y el valor pasado al bloque es el valor de la variable cuando el bloque es creado.
-int outsideVar = 17; // Si modificamos outsideVar después de declarar addUp, outsideVar AÚN es 17.
-__block long mutableVar = 3; // __block hace que las variables se puedan escribir en bloques.
-addUp = ^(int n) { // Remueve (int n) para tener un bloque que no recibe ningún parámetro
+void (^noParameterBlockVar)(void); // Ejemplo de una declaración de variable
+ // de bloque sin argumentos.
+// Los bloques tienen acceso a variables del mismo ámbito. Pero las variables
+// son solo readonly y el valor pasado al bloque es el valor de la variable
+// cuando el bloque es creado.
+int outsideVar = 17; // Si modificamos outsideVar después de declarar addUp,
+ // outsideVar AÚN es 17.
+__block long mutableVar = 3; // __block hace que las variables se puedan
+ // escribir en bloques.
+addUp = ^(int n) { // Remueve (int n) para tener un bloque que no recibe
+ // ningún parámetro
NSLog(@"You may have as many lines in a block as you would like.");
NSSet *blockSet; // También puedes declarar variables locales.
mutableVar = 32; // Asignar un nuevo valor a la variable __block.
return n + outsideVar; // Declaraciones de retorno son opcionales.
}
int addUp = add(10 + 16); // Llama al bloque de código con argumentos.
-// Los bloques son usualmente utilizados como argumentos a funciones que son llamados
-// más adelante o para callbacks.
+// Los bloques son usualmente utilizados como argumentos a funciones que
+// son llamados más adelante o para callbacks.
@implementation BlockExample : NSObject
- (void)runBlock:(void (^)(NSString))block {
@@ -724,51 +776,72 @@ int addUp = add(10 + 16); // Llama al bloque de código con argumentos.
// Manejo de memoria
///////////////////////////////////////
/*
-Para cada objeto utilizado en una aplicación, la memoria debe de ser alocada para ese objeto. Cuando
-la aplicación termina de utilizar ese objeto, la memoria debe de ser desalocada para asegurar la
-eficiencia de la aplicación.
-Objetive-C no utiliza garbage collection, y en lugar de eso utiliza conteos de referencias. Mientras
-haya al menos una referencia del objeto (también conocido como tener un objeto de adueñado), entonces
-el objeto estará disponible para su uso.
-
-Cuando una instancia es dueña un objeto, su contador de referencia incrementa por uno. Cuando
-el objeto es liberado, el contador de referencia decrementa uno. Cuando el conteo de referencia
-es cero, el objeto es removido de la memoria.
+Para cada objeto utilizado en una aplicación, la memoria debe de ser alocada
+para ese objeto. Cuando la aplicación termina de utilizar ese objeto, la
+memoria debe de ser desalocada para asegurar la eficiencia de la aplicación.
+Objetive-C no utiliza garbage collection, y en lugar de eso utiliza conteos
+de referencias. Mientras haya al menos una referencia del objeto (también
+conocido como tener un objeto de adueñado), entonces el objeto estará
+disponible para su uso.
+
+Cuando una instancia es dueña un objeto, su contador de referencia incrementa
+por uno. Cuando el objeto es liberado, el contador de referencia decrementa uno.
+Cuando el conteo de referencia es cero, el objeto es removido de la memoria.
Con todas las interacciones de los objetos, sigue el patrón de:
(1) Crear e lobjeto, (2) utiliza el objeto, (3) libera el objeto de la memoria.
*/
-MyClass *classVar = [MyClass alloc]; // 'alloc' asigna uno al conteo de referencias de classVar. Devuelve un puntero al objeto
+MyClass *classVar = [MyClass alloc]; // 'alloc' asigna uno al conteo de
+ // referencias de classVar. Devuelve un
+ // puntero al objeto
[classVar release]; // Decrementa el conteo de referencias de classVar's
// 'retain'
-// 'retain' adueña la instancia de objeto existente e incrementa el conteo de referencia por uno. Devuelve un puntero al objeto.
-MyClass *newVar = [classVar retain]; // Si classVar es liberado, el objeto aún se queda en memoria porque newVar es el dueño.
-[classVar autorelease]; // Remueve el adueñamiento de un objeto al final del bloque @autoreleasepool. Devuelve un puntero al objeto.
-
-// @property puede utilizar 'retain' y 'assign' también para pequeñas definiciones convenientes
-@property (retain) MyClass *instance; // Libera el valor viejo y retiene uno nuevo (referencia fuerte)
-@property (assign) NSSet *set; // Apunta a un nuevo valor sin retener/liberar una referencia vieja (débil)
+// 'retain' adueña la instancia de objeto existente e incrementa el conteo de
+// referencia por uno. Devuelve un puntero al objeto.
+MyClass *newVar = [classVar retain]; // Si classVar es liberado, el objeto
+ // aún se queda en memoria porque newVar
+ // es el dueño.
+[classVar autorelease]; // Remueve el adueñamiento de un objeto al final del
+ // bloque @autoreleasepool. Devuelve un puntero al objeto.
+
+// @property puede utilizar 'retain' y 'assign' también para pequeñas
+// definiciones convenientes
+@property (retain) MyClass *instance; // Libera el valor viejo y retiene
+ // uno nuevo (referencia fuerte)
+@property (assign) NSSet *set; // Apunta a un nuevo valor sin retener/liberar
+ // una referencia vieja (débil)
// Conteo Automático de Referencias (ARC)
-// Debido a que el manejo de memoria puede ser un dolor, en Xcode 4.2 y iOS 4 se introdujo el Conteo Automático
-// de Referencias (ARC).
-// ARC es una funcionalidad del compilador que agrega retain, release y autorealase automáticamente, así que al
+// Debido a que el manejo de memoria puede ser un dolor, en Xcode 4.2 y iOS 4
+// se introdujo el Conteo Automático de Referencias (ARC).
+// ARC es una funcionalidad del compilador que agrega retain, release y
+// autorealase automáticamente, así que al
// utilizar ARC, no se debe de utilizar retain, release o autorelease.
MyClass *arcMyClass = [[MyClass alloc] init];
// ... código utilizando arcMyClass
-// Sin ARC, necesitarás llamar: [arcMyClass release] luego de terminar de utilizar arcMyClass. Pero con ARC,
-// no hay necesidad. Insertará automáticamente la declaración de liberación.
-
-// Mientras que para los atributos de @property 'assign' y 'retain', con ARC utilizarás 'weak' y 'strong'
-@property (weak) MyClass *weakVar; // 'weak' no adueña el objeto. El conteo de referencias de la instancia original
-// es fijado a ceor, weakVar autom´åticamente recibe el valor de nil para evitar cualquier 'crashing'.
-@property (strong) MyClass *strongVar; // 'strong' se adueña del objeto. Asegura que el objeto se quede en memoria.
+// Sin ARC, necesitarás llamar: [arcMyClass release] luego de terminar de
+// utilizar arcMyClass. Pero con ARC, no hay necesidad. Insertará
+// automáticamente la declaración de liberación.
+
+// Mientras que para los atributos de @property 'assign' y 'retain', con ARC
+// utilizarás 'weak' y 'strong'
+@property (weak) MyClass *weakVar; // 'weak' no adueña el objeto. El conteo de
+ // referencias de la instancia original
+// es fijado a ceor, weakVar automáticamente recibe el valor de nil para
+// evitar cualquier 'crashing'.
+@property (strong) MyClass *strongVar; // 'strong' se adueña del objeto.
+ // Asegura que el objeto se quede en memoria.
// Para variables regulares (no variables de @property), utiliza lo siguiente:
-__strong NSString *strongString; // Por defecto. La variables de retenida en memoria hasta que se salga del ámbito.
-__weak NSSet *weakSet; // Referencia débil a un objeto existente. Cuando el objeto existente es liberado, weakSet le es asginado un valor nil
-__unsafe_unretained NSArray *unsafeArray; // Como __weak, pero unsafeArray no es asginado a nil cuando el objeto existente es liberado.
+__strong NSString *strongString; // Por defecto. La variables de retenida en
+ // memoria hasta que se salga del ámbito.
+__weak NSSet *weakSet; // Referencia débil a un objeto existente. Cuando el
+ // objeto existente es liberado, weakSet le es asginado
+ // un valor nil
+__unsafe_unretained NSArray *unsafeArray; // Como __weak, pero unsafeArray no
+ // es asginado a nil cuando el objeto
+ // existente es liberado.
```
## Lecturas sugeridas