Cette page traite principalement de la notation Java / Swift des «types de base», des «expressions arithmétiques», de la «syntaxe de contrôle» et des «définitions de fonction» qui sont souvent utilisées. Cet article est basé sur 1.7 pour Java et Swift3 pour Swift, mais nous nous excusons pour les erreurs de notation.
Java
Les tableaux Java sont déclarés comme "nom de type [] nom de variable;".
python
String[] hoge;
Cependant, les tableaux Java ne sont pas des tableaux de longueur variable car ils ne peuvent pas être redimensionnés une fois qu'ils ont été initialisés et qu'une instance a été allouée dans la zone du tas. Lors de son utilisation, il est nécessaire de spécifier la taille qui peut être stockée à l'avance comme "nom de type [] nom de variable = nouveau nom de type [0];" et effectuer l'initialisation. Il est également possible de définir "nom de type [] nom de variable = {valeur, valeur, valeur ...};" comme valeur initiale en même temps que la déclaration.
Pour accéder aux éléments d'un tableau, utilisez "Nom du nombre de tableaux [index]". Le premier index commence à 0, par exemple, le dernier index d'un tableau déclaré avec une taille de "3" est "taille -1" et est "2". Si vous essayez d'opérer sur un élément qui n'est pas de taille, vous obtiendrez une exception.
python
String[] hoge = new String[3]; //Sécurisez une baie de taille 3
hoge = new String[]{"a", "b", "c"}; //Il est également possible de remplacer la valeur initiale et d'initialiser
System,out.println(hoge[1]); // "b"Et sortie
// hoge[3] = 1; //Une exception se produit lorsque vous essayez de fonctionner en dehors de la plage
Si vous modifiez la valeur après avoir récupéré les éléments du tableau, les éléments du tableau lui-même seront également affectés.
python
String[] hogeA= new String[]{"a", "b", "c"};
hogeA[0] = "x";
System.out.println(hogeA[0]); // "x"Et sortie
De plus, les tableaux Java ont des propriétés de type référence, donc si vous affectez un tableau à une variable dans un autre tableau et manipulez la variable de tableau de destination, le tableau affecté sera également affecté.
python
String[] hogeA;
String[] hogeB = new String[]{"a", "b", "c"};
hogeA = hogeB;
hogeB[0] = "x";
System.out.println(hogeB[0]); // "x"Et sortie
System.out.println(hogeA[0]); // "x"Et sortie
List La "Liste" de Java est l'un des frameworks de collection, un type qui permet de dupliquer des éléments et vous permet d'ajouter des éléments dans l'ordre. Puisque "List" est l'interface décrite plus loin, il existe principalement ArrayList et LinkedList comme types de données instanciés. Dans la déclaration de la variable List, List est une interface, alors déclarez "List <nom du type d'élément> variable name = new List interface implementation class <> ();". Spécifiez le nom de type de l'élément que vous souhaitez stocker en utilisant le générique "<>" décrit plus loin.
python
List<String> hoge = new ArrayList();
Lors de l'ajout d'un élément à la liste, "Liste variable.add (valeur)" augmentera automatiquement la taille et ajoutera l'élément. Cependant, notez que les types d'éléments qui peuvent être stockés dans les listes Java sont limités aux types d'objet et que les types primitifs (indiquant int, char, long, etc.) ne peuvent pas être stockés en tant qu'éléments. Vous pouvez accéder aux éléments de List avec "List variable name.get (index)". Vous pouvez le modifier avec "Nom de la variable.set (index, valeur)". Le premier index commence à 0, par exemple, le dernier index d'une liste de taille "3" est "Size -1" et "2". Si vous essayez d'opérer sur un élément qui n'est pas de taille, vous obtiendrez une exception.
python
List<Integer> test = new ArrayList<>();
test.add(1);
test.add(2);
test.add(3);
test.set(2, 9);
// System.out.println(test.get(3)); //Une exception se produit lorsque vous essayez de fonctionner en dehors de la plage
Si vous modifiez la valeur après avoir récupéré les éléments dans la liste, les éléments de la liste elle-même seront également affectés.
python
//* L'implémentation de la classe Test est omise
List<Test> test = new ArrayList<>();
Test a1 = new Test();
a1.a1 = "1";
test.add(a1);
Test a2 = new Test();
a2.a1 = "2";
test.add(a2);
System.out.println(test); // ["1", "2"]Est sortie
Test q = test.get(1);
q.a1 = "A";
System.out.println(test); // ["1", "A"]Est sortie
Cependant, l'exemple suivant produit les résultats suivants:
python
//* L'implémentation de la classe Test est omise
List<Test> test = new ArrayList<>();
Test a1 = new Test();
a1.a1 = "1";
test.add(a1);
Test a2 = new Test();
a2.a1 = "2";
test.add(a2);
System.out.println(test); // ["1", "2"]Est sortie
Test q = test.get(1);
Test a3 = new Test();
a3.a1 = "3";
q = a3;
System.out.println(test); // ["1", "2"]Est sortie
Dans cet exemple, lorsque le "q" obtenu par "String q = test.get (1);" est changé en "q = a3;", la référence de "q" devient a3, mais la liste " La référence à l'élément à l'index 1 de "test" indique a1. En d'autres termes, la référence a changé, donc dans cet exemple elle n'affecte pas les éléments de List "test".
De plus, Java List a une propriété de type référence, donc si vous affectez une variable List à une autre variable List et manipulez la variable List de destination d'affectation, elle sera également affectée par la variable List affectée.
python
List<Test> hogeA;
List<Test> hogeB = new ArrayList<>();
Test a1 = new Test();
a1.a1 = "1";
hogeB.add(a1);
Test a2 = new Test();
a2.a1 = "2";
hogeB.add(a2);
Test a3 = new Test();
a3.a1 = "3";
hogeB.add(a3);
hogeA = hogeB;
hogeB.get(0).a1 = "x";
System.out.println(hogeA.get(0)); // "x"Et sortie
System.out.println(hogeB.get(0)); // "x"Et sortie
Map
La "Map" de Java est l'un des frameworks de collecte et est un type qui peut stocker des valeurs au format clé-valeur. Il peut être traité comme un dictionnaire Swift. Puisque "Map" est l'interface décrite plus loin, les types de données instanciés sont principalement HashMap, TreeMap et LinkedHashMap. Dictionary est un type similaire qui peut stocker des valeurs au format clé-valeur, mais Hashtable de ce type de données est moins pratique que Map (lent, ne peut pas stocker null, etc.), et utilise désormais "Map". La plupart d'entre eux. Puisque Map est une interface pour déclarer des variables Map, déclarez "Map <nom de type de clé d'élément, nom de type de valeur d'élément> nom de variable = nouvelle classe d'implémentation d'interface de carte <> ();". Spécifiez le nom de type de l'élément que vous souhaitez stocker en utilisant le générique "<>" décrit plus loin. De plus, HashMap, TreeMap et LinkedHashMap appartiennent au package java.util, vous devez donc importer la classe à partir du package java.util lors de son utilisation.
python
Map<String, String> hoge = new HashMap();
Lors de l'ajout d'un élément à Map, "Map variable.put (key, value)" augmente automatiquement la taille et ajoute l'élément avec la clé et la valeur spécifiées. À ce stade, si une valeur de clé qui chevauche la clé existante est spécifiée, elle sera écrasée. Cependant, notez que les types d'éléments clé et valeur qui peuvent être stockés dans Java Maps sont limités aux types d'objet et que les types primitifs (indiquant int, char, long, etc.) ne peuvent pas être stockés en tant qu'éléments. Pour accéder aux éléments de Map, vous pouvez accéder avec "Map variable name.get (key)". Pour supprimer un élément, utilisez «Map variable name.remove (key)» avec la valeur de clé spécifiée.
python
Map<Integer, Integer> test = new HashMap<>(); //Étant donné que Integer est un type d'objet, il peut être spécifié comme clé d'élément et type de valeur.
test.put(1, 11);
test.put(2, 12);
test.put(3, 13);
test.put(4, 14);
test.remove(3);
System.out.println(test); // {1=11, 2=12, 4=13}Est sortie
Si vous modifiez la valeur après avoir récupéré les éléments dans la carte, les éléments de la carte elle-même seront également affectés.
python
//* L'implémentation de la classe Test est omise
Map<Integer, Test> test = new HashMap<>();
Test a1 = new Test();
a1.a1 = "1";
test.put(1, a1);
Test a2 = new Test();
a2.a1 = "2";
test.put(2, a2);
System.out.println(test); // {1=1, 2=2}Est sortie
Test q = test.get(1);
q.a1 = "A";
System.out.println(test); // {1=A, 2=2}Est sortie
Cependant, l'exemple suivant produit les résultats suivants:
python
//* L'implémentation de la classe Test est omise
Map<Integer, Test> test = new HashMap<>();
Test a1 = new Test();
a1.a1 = "1";
test.put(1, a1);
Test a2 = new Test();
a2.a1 = "2";
test.put(2, a2);
System.out.println(test); // ["1", "2"]Est sortie
Test q = test.get(1);
Test a3 = new Test();
a3.a1 = "3";
q = a3;
System.out.println(test); // ["1", "2"]Est sortie
Dans cet exemple, lorsque "q" obtenu par "Test q = test.get (1);" est changé en "q = a3;", la référence de "q" devient a3, mais il s'agit toujours de Map "test". La référence à l'élément de la clé "1" de "" indique a1. En d'autres termes, la référence a changé, donc dans cet exemple elle n'affecte pas les éléments de Map "test".
De plus, étant donné que c'est la référence de clé qui est utilisée comme clé, même si la même instance est réutilisée et ajoutée à la variable Map, elle sera considérée comme la même clé.
python
//* L'implémentation de la classe Test est omise
java.util.Map<Test, String> test = new java.util.HashMap<>();
Test a1 = new Test();
a1.a1 = "1";
test.put(a1, "A"); // (1)Ajouter une instance comme clé
a1.a1 = "2";
test.put(a1, "B"); // (2)Ajouter dans la même instance
System.out.println(test); // (2)Remplacé comme valeur ajoutée dans{2=B}Est sortie
De plus, étant donné que Java Map possède une propriété de type de référence, si vous affectez une variable Map à une autre variable Map et que vous utilisez la variable Map affectée, elle sera affectée par la variable Map affectée.
python
Map<Integer, Test> hogeA;
Map<Integer, Test> hogeB = new HashMap();
Test a1 = new Test();
a1.a1 = "1";
hogeB.put(1, a1);
Test a2 = new Test();
a2.a1 = "2";
hogeB.put(2, a2);
Test a3 = new Test();
a3.a1 = "3";
hogeB.put(3, a3);
hogeA = hogeB;
hogeB.get(1).a1 = "x";
System.out.println(hogeA.get(1)); // "x"Et sortie
System.out.println(hogeB.get(1)); // "x"Et sortie
Vous trouverez ci-dessous une comparaison des types de données Java et Swift.
Swift
Le tableau Swift déclare "var nom de variable: [type name] = []". Vous pouvez également déclarer "var variable name: Array = Array
python
var test:[Int] = [] //Pour Swift, il n'est pas nécessaire de spécifier la taille à l'avance
test.append(1) //Développé automatiquement grâce au tableau de longueur variable
Pour accéder aux éléments d'un tableau, utilisez "nom de la variable du tableau [index]". Le premier index commence à 0, par exemple, le dernier index d'un tableau déclaré avec une taille de "3" est "taille -1" et est "2".
Si vous modifiez la valeur après avoir récupéré les éléments du tableau, les éléments du tableau lui-même seront également affectés.
python
var test:[Int] = [1, 2, 3]
test[0] = 9
print(test); // [9, 2, 3]Et sortie
Cependant, l'exemple suivant produit les résultats suivants:
python
//* L'implémentation de la classe Test est omise
var a1 = Test(a1: 1)
var a2 = Test(a1: 2)
var a3 = Test(a1: 3)
var test:[Test] = [a1, a2, a3]
print(test); // [Test(a1: 1), Test(a1: 2), Test(a1: 3)]Et sortie
var q = test[0]
var temp:Test = Test(a1: 9)
q = temp
print(test); // [Test(a1: 1), Test(a1: 2), Test(a1: 3)]Et sortie
Dans cet exemple, lorsque "q" obtenu par "var q = test [0]" est remplacé par "q = temp", la référence de "q" devient temp, mais l'indice 1 du tableau "test" est toujours utilisé. L'élément référence à indique a1. En d'autres termes, la référence a changé, donc dans cet exemple elle n'affecte pas les éléments de Map "test".
Cependant, cela ne s'applique pas lors de la réécriture directe, comme "test [0] = Test (a1: 9)".
//* L'implémentation de la classe Test est omise
var a1 = Test(a1: 1)
var a2 = Test(a1: 2)
var a3 = Test(a1: 3)
var test:[Test] = [a1, a2, a3]
print(test); // [Test(a1: 1), Test(a1: 2), Test(a1: 3)]Et sortie
test[0] = Test(a1: 9)
print(test); // [Test(a1: 9), Test(a1: 2), Test(a1: 3)]Et sortie
print(a1); // [Test(a1: 1)Et sortie
De plus, contrairement à Java, les tableaux Swift sont des types valeur plutôt que des types référence. Si vous affectez un tableau à une variable dans un autre tableau et manipulez la variable de tableau de destination, le tableau affecté ne sera pas affecté.
python
var test1:[Int] = [1, 2, 3]
var test2:[Int] = [4, 5, 6]
test2 = test1 //Assigner à une autre variable de tableau(※1)
test1[0] = 9
print(test1); // [9, 2, 3]Et sortie
print(test2); // (※1)Parce que le tableau lui-même est un type valeur[1, 2, 3]Est sortie
Un dictionnaire est un type qui peut stocker des valeurs au format clé-valeur. Déclarez "var nom de variable: [nom du type de clé d'élément, nom du type de valeur d'élément] = [:]". Vous pouvez également déclarer "var variable name: Dictionary <element key type name, element value type name> = [:]". Il est également possible de définir "var nom de variable: Dictionary <nom de type de clé d'élément, nom de type de valeur d'élément> = [clé d'élément: valeur d'élément, clé d'élément: valeur d'élément ...]" comme valeur initiale en même temps que la déclaration.
python
var test1:[Int:String] = [:]
var test2:Dictionary = Dictionary<Int, String>() //Il est également possible de le déclarer comme indiqué à gauche
Lors de l'ajout d'un élément au dictionnaire, "Nom de la variable du dictionnaire [clé de l'élément] = valeur de l'élément" ajoutera l'élément au dictionnaire existant. À ce stade, si une valeur de clé qui chevauche la clé existante est spécifiée, elle sera écrasée. L'élément est supprimé en spécifiant la valeur "nil" avec "Dictionary variable name [key] = nil" avec la valeur de clé spécifiée. Pour accéder aux éléments du dictionnaire, utilisez "Nom de la variable du dictionnaire [clé]".
Si vous modifiez la valeur après avoir récupéré les éléments dans le dictionnaire, les éléments du dictionnaire lui-même seront également affectés.
python
//* L'implémentation de la classe Test est omise
var items: Dictionary<Int, Test> = [:]
items[1] = Test(a1: 1)
print(items[1]!.a1) //Est sortie comme 1
var q = items[1]!
q.a1 = 9
print(items[1]!.a1) //Est sortie comme 9
Cependant, l'exemple suivant produit les résultats suivants:
python
//* L'implémentation de la classe Test est omise
var items: Dictionary<Int, Test> = [:]
var a1 = Test(a1: 1)
items[1] = a1
print(items[1]!.a1) //Est sortie comme 1
var q:Test = items[1]!
var a3:Test = Test(a1: 9)
q = a3
print(items[1]!.a1) //Est sortie comme 1
Dans cet exemple, lorsque "q" obtenu par "var q: Test = items [1]!" Est changé en "q = a3", la référence de "q" devient a3. Pourtant, la clé du dictionnaire "test" La référence à l'élément "1" indique a1. En d'autres termes, la référence a changé, donc dans cet exemple elle n'affecte pas les éléments de Map "test".
Cependant, cela ne s'applique pas lors de la réécriture directe, comme "test [1] = Test (a1: 9)".
//* L'implémentation de la classe Test est omise
var items: Dictionary<Int, Test> = [:]
var a1 = Test(a1: 1)
items[1] = a1
print(items[1]!.a1) //Est sortie comme 1
items[1] = Test(a1: 9)
print(items[1]!.a1) //Est sortie comme 9
print(a1.a1) //Est sortie comme 1
En outre, la valeur d'élément peut spécifier n'importe quel type de données, mais si vous souhaitez spécifier un objet en tant que clé, l'objet clé doit implémenter le protocole Hashable.
python
///Doit être conforme au protocole hashable pour utiliser TestClass comme clé de dictionnaire
public class TestClass : Hashable {
var a1:String = ""
init (a1:String) {
self.a1 = a1
}
///Les valeurs de hachage sont utilisées dans l'implémentation Equatable
public var hashValue: Int {
get {
///Si cette valeur de hachage est la même, elle sera traitée comme la même dans le dictionnaire.
return a1.hashValue
}
}
}
///Implémentation équatable de TestClass
func == (lhs:TestClass, rhs:TestClass) -> Bool {
return lhs.hashValue == rhs.hashValue
}
python
var items: Dictionary<TestClass, Int> = [:]
var a1:TestClass = TestClass(a1 : "A")
var a2:TestClass = TestClass(a1 : "B")
var a3:TestClass = TestClass(a1 : "C")
var a4:TestClass = TestClass(a1 : "D")
var a5:TestClass = TestClass(a1 : "A")
items[a1] = 1
items[a2] = 2
items[a3] = 3
items[a4] = 4
items[a5] = 5
for (k, v) in items { // A : 5、B : 2、C : 3、D :Est sortie comme 4
print(k.a1 + " : " + v.description)
}
Dans l'exemple ci-dessus, une autre instance est créée avec "var a1: TestClass = TestClass (a1:" A ")" et? "Var a5: TestClass = TestClass (a1:" A ")" et le dictionnaire "items" "A1" et "a5" ont été traités comme la même clé même s'ils ont été ajoutés. Cela est dû au fait que la classe Test créée en tant que clé ci-dessus utilise «TestClass.a1.hashValue» pour la vérification de correspondance de clé, et si elle correspond, elle est implémentée afin qu'elle soit considérée comme la même clé. est.
Un taple est un type de données plus facile à gérer qu'une structure et est un ensemble de valeurs multiples. Une spécification de langage qui n'existe pas en Java. Cela peut être utile, en particulier lorsqu'il s'agit de groupes de valeurs associées qui sont utilisées temporairement, comme la valeur de retour d'une fonction qui renvoie la largeur et la hauteur de la taille de l'écran. Les fonctionnalités sont répertoriées ci-dessous.
Spécifiez "var nom de variable: (nom du type, nom du type, nom du type ...)" dans la déclaration, et décrivez le type que vous souhaitez gérer comme taple entre parenthèses "()". Il est également possible de définir la valeur initiale au moment de la déclaration comme "var variable name: (type name, type name) = (value, value)". De plus, il est possible de donner un nom externe aux membres que vous souhaitez combiner, et il dit "var nom de variable: (nom externe: nom de type, nom externe: nom de type) = (nom externe: valeur, nom externe: valeur)". Peut être décrit comme
python
var test1:(name:String, age:Int) //Peut être facilement compris en donnant un nom externe
test1 = (name:"NYANKO", age:100)
print(test1.name) //Vous pouvez également accéder à l'aide d'un nom externe
let test2:(String, Int) = ("WANKO", 2) //Il est possible de déclarer sans donner de nom externe, et il est possible de remplacer par correspondance de motifs.
print(test2.1) //L'index peut être utilisé lors de l'accès
if (test2 == ("WANKO", 2)) { //La comparaison par correspondance de motifs est également possible
print("same.")
}
Swift fournit des structures pour réaliser facilement l'encapsulation. Il excelle dans la gestion de données simples et est souvent utilisé pour représenter des structures de données telles que la valeur de retour d'une fonction qui renvoie la largeur et la hauteur de la taille de l'écran. Au moment de la définition, il est défini comme "nom de structure struct {...}", et les membres sont définis dans les blocs de la structure. Déclarez "var structure variable name = structure ()" dans la déclaration. La structure a un constructeur par défaut, et il est également possible de l'initialiser en tant que nom externe pendant le processus d'initialisation en utilisant le nom de variable du membre défini dans la structure. Les fonctionnalités sont répertoriées ci-dessous.
Les structures sont similaires en termes d'utilisation aux classes, mais la différence majeure par rapport aux classes est que la valeur de la structure ≒.
Si la classe crée une instance et l'affecte à "Variable A" et à une autre "Variable B", l'opération sera effectuée sur l'instance. Par exemple, l'instance "Yoshiko" est parfois "nettoyage tante" variable A "" et parfois "voleur fantôme femme mûre quatorze" variable B "", mais comme "tante nettoyante" Takano Yuri Beauty Clinic a une grosse poitrine. Si vous êtes opéré, le buste de "Phantom Thief Mature Woman Fourteen" augmentera également. Au contraire, si la structure est affectée à la "variable A '" et à une autre "variable B'", elle sera traitée comme une valeur différente.
python
public class TestClass {
var a1:String = ""
}
public class TestStruct {
var a1:String = ""
}
var testStruct:TestClass = TestClass() //Déclarer la structure
var testClass:TestClass = TestClass() //Déclarer une instance de la classe
testStruct.a1 = "ABC"
testClass.a1 = "ABC"
var assignmentStruct = testStruct //Structure de substitution
var assignmentClass = testClass //Attribuer une instance de la classe
assignmentStruct.a1 = "DEF"
assignmentClass.a1 = "DEF"
print(testStruct.a1) //Parce que la structure est copiée"ABC"Est sortie
print(testClass.a1) //La classe reçoit une référence, elle est donc affectée par la destination de l'affectation"DEF"Est sortie
struct TestStruct {
var a1:String = ""
}
class TestClass {
var a1:String = ""
}
Swift vous permet d'utiliser des types existants avec des alias.
public typealias hoge1 = Int
public typealias hoge2 = (String, Int, Int)
var a1:hoge1 = 1
var a2:hoge2 = ("ABC", 1, 2)
print(a1)
print(a2)
Java et Swift ont la même notation d'opération à quatre règles, et l'opérateur de comparaison et la notation d'incrémentation / décrémentation sont également les mêmes, donc si vous êtes familier avec l'un ou l'autre, vous devriez être capable de le comprendre sans problème.
Java
python
int test = 1;
if (test == 1) {
System.out.println("1");
} else if (test == 1) {
System.out.println("2");
} else {?
System.out.println("3");
}
Swift Lors de l'écriture d'une expression conditionnelle, vous pouvez ajouter "(expression conditionnelle)" entre parenthèses, mais c'est une notation générale de ne pas l'ajouter.
python
var test = 1;
if test == 1 {
print("1")
} else if test == 1 {
print("2")
} else {
print("3")
}
Java
Java ne peut utiliser que char, byte, short, int, Character, Byte, Short, Integer, String (JDK 1.7 ou version ultérieure) ou enum pour évaluer les instructions switch. Après avoir traité le bloc de l'instruction case avec le résultat d'évaluation correspondant, vous pouvez sortir de la branche conditionnelle du commutateur en plaçant une instruction break explicite. Par conséquent, si plusieurs valeurs d'évaluation effectuent le même traitement, la rupture n'est pas décrite.
python
int test = 1;
switch(test) {
case 1:
case 2:
System.out.println("A");
break;
case 3:
System.out.println("C");
break;
default:
System.out.println("D");
}
Swift
Contrairement à Java, il est possible de définir des expressions et des valeurs (variables) dans la cible d'évaluation «commutateur (évaluation)», et de définir des chaînes de caractères, des expressions, etc. en plus des nombres entiers dans le résultat de l'évaluation «valeur d'évaluation de cas:». est. De plus, aucune instruction break explicite n'est requise, et si le traitement sous l'instruction case du résultat d'évaluation correspondant est effectué, le traitement sous les autres instructions case ne sera pas effectué. Par conséquent, si plusieurs valeurs d'évaluation effectuent le même traitement, décrivez les valeurs d'évaluation en "cas" séparées par des virgules.
python
var test:Int = 1
switch test {
case is Test:
//Si le type est Test
print("A")
case is Int:
//Si le type est Int
print("B")
case 1111, 2222:
//Si la valeur est 1111 ou 2222
//Cependant, si le type de test n'est pas Int en premier lieu, "Modèle d'expression de type"'Int'ne peut pas correspondre aux valeurs de type ~ ",
print("C")
default:
print("D")
}
Java
La forme de base est décrite comme suit.
python
for (int i = 0; i < 10; i++) {
System.out.println(i);
}
Si vous souhaitez inspecter les éléments un par un, vous pouvez utiliser l'instruction étendue for. Il peut être utilisé avec des instances de classes qui implémentent l'interface Iterable, des tableaux, etc.
python
List<Integer> list = new ArrayList(); //List implémente Iterable, donc les instructions étendues peuvent être utilisées
for (Integer item : list) {
System.out.println(i);
}
Swift
La forme de base est décrite comme suit.
python
for i in 0 ..< 10 {
print(i)
}
Si vous souhaitez inspecter les éléments un par un, vous pouvez utiliser l'instruction étendue for. Il peut être utilisé pour les instances de classes qui ont une implémentation du protocole SequenceType et pour les tableaux.
python
for (item in 1..10) {
print(i)
}
Dans le cas de Swift, la notation est la même pour Java et Swift, sauf que "(expression conditionnelle)" et les parenthèses peuvent être omis, donc si vous êtes familier avec l'un ou l'autre, vous pouvez le comprendre sans problème.
Java
La notation lors de la définition d'une fonction en Java est la suivante.
python
//Modificateur d'accès Type de retour Nom de la fonction(Type d'argument Nom de la variable d'argument) {
//return Valeur de retour;
// }
private int test(int value) {
return value;
}
//Comment appeler
test(1);
--Si la valeur de retour n'existe pas, spécifiez "void" pour "Return type". --En Java, la valeur de retour ne peut pas être définie sur taple ou sur plusieurs valeurs, donc la valeur de retour doit être un type primitif (int, char, long, etc.) ou un type d'objet. --Java n'a pas de "nom externe" comme argument dans Swift, et lors de l'appel d'une fonction, il est nécessaire de faire correspondre le modèle en faisant correspondre le type, le nombre et l'ordre des arguments de fonction définis.
De plus, comme note spéciale, en Java, les arguments passés à la fonction ne sont pas strictement passés par référence, mais je pense qu'il est bon de comprendre que la valeur passée peut être manipulée à l'intérieur de la fonction de fonction. Par exemple, si vous l'utilisez pour recréer une instance dans une fonction, vous pouvez voir qu'elle n'est pas réellement passée par référence.
python
Test test = new Test();
test.a1 = "1";
Test newTest = newTest(test);
System.out.print(test); //1 est la sortie
System.out.print(newTest); //null est sorti
private Test newTest(Test test) {
test = new Test(); //Une nouvelle référence est créée
test.a1 = "2";
return test;
}
De plus, dans le cas d'arguments immuables, la valeur de l'appelant ne change pas même si la valeur de l'argument est manipulée dans la fonction.
python
int value = 1;
test(value);
System.out.println(a); //1 est la sortie
private void test(int value) {
value = 2;
}
Swift
La notation lors de la définition d'une fonction dans Swift est la suivante.
python
//nom de la fonction func(Nom externe Nom de la variable d'argument:Type d'argument=Valeur par défaut) ->Type de retour{
//return Valeur de retour;
// }
private func test(test value:Int = 9) -> Int {
return value;
}
//Comment appeler
test(test:1);
Dans Swift, les arguments passés à la fonction sont passés par valeur, mais il existe un moyen de passer par référence.
python
var a = 1
test(&a)
print(a) //Le résultat est "2" car il a été passé par référence.
func test(value:inout Int) {
a = 2
}
De plus, Swift peut traiter les fonctions comme des valeurs. Par exemple, les informations de type d'une fonction qui a un argument de chaîne et qui renvoie la valeur de retour de la chaîne peuvent être exprimées sous la forme "(String) -> String".
python
let funcTest:(String)->String = test // func test(name:String) -> String {...}Dans funcTest
let message = funcTest("Swift") //Test Func à partir de la variable qui stocke la fonction(name:String) -> String {...}Appel
print(message)
//une fonction
func test(name:String) -> String {
return "Bonjour" + name + "M."
}
Vous pouvez également passer une fonction à une fonction car elle peut être traitée comme une valeur dans Swift.
python
let funcTest:(String)->String = test // func test(name:String) -> String {...}Dans funcTest
callTest(name: "Java", function: funcTest) // callTest(name:String, function:(String)->String) {...}Appel
//une fonction
func test(name:String) -> String {
return "Bonjour" + name + "M."
}
//Test remis(name:String) ->Fonction pour exécuter String
func callTest(name:String, function:(String)->String) {
let message = function(name) //Test remis(name:String) ->Appel de chaîne
print(message)
}
Il est également possible de définir et d'utiliser une fonction à l'intérieur d'une fonction.
//Méthode d'exécution
func exe() {
let value = test(value1: 5, value2:3) //Appel de fonction
print(value.0)
print(value.1)
}
//Fonctions qui ont des fonctions à l'intérieur
func test(value1:Int, value2:Int) -> (Int, Int) {
//Fonction interne(1)
func add(value1:Int, value2:Int) -> Int {
return value1 + value2
}
//Fonction interne(2)
func subtract(value1:Int, value2:Int) -> Int {
return value1 - value2
}
let result1 = add(value1: value1, value2: value2) //Fonction interne(1)Obtenez le résultat de
let result2 = subtract(value1: value1, value2: value2) //Fonction interne(2)Obtenez le résultat de
return (result1, result2)
}
Puisque Swift vous permet d'implémenter des fonctions anonymes, vous pouvez également définir des fonctions anonymes dans des variables. Les fonctions anonymes peuvent être utilisées sans déclarer de fonction (sans donner de nom de fonction) et peuvent être gérées comme suit.
python
// {(Nom de l'argument:Nom du type d'argument) -> (Nom du type de retour) in
// //En traitement
//return Valeur de retour
// }
// (1)Lorsqu'il n'y a aucun argument et aucune valeur de retour
let closure1 = {() -> () in
print("test1")
}
closure1() // "test1"Et sortie
// (2)Aucun argument, valeur de retour String
let closure2 = {() -> String in
return "test2"
}
print(closure2()) // "test2"Et sortie
// (3)Pour les arguments String, Int, retournez String
let closure3 = {(param1:String, param2:Int) -> String in
return param1 + param2.description
}
print(closure3("test", 3)) // "test3"Et sortie
// (4)Lors de l'utilisation de l'inférence de type au moment de l'appel sans spécifier le type d'argument En cas de valeur de retour Int
let closures4:(String, Int) -> String
closures4 = {(param1, param2) -> String in
return param1 + param2.description
}
print(closures4("test", 4)) // "test4"Et sortie
Vous pouvez passer un littéral de fonction en tant qu'argument à une fonction. Il n'est pas nécessaire de déclarer des fonctions séparées, par exemple lorsque vous souhaitez effectuer chaque traitement en fonction de l'appelant après avoir exécuté le traitement de fonction dans lequel la fonction est déclarée.
python
//Méthode d'exécution
func exe() {
//Calcul de la surface triangulaire(Vertical x horizontal ÷ 2)Dans une variable en tant que fonction anonyme
var calcTriangle = { (width:Int, height:Int) -> (Int) in
return width * height / 2
}
//Calcul de la surface du rectangle(Vertical x horizontal)Dans une variable en tant que fonction anonyme
var calcRctangle = { (width:Int, height:Int) -> (Int) in
return width * height
}
print(calcAreaScreenRect(areaLogic: calcTriangle)) //Calcul de surface triangulaire Appelle la fonction de calcul de surface par taille d'écran avec une fonction anonyme comme argument
print(calcAreaScreenRect(areaLogic: calcRctangle)) //Appelez la fonction de calcul de surface pour chaque taille d'écran avec la fonction anonyme de calcul de surface rectangulaire comme argument
}
///Calcul de la surface par taille d'écran
func calcAreaScreenRect(areaLogic:(Int, Int) -> (Int)) -> Int{
let rect = UIScreen.main.bounds;
return areaLogic(Int(rect.width), Int(rect.height))
}
Les fonctions anonymes peuvent également accéder à la variable appelante en raison des caractéristiques de la portée lexicale. Utilisez une fonction anonyme comme argument
python
var message = "Hello"
var printHello = {
print(message) //La fonction anonyme peut accéder au message
}
printHello() // "Hello"Et sortie
Comme expliqué dans la déclaration de fonction, vous pouvez utiliser une fonction déclarée comme un nombre d'intervalle comme argument, même si ce n'est pas une fonction anonyme. Une telle fonction est appelée une fonction d'ordre supérieur.
La fermeture (fermeture de fonction) est, en un mot, la définition d'une fonction au sein d'une fonction. Plus précisément, il se réfère à un "objet fonction réalisé par une fonction anonyme". Puisque Swift peut utiliser des fonctions anonymes, il est possible d'utiliser des fermetures.
python
func getCounter()->()->Int {
var counter = 0
//Fonction anonyme
let countUp = { ()->Int in
counter += 1
return counter
}
return countUp
}
Dans l'exemple ci-dessus, une fonction appelée "getCounter" est déclarée de sorte qu'une fonction anonyme est définie en interne et cette fonction est renvoyée. L'appel de cette fonction a le résultat suivant:
python
let funcGetCounter:()-> Int = getCounter() //Fonction anonyme de la valeur de retour de getCounter
print(funcGetCounter()) // "1"Est sortie
print(funcGetCounter()) // "2"Est sortie
print(funcGetCounter()) // "3"Est sortie
La fonction anonyme stockée dans "let funcGetCounter" est comptée chaque fois qu'elle est appelée. De cette façon, le "var counter" de la fonction "getCounter" référencé par la fonction anonyme dans la portée lexicale est conservé jusqu'à ce que la référence "let funcGetCounter" soit perdue, et peut être utilisé comme une instance d'une classe.
Recommended Posts