Définir “cyclique de structures de données”

À la JSON site il dit

JSON ne prend pas en charge cyclique de données
structures, donc soyez prudent de ne pas donner
cyclique des structures pour le JSON
stringifier.

Que faut-il dire par là? Quelqu'un peut-il me donner un exemple d'une telle structure de données en Javascript?

InformationsquelleAutor Earlz | 2010-06-09

var cyclic = {};
cyclic.somekey = cyclic;
cyclic.another = "Hello world!";

Maintenant, vous pouvez le faire, par exemple:

alert(cyclic.somekey.somekey.somekey.another);

InformationsquelleAutor liori

8

Si vous imaginez que les membres de la structure de données définie comme un graphe cyclique structure de données est l'endroit où un membre se réfère à un autre, ou même de la structure.

Par exemple:
```
var obj = new Object();

obj.left = new Object();

obj.left.left = obj;
```
Il est impossible de le représenter en JSON, vous devez vous référer à l'extérieur {} partie en quelque sorte:
```
{ "left": { "left": ??? } }
```
InformationsquelleAutor Skurmedel
2

L'objet contient un cycle, c'est à dire, il se réfère à lui-même ou, plus généralement, d'un objet auquel il se réfère, soit directement ou par l'intermédiaire d'une propriété est l'objet d'origine.
```
 var $this =  { };
 $this["self"] = $this;
```
ou, plus probablement,
```
 var child = { parent: null };
 var parent = { child: child };
 child.parent = parent;
```
InformationsquelleAutor tvanfosson
2

Cyclique structure de données est une structure qui contient une référence à lui-même (directement ou indirectement).
Voir aussi http://en.wikipedia.org/wiki/Circular_reference

Voici un exemple d'une telle structure:
```
var c = { value: 'abc' };
c['c'] = c;
c['a'] = { value: c };
```
Si vous essayez d'imprimer sa représentation sous forme de chaîne de manière récursive, vous allez vous retrouver avec un débordement de pile, parce que pour imprimer une valeur de c vous devez imprimer la valeur de c.

InformationsquelleAutor Kru
1

Une structure de données cyclique graphique: http://en.wikipedia.org/wiki/Cycle_graph
- C'est juste une définition de ce qu'est un cycle, il n'y a pas de JS exemple. L'article est sur les graphiques, même si elles sont liées au problème, ce n'est pas directement répondre à la question.
InformationsquelleAutor Danny Varod

js> var a = {label:"a", next:null};
js> var b = {label:"b", next:a};
js> a.next = b; //cycle is created here
[object Object]
js> print(a.next.label);
b
js> print(a.next.next.label);
a
js> print(a.next.next.next.label);
b
js> print(a.next.next.next.next.label);
a

InformationsquelleAutor el.pescado

1

Je suppose que l'exemple classique d'une structure cyclique est le liste à double liaison. Chaque élément de points à la précédente et la suivante éléments dans la liste. Cela signifie que chaque élément forme un cycle avec le précédent et suivant de l'élément.
```
A --> B  --> C
A <-- B  <-- C
```
(Ici, chacun A, B, C bien écrit deux fois, c'est un objet).

Un des points de B, comme le suivant dans la liste. B points à Un précédent dans la liste. Il y a donc un cycle de A à B et à A. La même chose est vraie pour tout élément dans la liste, avec des éléments pas la tête ou la queue beloning à deux cycles.

Une solution de sérialisation des listes de ce genre est d'utiliser des Identifiants pour représenter chaque objet. Cela supprime les cycles dans la structure. On pourrait alors écrire
```
  list: {
     items:
      { id:"a", value1: ... etc },
      { id:"b", values .... },
      { id:"c", values .... }
     links:
       { elem:"a", next:"b" },
       { elem:"b", next:"c", prev: "a"},
       { elem:"c", prev:"b" }
  }
```
InformationsquelleAutor mdma
1

CYCLE: UNE situation dans laquelle vous retournez à l'endroit même où vous avez commencé.

CYCLIQUE STRUCTURE de DONNÉES: UNE structure de données dans laquelle une telle situation pourrait se produire. Par exemple graphique,liste chaînée (individuellement/doublement), file d'attente, etc.

Une liste liée nœud dans le JS est mis en œuvre comme:
```
function Node(data){
    this.data = data;
    this.next = null;
}
```
Maintenant j'ai créer deux nœuds comme indiqué ci-dessous:
```
var node1 = new Node(10);
var node2 = new Node(20);
```
Et le lien entre eux pour former un cycle.
```
node1.next = node2;
node2.next = node1;
```
La suite de la traversée de code va entrer dans une boucle infinie qui montre l'existence d'un cycle.
```
node = node1;
while(node!==null){
    print(node.data);
    node = node.next;
}
```
InformationsquelleAutor ojas mohril
-2

si vous avez:
```
var a = {value: 'a'};
var b = {value: a};
var c = {value: a};
```
En JSON pour b, il devrait ressembler à:
```
"{value: {value: 'a'}}"
```
En JSON pour le c, il devrait ressembler à:
```
"{value: {value: 'a'}}"
```
Pas de pointeurs.
- Il n'y a pas de cycle.
- Oh la droite. Juste démontrant les pointeurs, je suppose. Mon mauvais.
InformationsquelleAutor Daniil

Vous devez vous connecter pour publier un commentaire.