Hướng dẫn css line arrow generator - trình tạo mũi tên dòng css

Tìm hiểu cách tạo mũi tên với CSS.

Mũi tên bên phải:

Mũi tên trái:

Mũi tên lên:

Mũi tên xuống:

Cách tạo mũi tên

Bước 1) Thêm HTML:

Thí dụ

Mũi tên phải: Mũi tên trái: Mũi tên lên: Mũi tên xuống:

Left arrow:

Up arrow:

Down arrow:

Bước 2) Thêm CSS:

Thí dụ

Mũi tên phải: Mũi tên trái: Mũi tên lên: Mũi tên xuống:
  border: solid black;
  border-width: 0 3px 3px 0;
  display: inline-block;
  padding: 3px;
}

Bước 2) Thêm CSS:
  transform: rotate(-45deg);
  -webkit-transform: rotate(-45deg);
}

.arrow {& nbsp; Biên giới: Đen rắn; & nbsp; Độ rộng biên giới: 0 3px 3px 0; & nbsp; Hiển thị: Inline-Block; & nbsp; Đệm: 3px;}
  transform: rotate(135deg);
  -webkit-transform: rotate(135deg);
}

.right {& nbsp; biến đổi: xoay (-45deg); & nbsp; -WebKit-Transform: ROTATE (-45DEG);}
  transform: rotate(-135deg);
  -webkit-transform: rotate(-135deg);
}

.left {& nbsp; Biến đổi: Xoay (135deg); & nbsp; & nbsp;
  transform: rotate(45deg);
  -webkit-transform: rotate(45deg);
}

.up {& nbsp; Biến đổi: ROTATE (-135DEG); & nbsp; & nbsp;

Tôi đang cố gắng tạo ra một đường ngang thẳng với sự cố ở giữa để hiển thị một mũi tên. Ý tưởng là nội dung được hiển thị trong dòng sẽ cung cấp chi tiết về nội dung được hiển thị phía trên dòng. Đây là những gì dòng sẽ trông như thế nào:

Tôi đang cố gắng tạo ra điều này với HTML và CSS thuần túy (không có hình ảnh bitmap). Việc sử dụng phông chữ tuyệt vời là chấp nhận được nếu nó kết thúc kết quả đúng. Tôi cần kiểm soát độ dày và màu sắc của dòng. Góc của sự cố không quan trọng (45 và 90 độ trên mẫu hiển thị ở trên). Tôi biết về thủ thuật tam giác CSS này, nhưng tôi không thể nghĩ ra cách áp dụng nó vào kịch bản này.

web-tiki

94,4K31 Huy hiệu vàng211 Huy hiệu bạc243 Huy hiệu Đồng31 gold badges211 silver badges243 bronze badges

Hỏi ngày 2 tháng 4 năm 2013 lúc 23:51Apr 2, 2013 at 23:51

Ismael Ghalimiismaael GhalimiIsmael Ghalimi

3,4462 Huy hiệu vàng21 Huy hiệu bạc25 Huy hiệu Đồng2 gold badges21 silver badges25 bronze badges

1

Hiệu ứng tốt đẹp này có thể đạt được bằng cách sử dụng các thuộc tính CSS

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

Đã trả lời ngày 2 tháng 4 năm 2013 lúc 23:54Apr 2, 2013 at 23:54

4

Một giải pháp với nền mũi tên trong suốt, cho phép bạn sử dụng nó với mọi nền:

HTML:

CSS:

.side-line {
    display: inline-block;
    border-top: 1px solid black;
    width: 20%;
}

.triangle {
    display: inline-block;
    height: 7px;
    width: 7px;
    transform: rotate(45deg);
    transform-origin: center center;
    border-top: 1px solid black;
    border-left: 1px solid black;
    margin: 0 -3px -3px;
}

Bản demo trực tiếp: http://jsfiddle.net/85saaphw/ http://jsfiddle.net/85saaphw/

Đã trả lời ngày 9 tháng 2 năm 2016 lúc 9:16Feb 9, 2016 at 9:16

Itayaitayaitaya

Phù hiệu bằng đồng 1971 Silver71 silver badge7 bronze badges

Bản trình diễn

Giới thiệu

Bảng thông tin

• Thư viện đồ thị đầy đủ tính năng được viết bằng JS thuần túy
• Giấy phép nguồn mở cho phép (MIT) cho Thư viện Cytoscape.js Core và tất cả các tiện ích mở rộng của bên thứ nhất
• Được sử dụng trong các dự án thương mại và các dự án nguồn mở trong sản xuất
• Được thiết kế cho người dùng đầu tiên, cho cả ứng dụng Frontfaces usecase và nhà phát triển Usecase
• Tối ưu hóa cao
• Tương thích với
• Tất cả các trình duyệt hiện đại
• Trình duyệt Legacy với hỗ trợ ES5 và Canvas
  • Hỗ trợ ES5 và Canvas là bắt buộc và phát hiện tính năng được sử dụng để cải tiến hiệu suất tùy chọn.
  • Trình duyệt vào khoảng năm 2012 Hỗ trợ ES5 Hoàn toàn: IE10, Chrome 23, Firefox 21, Safari 6 (Caniuse)
  • Các trình duyệt có hỗ trợ ES5 một phần nhưng đầy đủ cũng hoạt động, chẳng hạn như IE9 và Firefox 4.
  • Các tài liệu và ví dụ không được tối ưu hóa cho các trình duyệt cũ, mặc dù chính thư viện là. Một số bản demo có thể không hoạt động trong các trình duyệt cũ để giữ cho mã demo đơn giản.
• Hệ thống mô -đun
  • Mô -đun ES
  • UMD
    • CommonJS/Node.js
    • Quả cầu
    • AMD/Require.js
• Người quản lý gói
  • NPM
  • sợi
  • Bower
• Hỗ trợ ngôn ngữ R thông qua RCYJS
• Hỗ trợ kết xuất hình ảnh của biểu đồ trên Node.js với Cytosnap
• Có một bộ thử nghiệm lớn có thể chạy trong trình duyệt hoặc thiết bị đầu cuối
• Tài liệu bao gồm các ví dụ mã trực tiếp, nhân đôi như một đặc tả yêu cầu tương tác; Biểu đồ ví dụ cũng có thể được sửa đổi tự do trong bảng điều khiển của bạn
• Hoàn toàn có thể nối tiếp và khó chịu thông qua JSON
• Sử dụng bố cục cho các nút định vị tự động hoặc thủ công
• Hỗ trợ các bộ chọn để lọc và truy vấn đồ thị Terse
• Sử dụng bảng hiệu kiểu để phân tách bản trình bày khỏi dữ liệu theo cách kết xuất bất khả tri
• Tóm tắt và thống nhất các sự kiện cảm ứng trên đầu mô hình sự kiện quen thuộc
• Hỗ trợ tích hợp cho các cử chỉ tiêu chuẩn trên cả máy tính để bàn và cảm ứng
• Chuỗi để thuận tiện
• Hỗ trợ các mẫu lập trình chức năng
• Hỗ trợ các hoạt động lý thuyết đặt
• Bao gồm các thuật toán lý thuyết đồ thị, từ BFS đến PageRank
• Các yếu tố biểu đồ và chế độ xem có thể hoạt hình
• Có thể mở rộng hoàn toàn (và tiện ích mở rộng có thể được tự động hóa cho bạn)
• Duy trì tốt
  • Cadence phát hành bản vá hàng tuần
  • Cadence phát hành tính năng hàng tháng
• Được liệt kê bởi Zenodo cho DOI phiên bản Per-Phiên bản
• Được liệt kê bởi các công cụ OMIC

Người sử dụng cytoscape.js

Công nghệ tên tuổi lớn

• Amazon
• Quỹ phần mềm Apache
• Cặp đôi
• đàn hồi
• Fujitsu
• Google
• Hewlett Packard Enterprise
• IBM
• Quỹ Linux
• Meta
• Microsoft
• MongoDB
• Con rối
• Mũ đỏ
• Tencent
• Uber

Chính quyền

• DARPA
• GCHQ
• NHS
• NOAA
• NSA

Tài nguyên nghiên cứu

• Apid
• Araqtl
• Vòm
• Biocyc
• Biogrid
• BIOPLEX
• cbioportal
• Đồng thuận
• DSYSMAP
• Elsevier
• Bao gồm
• Flybase
• ngân hà
• Genemania
• GraphSpace
• Xen kẽ
• Metagenomescope
• NDEX
• Newt
• OpenBio
• Con đường Commons
• Pinet
• Plotly (Dash)
• Quantstack (Jupyter)
• Cổ phiếu
• Synbiohub
• Hiệp hội bản thể gen
• Wormbase

Nghiên cứu & phi lợi nhuận

• Đại học Aalto
• Đại học Albert Ludwig của Freiburg
• Trung tâm siêu máy tính Barcelona
• BBC
• Đại học Ben-Gurion của Negev
• Phòng thí nghiệm Berkeley
• Viện rộng
• Carnegie Mellon
• Viện Earlham
• École Polytechnique Fédérale de Lausanne (EPFL)
• Trung tâm y tế Erasmus
• Phòng thí nghiệm sinh học phân tử châu Âu (EMBL)
• Fairplus
• Học viện Công nghệ Georgia
• Getty
• đại học Harvard
• Hop
• Viện Y khoa Howard Hughes
• Phòng thí nghiệm quốc gia Idaho
• đại học Indiana
• Inrae
• Học viện Curie
• Viện Sinh học Hệ thống
• Viện nghiên cứu gạo quốc tế
• Đại học Johns Hopkins
• Viện nghiên cứu Lerner, Phòng khám Cleveland
• Đại học Maastricht
• Học viện Max Plank
• trường đại học công nghệ Nayang
• Mạng lưới các nhà phân tích sinh học châu Âu
• NHS
• Công viên nghiên cứu Norwich
• Khoa học và tin học về dữ liệu sức khỏe quan sát (OHDSI)
• Quyền sở hữu mở
• Đại học Khoa học và Y tế Oregon
• Đại học Khoa học Paris et Lettres
• Đại học bang Pennsylvania
• Viện nghiên cứu vật liệu nước hoa
• Viện Sanger
• Viện tin sinh học quốc gia Tây Ban Nha
• Sri International
• Đại học Stanford
• Nền tảng cho nghiên cứu và công nghệ - Hellas
• Viện phần mềm khoa học phân tử
• Đại học Tsinghua
• Unist
• Đại học Degli Studi di Milano - Bicocca
• Đại học Alabama
• Đại học Barcelona
• đại học California, Berkeley
• Đại học California, San Diego
• Đại học California, San Francisco
• đại học Cambridge
• Đại học Khoa học và Công nghệ Điện tử Trung Quốc
• Đại học Heidelberg
• Đại học Helsinki
• Đại học Leipzig
• Đại học Maryland
• Trường đại học Toronto
• Đại học Utah
• Đại học Vanderbilt
• Virginia Tech
• Đại học Wageningen và nghiên cứu
• Quỹ di tích thế giới

Ứng dụng & Dịch vụ

• Apache tuổi
• Ứng dụng
• Aras
• Athenz
• Quan điểm AWS
• Bicep Azure
• Bell Media
• Bluesailcrm
• Bugbug
• Nhịp
• Lưới hỗn loạn
• Lớp học
• Cybersift
• Xi lanh
• Dendron
• Dockflow
• DRONEDEMPLINE
• Dynalearn
• Flowchart.fun
• Foxglove
• Ganister
• Diễn đàn CTO toàn cầu
• Đồ họa
• Đồ thị
• Grezi
• Hackertarget
• How-4
• Infotrack
• Intercax
• Phiên dịch
• IPFS & libp2p
• Jiva.ai
• JSdelivr
• Tung hứng
• Đường dẫn Kausal
• Kiali
• Kibana
• KPN
• Học tập
• Machine2Learn
• Tài chính đa dạng
• Sao Hoả
• Nhạc kịch
• Mạng Weathermap
• Thánh tích mới
• NX
• Obsidian
• OnePanel
• Opendialog
• Panaya
• Xác định chính xác
• Nhớ lại
• Đi lang thang
• Dấu hiệu
• Khung SQL
• Steemit
• StixView
• ICSI Haystack Panopticon
• Bản đồ Kanji
• Đe dọa kết nối
• Đe dọa
• Underlay
• VAC
• wanderer.ai
• Wisecube AI
• Zubir cho biết biểu đồ kiến ​​thức

Hãy cho chúng tôi biết

Hãy cho chúng tôi biết rằng bạn đã sử dụng cytoscape.js.

Về

Cytoscape.js là một thư viện lý thuyết đồ thị nguồn mở (a.k.a.) được viết bằng JS. Bạn có thể sử dụng cytoscape.js để phân tích đồ thị và trực quan hóa.

Cytoscape.js cho phép bạn dễ dàng hiển thị và thao tác các biểu đồ tương tác phong phú. Vì cytoscape.js cho phép người dùng tương tác với biểu đồ và thư viện cho phép máy khách kết nối với các sự kiện người dùng, cytoscape.js dễ dàng tích hợp vào ứng dụng của bạn, đặc biệt là khi cytoscape.js hỗ trợ cả trình duyệt máy tính để bàn, như Chrome và trình duyệt di động , giống như trên iPad. Cytoscape.js bao gồm tất cả các cử chỉ mà bạn mong đợi ngoài hộp, bao gồm Pinch-to-Zoom, Lựa chọn hộp, Panning, et cetera.

Cytoscape.js cũng có phân tích đồ thị trong tâm trí: Thư viện chứa nhiều chức năng hữu ích trong lý thuyết đồ thị. Bạn có thể sử dụng cytoscape.js không đầu trên Node.js để thực hiện phân tích đồ thị trong thiết bị đầu cuối hoặc trên máy chủ web.

Cytoscape.js là một dự án nguồn mở và bất kỳ ai có thể tự do đóng góp. Để biết thêm thông tin, hãy tham khảo GitHub Readme.

Thư viện được tạo ra tại Trung tâm Donnelly tại Đại học Toronto. Nó là sự kế thừa của Cytoscape Web.

Gói

• NPM:

  cytoscape({
  
    container: document.getElementById('cy'),
  
    elements: [ // flat array of nodes and edges
      { // node n1
        group: 'nodes', // 'nodes' for a node, 'edges' for an edge
        // NB the group field can be automatically inferred for you but specifying it
        // gives you nice debug messages if you mis-init elements
  
  
        data: { // element data (put json serialisable dev data here)
          id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
          parent: 'nparent', // indicates the compound node parent id; not defined => no parent
          // (`parent` can be effectively changed by `eles.move()`)
        },
  
        // scratchpad data (usually temp or nonserialisable data)
        scratch: {
          _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
        },
  
        position: { // the model position of the node (optional on init, mandatory after)
          x: 100,
          y: 100
        },
  
        selected: false, // whether the element is selected (default false)
  
        selectable: true, // whether the selection state is mutable (default true)
  
        locked: false, // when locked a node's position is immutable (default false)
  
        grabbable: true, // whether the node can be grabbed and moved by the user
  
        pannable: false, // whether dragging the node causes panning instead of grabbing
  
        classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has
  
        // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
        // USE THE STYLESHEET INSTEAD
        style: { // style property overrides 
          'background-color': 'red'
        }
      },
  
      { // node n2
        data: { id: 'n2' },
        renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
      },
  
      { // node n3
        data: { id: 'n3', parent: 'nparent' },
        position: { x: 123, y: 234 }
      },
  
      { // node nparent
        data: { id: 'nparent' }
      },
  
      { // edge e1
        data: {
          id: 'e1',
          // inferred as an edge because `source` and `target` are specified:
          source: 'n1', // the source node id (edge comes from this node)
          target: 'n2'  // the target node id (edge goes to this node)
          // (`source` and `target` can be effectively changed by `eles.move()`)
        },
  
        pannable: true // whether dragging on the edge causes panning
      }
    ],
  
    layout: {
      name: 'preset'
    },
  
    // so we can see the ids
    style: [
      {
        selector: 'node',
        style: {
          'label': 'data(id)'
        }
      }
    ]
  
  });
  

  55
• Bower:

  cytoscape({
  
    container: document.getElementById('cy'),
  
    elements: [ // flat array of nodes and edges
      { // node n1
        group: 'nodes', // 'nodes' for a node, 'edges' for an edge
        // NB the group field can be automatically inferred for you but specifying it
        // gives you nice debug messages if you mis-init elements
  
  
        data: { // element data (put json serialisable dev data here)
          id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
          parent: 'nparent', // indicates the compound node parent id; not defined => no parent
          // (`parent` can be effectively changed by `eles.move()`)
        },
  
        // scratchpad data (usually temp or nonserialisable data)
        scratch: {
          _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
        },
  
        position: { // the model position of the node (optional on init, mandatory after)
          x: 100,
          y: 100
        },
  
        selected: false, // whether the element is selected (default false)
  
        selectable: true, // whether the selection state is mutable (default true)
  
        locked: false, // when locked a node's position is immutable (default false)
  
        grabbable: true, // whether the node can be grabbed and moved by the user
  
        pannable: false, // whether dragging the node causes panning instead of grabbing
  
        classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has
  
        // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
        // USE THE STYLESHEET INSTEAD
        style: { // style property overrides 
          'background-color': 'red'
        }
      },
  
      { // node n2
        data: { id: 'n2' },
        renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
      },
  
      { // node n3
        data: { id: 'n3', parent: 'nparent' },
        position: { x: 123, y: 234 }
      },
  
      { // node nparent
        data: { id: 'nparent' }
      },
  
      { // edge e1
        data: {
          id: 'e1',
          // inferred as an edge because `source` and `target` are specified:
          source: 'n1', // the source node id (edge comes from this node)
          target: 'n2'  // the target node id (edge goes to this node)
          // (`source` and `target` can be effectively changed by `eles.move()`)
        },
  
        pannable: true // whether dragging on the edge causes panning
      }
    ],
  
    layout: {
      name: 'preset'
    },
  
    // so we can see the ids
    style: [
      {
        selector: 'node',
        style: {
          'label': 'data(id)'
        }
      }
    ]
  
  });
  

  56
• JSPM:

  cytoscape({
  
    container: document.getElementById('cy'),
  
    elements: [ // flat array of nodes and edges
      { // node n1
        group: 'nodes', // 'nodes' for a node, 'edges' for an edge
        // NB the group field can be automatically inferred for you but specifying it
        // gives you nice debug messages if you mis-init elements
  
  
        data: { // element data (put json serialisable dev data here)
          id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
          parent: 'nparent', // indicates the compound node parent id; not defined => no parent
          // (`parent` can be effectively changed by `eles.move()`)
        },
  
        // scratchpad data (usually temp or nonserialisable data)
        scratch: {
          _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
        },
  
        position: { // the model position of the node (optional on init, mandatory after)
          x: 100,
          y: 100
        },
  
        selected: false, // whether the element is selected (default false)
  
        selectable: true, // whether the selection state is mutable (default true)
  
        locked: false, // when locked a node's position is immutable (default false)
  
        grabbable: true, // whether the node can be grabbed and moved by the user
  
        pannable: false, // whether dragging the node causes panning instead of grabbing
  
        classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has
  
        // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
        // USE THE STYLESHEET INSTEAD
        style: { // style property overrides 
          'background-color': 'red'
        }
      },
  
      { // node n2
        data: { id: 'n2' },
        renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
      },
  
      { // node n3
        data: { id: 'n3', parent: 'nparent' },
        position: { x: 123, y: 234 }
      },
  
      { // node nparent
        data: { id: 'nparent' }
      },
  
      { // edge e1
        data: {
          id: 'e1',
          // inferred as an edge because `source` and `target` are specified:
          source: 'n1', // the source node id (edge comes from this node)
          target: 'n2'  // the target node id (edge goes to this node)
          // (`source` and `target` can be effectively changed by `eles.move()`)
        },
  
        pannable: true // whether dragging on the edge causes panning
      }
    ],
  
    layout: {
      name: 'preset'
    },
  
    // so we can see the ids
    style: [
      {
        selector: 'node',
        style: {
          'label': 'data(id)'
        }
      }
    ]
  
  });
  

  57

Phát hành

• 3.23
  • 3.23.0
• 3.22
  • 3.22.1
  • 3.22.0
• 3.21
  • 3.21.3
  • 3.21.2
  • 3.21.1
  • 3.21.0
• 3.20
  • 3.20.3
  • 3.20.2
  • 3.20.1
  • 3.20.0
• 3.19
  • 3.19.1
  • 3.19.0
• 3.18
  • 3.18.2
  • 3.18.1
  • 3.18.0
• 3.17
  • 3.17.4
  • 3.17.3
  • 3.17.2
  • 3.17.1
  • 3.17.0
• 3.16
  • 3.16.5
  • 3.16.4
  • 3.16.3
  • 3.16.2
  • 3.16.1
  • 3.16.0
• 3.15
  • 3.15.5
  • 3.15.4
  • 3.15.3
  • 3.15.2
  • 3.15.1
  • 3.15.0
• 3.14
  • 3.14.4
  • 3.14.3
  • 3.14.2
  • 3.14.1
  • 3.14.0
• 3.13
  • 3.13.3
  • 3.13.2
  • 3.13.1
  • 3.13.0
• 3.12
  • 3.12.3
  • 3.12.2
  • 3.12.1
  • 3.12.0
• 3.11
  • 3.11.2
  • 3.11.1
  • 3.11.0
• 3.10
  • 3.10.2
  • 3.10.1
  • 3.10.0
• 3.9
  • 3.9.4
  • 3.9.3
  • 3.9.2
  • 3.9.1
  • 3.9.0
• 3.8
  • 3.8.5
  • 3.8.4
  • 3.8.3
  • 3.8.2
  • 3.8.1
  • 3.8.0
• 3.7
  • 3.7.6
  • 3.7.5
  • 3.7.4
  • 3.7.3
  • 3.7.2
  • 3.7.1
  • 3.7.0
• 3.6
  • 3.6.6
  • 3.6.5
  • 3.6.4
  • 3.6.3
  • 3.6.2
  • 3.6.1
  • 3.6.0
• 3.5
  • 3.5.9
  • 3.5.8
  • 3.5.7
  • 3.5.6
  • 3.5.5
  • 3.5.4
  • 3.5.3
  • 3.5.2
  • 3.5.1
  • 3.5.0
• 3.4
  • 3.4.9
  • 3.4.8
  • 3.4.7
  • 3.4.6
  • 3.4.5
  • 3.4.4
  • 3.4.3
  • 3.4.2
  • 3.4.1
  • 3.4.0
• 3.3
  • 3.3.6
  • 3.3.5
  • 3.3.4
  • 3.3.3
  • 3.3.2
  • 3.3.1
  • 3.3.0
• 3.2
  • 3.2.22
  • 3.2.21
  • 3.2.20
  • 3.2.19
  • 3.2.18
  • 3.2.17
  • 3.2.16
  • 3.2.15
  • 3.2.14
  • 3.2.13
  • 3.2.12
  • 3.2.11
  • 3.2.10
  • 3.2.9
  • 3.2.8
  • 3.2.7
  • 3.2.6
  • 3.2.5
  • 3.2.4
  • 3.2.3
  • 3.2.2
  • 3.2.1
  • 3.2.0
• 3.1
  • 3.1.5
  • 3.1.4
  • 3.1.3
  • 3.1.2
  • 3.1.1
  • 3.1.0
• 3.0
  • 3.0.1
  • 3.0.0
• 2.7
  • 2.7.29
  • 2.7.28
  • 2.7.27
  • 2.7.26
  • 2.7.25
  • 2.7.24
  • 2.7.23
  • 2.7.22
  • 2.7.21
  • 2.7.20
  • 2.7.19
  • 2.7.18
  • 2.7.17
  • 2.7.16
  • 2.7.15
  • 2.7.14
  • 2.7.13
  • 2.7.12
  • 2.7.11
  • 2.7.10
  • 2.7.9
  • 2.7.8
  • 2.7.7
  • 2.7.6
  • 2.7.5
  • 2.7.4
  • 2.7.3
  • 2.7.2
  • 2.7.1
  • 2.7.0
• 2.6
  • 2.6.12
  • 2.6.11
  • 2.6.10
  • 2.6.9
  • 2.6.8
  • 2.6.7
  • 2.6.6
  • 2.6.5
  • 2.6.4
  • 2.6.3
  • 2.6.2
  • 2.6.1
  • 2.6.0
• 2.5
  • 2.5.5
  • 2.5.4
  • 2.5.3
  • 2.5.2
  • 2.5.1
  • 2.5.0
• 2.4
  • 2.4.9
  • 2.4.8
  • 2.4.7
  • 2.4.6
  • 2.4.5
  • 2.4.4
  • 2.4.3
  • 2.4.2
  • 2.4.1
  • 2.4.0
• 2.3
  • 2.3.16
  • 2.3.15
  • 2.3.14
  • 2.3.13
  • 2.3.11
  • 2.3.10
  • 2.3.9
  • 2.3.8
  • 2.3.7
  • 2.3.6
  • 2.3.5
  • 2.3.4
  • 2.3.3
  • 2.3.1
  • 2.3.0
• 2.2
  • 2.2.14
  • 2.2.13
  • 2.2.12
  • 2.2.11
  • 2.2.10
  • 2.2.9
  • 2.2.8
  • 2.2.7
  • 2.2.6
  • 2.2.5
  • 2.2.4
  • 2.2.3
  • 2.2.2
  • 2.2.1
  • 2.2.0
• 2.1
  • 2.1.1
  • 2.1.0
• 2.0
  • 2.0.5
  • 2.0.4
  • 2.0.3
  • 2.0.2
  • 2.0.1
  • 2.0.0

Trích dẫn

Để trích dẫn cytoscape.js trong một bài báo, xin vui lòng trích dẫn vấn đề tin sinh học Oxford:

Cytoscape.js: Thư viện lý thuyết đồ thị để trực quan hóa và phân tích

Franz M, Lopes CT, Huck G, Dong Y, Sumer O, Bader GD

Tin sinh học (2016) 32 (2): 309-311 Xuất bản trực tuyến lần đầu tiên vào ngày 28 tháng 9 năm 2015 DOI: 10.1093/Tin sinh học/BTV557 (PDF)

PubMed Tóm tắt

Kinh phí

Tài trợ cho cytoscape.js và cytoscape được cung cấp bởi NRNB (Viện Y tế Quốc gia Hoa Kỳ, Trung tâm Nghiên cứu Tài nguyên Quốc gia P41 RR031228 và GM103504) và bởi NIH cấp 2R01GM070743 và 1U41HG006623. Các tổ chức sau đây giúp phát triển tế bào học:

Isb | UCSD | MSKCC | Pasteur | Agilent | Ucsf | Unilever | Toronto | Ncibi | Nrnb

Ký hiệu

Mô hình đồ thị

Cytoscape.js hỗ trợ nhiều lý thuyết đồ thị khác nhau usecase. Nó hỗ trợ các biểu đồ theo hướng, đồ thị không mong muốn, đồ thị hỗn hợp, vòng lặp, đa hình, đồ thị hợp chất (một loại siêu hình), v.v.

Chúng tôi thường xuyên thực hiện các bổ sung và cải tiến cho thư viện và chúng tôi sẵn sàng chấp nhận các yêu cầu tính năng và yêu cầu kéo.

Kiến trúc & API

Có hai thành phần trong kiến ​​trúc mà một lập trình viên phải quan tâm để sử dụng cytoscape.js, lõi (tức là một thể hiện đồ thị) và bộ sưu tập. Trong cytoscape.js, cốt lõi là điểm nhập chính của lập trình viên vào thư viện. Từ lõi, một lập trình viên có thể chạy bố cục, thay đổi chế độ xem và thực hiện các hoạt động khác trên toàn bộ biểu đồ.

Core cung cấp một số chức năng để truy cập các yếu tố trong biểu đồ. Mỗi chức năng này trả về một bộ sưu tập, một tập hợp các phần tử trong biểu đồ. Các chức năng có sẵn trên các bộ sưu tập cho phép lập trình viên lọc bộ sưu tập, thực hiện các hoạt động trên bộ sưu tập, vượt qua biểu đồ về bộ sưu tập, lấy dữ liệu về các yếu tố trong bộ sưu tập, v.v.

Lưu ý rằng một bộ sưu tập là bất biến theo mặc định, có nghĩa là tập hợp các phần tử trong một bộ sưu tập không thể thay đổi. API trả về một bộ sưu tập mới với các yếu tố khác nhau khi cần thiết, thay vì biến đổi bộ sưu tập hiện có. Điều này cho phép lập trình viên sử dụng một cách an toàn các hoạt động lý thuyết trên các bộ sưu tập, sử dụng các bộ sưu tập chức năng, v.v. Lưu ý rằng vì một bộ sưu tập chỉ là một danh sách các yếu tố, nên việc tạo ra các bộ sưu tập mới tương đối rẻ.

Đối với mã chuyên sâu hiệu suất, một bộ sưu tập có thể được coi là có thể thay đổi với

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

Chức năng

Có một số loại mà các chức năng khác nhau có thể được thực thi và các tên biến được sử dụng để biểu thị các loại này trong tài liệu được nêu dưới đây:

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

Theo mặc định, một hàm trả về một tham chiếu trở lại đối tượng gọi để cho phép chuỗi (ví dụ:

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

Đối với các chức năng trả về một giá trị, lưu ý rằng gọi một số ít -

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

Quyền sở hữu đối tượng

Khi chuyển các đối tượng cho cytoscape.js để tạo các yếu tố, hình ảnh động, bố cục, v.v., các đối tượng được coi là thuộc sở hữu của cytoscape. Các đối tượng như các yếu tố có một số cấp độ đối với chúng và thực hiện các bản sao sâu của các đối tượng đó mỗi khi chúng được chuyển cho Cytoscape tạo ra chi phí bổ sung. Khi muốn, lập trình viên có thể sao chép các đối tượng theo cách thủ công trước khi chuyển chúng đến tế bào học. Tuy nhiên, sao chép là không cần thiết cho hầu hết các lập trình viên hầu hết thời gian.

Cử chỉ

Cytoscape.js hỗ trợ một số cử chỉ:

• Lấy và kéo nền vào Pan: Touch & Desktop
• Pinch to Zoom: Touch & Desktop (với Trackpad được hỗ trợ)
• Bánh xe chuột để phóng to: Máy tính để bàn
• Trackpad hai ngón lên hoặc xuống để thu nhỏ: máy tính để bàn
• Nhấn để chọn: Touch & Desktop
• Nhấn vào nền để không chọn: Máy tính để bàn
• Bối cảnh Taphold để không chọn: Desktop & Touch
• Nhiều lựa chọn thông qua khóa sửa đổi (Shift, Command, Control, Alt) + Tap: Desktop
• Lựa chọn hộp: Chạm (Three Finger Swipe) & Desktop (Khóa sửa đổi + Mousedown sau đó kéo)
• Lấy và kéo các nút: Touch & Desktop

Tất cả các hành động cử chỉ có thể được kiểm soát bởi lập trình viên, bật hoặc tắt chúng bất cứ khi nào cần thiết.

Chức vụ

Một vị trí nút Node đề cập đến điểm trung tâm của cơ thể.

Có một sự khác biệt quan trọng để thực hiện cho vị trí: một vị trí có thể là một vị trí mô hình hoặc một vị trí được hiển thị.

Một vị trí mô hình - như tên của nó cho thấy - là vị trí được lưu trữ trong mô hình cho một phần tử. Vị trí mô hình phần tử không đổi, mặc dù có những thay đổi đối với Zoom và Pan. Các giá trị thuộc tính kiểu số được chỉ định trong các tọa độ mô hình, ví dụ: Một nút có chiều rộng 20px sẽ rộng 20 pixel ở Zoom 1.

Một vị trí được hiển thị là một vị trí trên màn hình so với chế độ xem. Ví dụ: vị trí được hiển thị là

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

Vị trí được hiển thị tự nhiên của một phần tử thay đổi khi Zoom và PAN thay đổi, bởi vì vị trí trên màn hình của phần tử trong chế độ xem thay đổi khi thu phóng và panning được áp dụng. Panning luôn được đo theo tọa độ kết xuất.

Trong tài liệu này, vị trí của người Viking đề cập đến vị trí mô hình trừ khi có quy định khác.

Vị trí nút có thể được đặt thủ công hoặc nó có thể được đặt tự động bằng cách sử dụng bố cục. Bởi vì vị trí của hai nút ảnh hưởng đến độ dài của các cạnh ở giữa chúng, một bố cục đặt hiệu quả độ dài cạnh.

Yếu tố json

Các ví dụ được đưa ra rằng định dạng phác thảo của các yếu tố JSON được sử dụng để tải các yếu tố vào cytoscape.js:

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

Các yếu tố JSON có thể thay thế ở định dạng sau, được khóa bởi nhóm:

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

Các nút ghép

Các nút ghép là một bổ sung cho mô hình đồ thị truyền thống. Một nút hợp chất chứa một số nút con, tương tự như cách phần tử HTML DOM có thể chứa một số phần tử con.

Các nút ghép được chỉ định thông qua trường

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

Một nút cha mẹ ghép không có kích thước độc lập (vị trí và kích thước), vì các giá trị đó được tự động suy ra bởi các vị trí và kích thước của các nút hậu duệ.

Theo như API có liên quan, các nút ghép được xử lý giống như các nút thông thường - ngoại trừ trong các chức năng hợp chất rõ ràng như

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

Ví dụ:

var a = cy.$('#a'); // assume a compound node

// the neighbourhood of `a` contains directly connected elements
var directlyConnected = a.neighborhood();

// you may want everything connected to its descendants instead
// because the descendants "belong" to `a`
var indirectlyConnected = a.add( a.descendants() ).neighborhood();

Bắt đầu

Phần này sẽ làm quen với bạn với các bước cơ bản cần thiết để bắt đầu sử dụng cytoscape.js.

Bao gồm cytoscape.js

Nếu bạn đang sử dụng môi trường HTML đơn giản (không có hệ thống xây dựng), thì hãy nguồn cytoscape.js trong thẻ

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

<script src="cytoscape.min.js">script>

hoặc

<script type="module">
import cytoscape from "./cytoscape.esm.min.js";
script>

Để sử dụng cytoscape.js từ CDN, hãy sử dụng một trong các CDN sau:

• CDNJ
• JSdelivr
• Pagecdn
• Unpkg

Vui lòng không liên kết với các bản sao của cytoscape.js từ tài liệu - họ chỉ dành cho các bản demo.

Các tệp có sẵn có sẵn trong

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

• cytoscape({
  
    container: document.getElementById('cy'),
  
    elements: [ // flat array of nodes and edges
      { // node n1
        group: 'nodes', // 'nodes' for a node, 'edges' for an edge
        // NB the group field can be automatically inferred for you but specifying it
        // gives you nice debug messages if you mis-init elements
  
  
        data: { // element data (put json serialisable dev data here)
          id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
          parent: 'nparent', // indicates the compound node parent id; not defined => no parent
          // (`parent` can be effectively changed by `eles.move()`)
        },
  
        // scratchpad data (usually temp or nonserialisable data)
        scratch: {
          _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
        },
  
        position: { // the model position of the node (optional on init, mandatory after)
          x: 100,
          y: 100
        },
  
        selected: false, // whether the element is selected (default false)
  
        selectable: true, // whether the selection state is mutable (default true)
  
        locked: false, // when locked a node's position is immutable (default false)
  
        grabbable: true, // whether the node can be grabbed and moved by the user
  
        pannable: false, // whether dragging the node causes panning instead of grabbing
  
        classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has
  
        // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
        // USE THE STYLESHEET INSTEAD
        style: { // style property overrides 
          'background-color': 'red'
        }
      },
  
      { // node n2
        data: { id: 'n2' },
        renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
      },
  
      { // node n3
        data: { id: 'n3', parent: 'nparent' },
        position: { x: 123, y: 234 }
      },
  
      { // node nparent
        data: { id: 'nparent' }
      },
  
      { // edge e1
        data: {
          id: 'e1',
          // inferred as an edge because `source` and `target` are specified:
          source: 'n1', // the source node id (edge comes from this node)
          target: 'n2'  // the target node id (edge goes to this node)
          // (`source` and `target` can be effectively changed by `eles.move()`)
        },
  
        pannable: true // whether dragging on the edge causes panning
      }
    ],
  
    layout: {
      name: 'preset'
    },
  
    // so we can see the ids
    style: [
      {
        selector: 'node',
        style: {
          'label': 'data(id)'
        }
      }
    ]
  
  });
  

  87: Một bản dựng UMD được thu nhỏ với tất cả các phụ thuộc có trong gói. Tệp này rất hữu ích cho các trang nhỏ, tài liệu bổ sung cho một bài báo học thuật chẳng hạn.

• cytoscape({
  
    container: document.getElementById('cy'),
  
    elements: [ // flat array of nodes and edges
      { // node n1
        group: 'nodes', // 'nodes' for a node, 'edges' for an edge
        // NB the group field can be automatically inferred for you but specifying it
        // gives you nice debug messages if you mis-init elements
  
  
        data: { // element data (put json serialisable dev data here)
          id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
          parent: 'nparent', // indicates the compound node parent id; not defined => no parent
          // (`parent` can be effectively changed by `eles.move()`)
        },
  
        // scratchpad data (usually temp or nonserialisable data)
        scratch: {
          _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
        },
  
        position: { // the model position of the node (optional on init, mandatory after)
          x: 100,
          y: 100
        },
  
        selected: false, // whether the element is selected (default false)
  
        selectable: true, // whether the selection state is mutable (default true)
  
        locked: false, // when locked a node's position is immutable (default false)
  
        grabbable: true, // whether the node can be grabbed and moved by the user
  
        pannable: false, // whether dragging the node causes panning instead of grabbing
  
        classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has
  
        // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
        // USE THE STYLESHEET INSTEAD
        style: { // style property overrides 
          'background-color': 'red'
        }
      },
  
      { // node n2
        data: { id: 'n2' },
        renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
      },
  
      { // node n3
        data: { id: 'n3', parent: 'nparent' },
        position: { x: 123, y: 234 }
      },
  
      { // node nparent
        data: { id: 'nparent' }
      },
  
      { // edge e1
        data: {
          id: 'e1',
          // inferred as an edge because `source` and `target` are specified:
          source: 'n1', // the source node id (edge comes from this node)
          target: 'n2'  // the target node id (edge goes to this node)
          // (`source` and `target` can be effectively changed by `eles.move()`)
        },
  
        pannable: true // whether dragging on the edge causes panning
      }
    ],
  
    layout: {
      name: 'preset'
    },
  
    // so we can see the ids
    style: [
      {
        selector: 'node',
        style: {
          'label': 'data(id)'
        }
      }
    ]
  
  });
  

  88: Một bản dựng UMD không được phân loại với tất cả các phụ thuộc có trong gói. Tệp này rất hữu ích để gỡ lỗi trên các trang nhỏ, tài liệu bổ sung cho một bài báo học thuật chẳng hạn.

• cytoscape({
  
    container: document.getElementById('cy'),
  
    elements: [ // flat array of nodes and edges
      { // node n1
        group: 'nodes', // 'nodes' for a node, 'edges' for an edge
        // NB the group field can be automatically inferred for you but specifying it
        // gives you nice debug messages if you mis-init elements
  
  
        data: { // element data (put json serialisable dev data here)
          id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
          parent: 'nparent', // indicates the compound node parent id; not defined => no parent
          // (`parent` can be effectively changed by `eles.move()`)
        },
  
        // scratchpad data (usually temp or nonserialisable data)
        scratch: {
          _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
        },
  
        position: { // the model position of the node (optional on init, mandatory after)
          x: 100,
          y: 100
        },
  
        selected: false, // whether the element is selected (default false)
  
        selectable: true, // whether the selection state is mutable (default true)
  
        locked: false, // when locked a node's position is immutable (default false)
  
        grabbable: true, // whether the node can be grabbed and moved by the user
  
        pannable: false, // whether dragging the node causes panning instead of grabbing
  
        classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has
  
        // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
        // USE THE STYLESHEET INSTEAD
        style: { // style property overrides 
          'background-color': 'red'
        }
      },
  
      { // node n2
        data: { id: 'n2' },
        renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
      },
  
      { // node n3
        data: { id: 'n3', parent: 'nparent' },
        position: { x: 123, y: 234 }
      },
  
      { // node nparent
        data: { id: 'nparent' }
      },
  
      { // edge e1
        data: {
          id: 'e1',
          // inferred as an edge because `source` and `target` are specified:
          source: 'n1', // the source node id (edge comes from this node)
          target: 'n2'  // the target node id (edge goes to this node)
          // (`source` and `target` can be effectively changed by `eles.move()`)
        },
  
        pannable: true // whether dragging on the edge causes panning
      }
    ],
  
    layout: {
      name: 'preset'
    },
  
    // so we can see the ids
    style: [
      {
        selector: 'node',
        style: {
          'label': 'data(id)'
        }
      }
    ]
  
  });
  

  89: Xây dựng ESM (

  cytoscape({
  
    container: document.getElementById('cy'),
  
    elements: [ // flat array of nodes and edges
      { // node n1
        group: 'nodes', // 'nodes' for a node, 'edges' for an edge
        // NB the group field can be automatically inferred for you but specifying it
        // gives you nice debug messages if you mis-init elements
  
  
        data: { // element data (put json serialisable dev data here)
          id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
          parent: 'nparent', // indicates the compound node parent id; not defined => no parent
          // (`parent` can be effectively changed by `eles.move()`)
        },
  
        // scratchpad data (usually temp or nonserialisable data)
        scratch: {
          _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
        },
  
        position: { // the model position of the node (optional on init, mandatory after)
          x: 100,
          y: 100
        },
  
        selected: false, // whether the element is selected (default false)
  
        selectable: true, // whether the selection state is mutable (default true)
  
        locked: false, // when locked a node's position is immutable (default false)
  
        grabbable: true, // whether the node can be grabbed and moved by the user
  
        pannable: false, // whether dragging the node causes panning instead of grabbing
  
        classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has
  
        // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
        // USE THE STYLESHEET INSTEAD
        style: { // style property overrides 
          'background-color': 'red'
        }
      },
  
      { // node n2
        data: { id: 'n2' },
        renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
      },
  
      { // node n3
        data: { id: 'n3', parent: 'nparent' },
        position: { x: 123, y: 234 }
      },
  
      { // node nparent
        data: { id: 'nparent' }
      },
  
      { // edge e1
        data: {
          id: 'e1',
          // inferred as an edge because `source` and `target` are specified:
          source: 'n1', // the source node id (edge comes from this node)
          target: 'n2'  // the target node id (edge goes to this node)
          // (`source` and `target` can be effectively changed by `eles.move()`)
        },
  
        pannable: true // whether dragging on the edge causes panning
      }
    ],
  
    layout: {
      name: 'preset'
    },
  
    // so we can see the ids
    style: [
      {
        selector: 'node',
        style: {
          'label': 'data(id)'
        }
      }
    ]
  
  });
  

  85 /

  cytoscape({
  
    container: document.getElementById('cy'),
  
    elements: [ // flat array of nodes and edges
      { // node n1
        group: 'nodes', // 'nodes' for a node, 'edges' for an edge
        // NB the group field can be automatically inferred for you but specifying it
        // gives you nice debug messages if you mis-init elements
  
  
        data: { // element data (put json serialisable dev data here)
          id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
          parent: 'nparent', // indicates the compound node parent id; not defined => no parent
          // (`parent` can be effectively changed by `eles.move()`)
        },
  
        // scratchpad data (usually temp or nonserialisable data)
        scratch: {
          _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
        },
  
        position: { // the model position of the node (optional on init, mandatory after)
          x: 100,
          y: 100
        },
  
        selected: false, // whether the element is selected (default false)
  
        selectable: true, // whether the selection state is mutable (default true)
  
        locked: false, // when locked a node's position is immutable (default false)
  
        grabbable: true, // whether the node can be grabbed and moved by the user
  
        pannable: false, // whether dragging the node causes panning instead of grabbing
  
        classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has
  
        // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
        // USE THE STYLESHEET INSTEAD
        style: { // style property overrides 
          'background-color': 'red'
        }
      },
  
      { // node n2
        data: { id: 'n2' },
        renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
      },
  
      { // node n3
        data: { id: 'n3', parent: 'nparent' },
        position: { x: 123, y: 234 }
      },
  
      { // node nparent
        data: { id: 'nparent' }
      },
  
      { // edge e1
        data: {
          id: 'e1',
          // inferred as an edge because `source` and `target` are specified:
          source: 'n1', // the source node id (edge comes from this node)
          target: 'n2'  // the target node id (edge goes to this node)
          // (`source` and `target` can be effectively changed by `eles.move()`)
        },
  
        pannable: true // whether dragging on the edge causes panning
      }
    ],
  
    layout: {
      name: 'preset'
    },
  
    // so we can see the ids
    style: [
      {
        selector: 'node',
        style: {
          'label': 'data(id)'
        }
      }
    ]
  
  });
  

  91) Minified với tất cả các phụ thuộc có trong gói. Tệp này phục vụ cùng mục đích với các mục đích trên, nhưng nó có thể được nhập dưới dạng mô -đun ES6 mà không cần một người đóng gói.

• cytoscape({
  
    container: document.getElementById('cy'),
  
    elements: [ // flat array of nodes and edges
      { // node n1
        group: 'nodes', // 'nodes' for a node, 'edges' for an edge
        // NB the group field can be automatically inferred for you but specifying it
        // gives you nice debug messages if you mis-init elements
  
  
        data: { // element data (put json serialisable dev data here)
          id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
          parent: 'nparent', // indicates the compound node parent id; not defined => no parent
          // (`parent` can be effectively changed by `eles.move()`)
        },
  
        // scratchpad data (usually temp or nonserialisable data)
        scratch: {
          _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
        },
  
        position: { // the model position of the node (optional on init, mandatory after)
          x: 100,
          y: 100
        },
  
        selected: false, // whether the element is selected (default false)
  
        selectable: true, // whether the selection state is mutable (default true)
  
        locked: false, // when locked a node's position is immutable (default false)
  
        grabbable: true, // whether the node can be grabbed and moved by the user
  
        pannable: false, // whether dragging the node causes panning instead of grabbing
  
        classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has
  
        // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
        // USE THE STYLESHEET INSTEAD
        style: { // style property overrides 
          'background-color': 'red'
        }
      },
  
      { // node n2
        data: { id: 'n2' },
        renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
      },
  
      { // node n3
        data: { id: 'n3', parent: 'nparent' },
        position: { x: 123, y: 234 }
      },
  
      { // node nparent
        data: { id: 'nparent' }
      },
  
      { // edge e1
        data: {
          id: 'e1',
          // inferred as an edge because `source` and `target` are specified:
          source: 'n1', // the source node id (edge comes from this node)
          target: 'n2'  // the target node id (edge goes to this node)
          // (`source` and `target` can be effectively changed by `eles.move()`)
        },
  
        pannable: true // whether dragging on the edge causes panning
      }
    ],
  
    layout: {
      name: 'preset'
    },
  
    // so we can see the ids
    style: [
      {
        selector: 'node',
        style: {
          'label': 'data(id)'
        }
      }
    ]
  
  });
  

  92: Bản dựng CJS (Node.js) không được phân loại mà không có bất kỳ phụ thuộc nào đi kèm. Điều này được dự định sẽ được tiêu thụ tự động bởi Node.js hoặc một người đóng gói như webpack thông qua

  cytoscape({
  
    container: document.getElementById('cy'),
  
    elements: [ // flat array of nodes and edges
      { // node n1
        group: 'nodes', // 'nodes' for a node, 'edges' for an edge
        // NB the group field can be automatically inferred for you but specifying it
        // gives you nice debug messages if you mis-init elements
  
  
        data: { // element data (put json serialisable dev data here)
          id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
          parent: 'nparent', // indicates the compound node parent id; not defined => no parent
          // (`parent` can be effectively changed by `eles.move()`)
        },
  
        // scratchpad data (usually temp or nonserialisable data)
        scratch: {
          _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
        },
  
        position: { // the model position of the node (optional on init, mandatory after)
          x: 100,
          y: 100
        },
  
        selected: false, // whether the element is selected (default false)
  
        selectable: true, // whether the selection state is mutable (default true)
  
        locked: false, // when locked a node's position is immutable (default false)
  
        grabbable: true, // whether the node can be grabbed and moved by the user
  
        pannable: false, // whether dragging the node causes panning instead of grabbing
  
        classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has
  
        // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
        // USE THE STYLESHEET INSTEAD
        style: { // style property overrides 
          'background-color': 'red'
        }
      },
  
      { // node n2
        data: { id: 'n2' },
        renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
      },
  
      { // node n3
        data: { id: 'n3', parent: 'nparent' },
        position: { x: 123, y: 234 }
      },
  
      { // node nparent
        data: { id: 'nparent' }
      },
  
      { // edge e1
        data: {
          id: 'e1',
          // inferred as an edge because `source` and `target` are specified:
          source: 'n1', // the source node id (edge comes from this node)
          target: 'n2'  // the target node id (edge goes to this node)
          // (`source` and `target` can be effectively changed by `eles.move()`)
        },
  
        pannable: true // whether dragging on the edge causes panning
      }
    ],
  
    layout: {
      name: 'preset'
    },
  
    // so we can see the ids
    style: [
      {
        selector: 'node',
        style: {
          'label': 'data(id)'
        }
      }
    ]
  
  });
  

  93.

• cytoscape({
  
    container: document.getElementById('cy'),
  
    elements: [ // flat array of nodes and edges
      { // node n1
        group: 'nodes', // 'nodes' for a node, 'edges' for an edge
        // NB the group field can be automatically inferred for you but specifying it
        // gives you nice debug messages if you mis-init elements
  
  
        data: { // element data (put json serialisable dev data here)
          id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
          parent: 'nparent', // indicates the compound node parent id; not defined => no parent
          // (`parent` can be effectively changed by `eles.move()`)
        },
  
        // scratchpad data (usually temp or nonserialisable data)
        scratch: {
          _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
        },
  
        position: { // the model position of the node (optional on init, mandatory after)
          x: 100,
          y: 100
        },
  
        selected: false, // whether the element is selected (default false)
  
        selectable: true, // whether the selection state is mutable (default true)
  
        locked: false, // when locked a node's position is immutable (default false)
  
        grabbable: true, // whether the node can be grabbed and moved by the user
  
        pannable: false, // whether dragging the node causes panning instead of grabbing
  
        classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has
  
        // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
        // USE THE STYLESHEET INSTEAD
        style: { // style property overrides 
          'background-color': 'red'
        }
      },
  
      { // node n2
        data: { id: 'n2' },
        renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
      },
  
      { // node n3
        data: { id: 'n3', parent: 'nparent' },
        position: { x: 123, y: 234 }
      },
  
      { // node nparent
        data: { id: 'nparent' }
      },
  
      { // edge e1
        data: {
          id: 'e1',
          // inferred as an edge because `source` and `target` are specified:
          source: 'n1', // the source node id (edge comes from this node)
          target: 'n2'  // the target node id (edge goes to this node)
          // (`source` and `target` can be effectively changed by `eles.move()`)
        },
  
        pannable: true // whether dragging on the edge causes panning
      }
    ],
  
    layout: {
      name: 'preset'
    },
  
    // so we can see the ids
    style: [
      {
        selector: 'node',
        style: {
          'label': 'data(id)'
        }
      }
    ]
  
  });
  

  94: Xây dựng ESM không phân loại (

  cytoscape({
  
    container: document.getElementById('cy'),
  
    elements: [ // flat array of nodes and edges
      { // node n1
        group: 'nodes', // 'nodes' for a node, 'edges' for an edge
        // NB the group field can be automatically inferred for you but specifying it
        // gives you nice debug messages if you mis-init elements
  
  
        data: { // element data (put json serialisable dev data here)
          id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
          parent: 'nparent', // indicates the compound node parent id; not defined => no parent
          // (`parent` can be effectively changed by `eles.move()`)
        },
  
        // scratchpad data (usually temp or nonserialisable data)
        scratch: {
          _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
        },
  
        position: { // the model position of the node (optional on init, mandatory after)
          x: 100,
          y: 100
        },
  
        selected: false, // whether the element is selected (default false)
  
        selectable: true, // whether the selection state is mutable (default true)
  
        locked: false, // when locked a node's position is immutable (default false)
  
        grabbable: true, // whether the node can be grabbed and moved by the user
  
        pannable: false, // whether dragging the node causes panning instead of grabbing
  
        classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has
  
        // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
        // USE THE STYLESHEET INSTEAD
        style: { // style property overrides 
          'background-color': 'red'
        }
      },
  
      { // node n2
        data: { id: 'n2' },
        renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
      },
  
      { // node n3
        data: { id: 'n3', parent: 'nparent' },
        position: { x: 123, y: 234 }
      },
  
      { // node nparent
        data: { id: 'nparent' }
      },
  
      { // edge e1
        data: {
          id: 'e1',
          // inferred as an edge because `source` and `target` are specified:
          source: 'n1', // the source node id (edge comes from this node)
          target: 'n2'  // the target node id (edge goes to this node)
          // (`source` and `target` can be effectively changed by `eles.move()`)
        },
  
        pannable: true // whether dragging on the edge causes panning
      }
    ],
  
    layout: {
      name: 'preset'
    },
  
    // so we can see the ids
    style: [
      {
        selector: 'node',
        style: {
          'label': 'data(id)'
        }
      }
    ]
  
  });
  

  85 /

  cytoscape({
  
    container: document.getElementById('cy'),
  
    elements: [ // flat array of nodes and edges
      { // node n1
        group: 'nodes', // 'nodes' for a node, 'edges' for an edge
        // NB the group field can be automatically inferred for you but specifying it
        // gives you nice debug messages if you mis-init elements
  
  
        data: { // element data (put json serialisable dev data here)
          id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
          parent: 'nparent', // indicates the compound node parent id; not defined => no parent
          // (`parent` can be effectively changed by `eles.move()`)
        },
  
        // scratchpad data (usually temp or nonserialisable data)
        scratch: {
          _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
        },
  
        position: { // the model position of the node (optional on init, mandatory after)
          x: 100,
          y: 100
        },
  
        selected: false, // whether the element is selected (default false)
  
        selectable: true, // whether the selection state is mutable (default true)
  
        locked: false, // when locked a node's position is immutable (default false)
  
        grabbable: true, // whether the node can be grabbed and moved by the user
  
        pannable: false, // whether dragging the node causes panning instead of grabbing
  
        classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has
  
        // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
        // USE THE STYLESHEET INSTEAD
        style: { // style property overrides 
          'background-color': 'red'
        }
      },
  
      { // node n2
        data: { id: 'n2' },
        renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
      },
  
      { // node n3
        data: { id: 'n3', parent: 'nparent' },
        position: { x: 123, y: 234 }
      },
  
      { // node nparent
        data: { id: 'nparent' }
      },
  
      { // edge e1
        data: {
          id: 'e1',
          // inferred as an edge because `source` and `target` are specified:
          source: 'n1', // the source node id (edge comes from this node)
          target: 'n2'  // the target node id (edge goes to this node)
          // (`source` and `target` can be effectively changed by `eles.move()`)
        },
  
        pannable: true // whether dragging on the edge causes panning
      }
    ],
  
    layout: {
      name: 'preset'
    },
  
    // so we can see the ids
    style: [
      {
        selector: 'node',
        style: {
          'label': 'data(id)'
        }
      }
    ]
  
  });
  

  91) mà không có bất kỳ phụ thuộc nào đi kèm. Điều này được dự định sẽ được tiêu thụ tự động bởi Node.js hoặc một người đóng gói như webpack thông qua

  cytoscape({
  
    container: document.getElementById('cy'),
  
    elements: [ // flat array of nodes and edges
      { // node n1
        group: 'nodes', // 'nodes' for a node, 'edges' for an edge
        // NB the group field can be automatically inferred for you but specifying it
        // gives you nice debug messages if you mis-init elements
  
  
        data: { // element data (put json serialisable dev data here)
          id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
          parent: 'nparent', // indicates the compound node parent id; not defined => no parent
          // (`parent` can be effectively changed by `eles.move()`)
        },
  
        // scratchpad data (usually temp or nonserialisable data)
        scratch: {
          _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
        },
  
        position: { // the model position of the node (optional on init, mandatory after)
          x: 100,
          y: 100
        },
  
        selected: false, // whether the element is selected (default false)
  
        selectable: true, // whether the selection state is mutable (default true)
  
        locked: false, // when locked a node's position is immutable (default false)
  
        grabbable: true, // whether the node can be grabbed and moved by the user
  
        pannable: false, // whether dragging the node causes panning instead of grabbing
  
        classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has
  
        // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
        // USE THE STYLESHEET INSTEAD
        style: { // style property overrides 
          'background-color': 'red'
        }
      },
  
      { // node n2
        data: { id: 'n2' },
        renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
      },
  
      { // node n3
        data: { id: 'n3', parent: 'nparent' },
        position: { x: 123, y: 234 }
      },
  
      { // node nparent
        data: { id: 'nparent' }
      },
  
      { // edge e1
        data: {
          id: 'e1',
          // inferred as an edge because `source` and `target` are specified:
          source: 'n1', // the source node id (edge comes from this node)
          target: 'n2'  // the target node id (edge goes to this node)
          // (`source` and `target` can be effectively changed by `eles.move()`)
        },
  
        pannable: true // whether dragging on the edge causes panning
      }
    ],
  
    layout: {
      name: 'preset'
    },
  
    // so we can see the ids
    style: [
      {
        selector: 'node',
        style: {
          'label': 'data(id)'
        }
      }
    ]
  
  });
  

  97.

Lưu ý rằng cytoscape.js sử dụng kích thước của thùng chứa phần tử HTML DOM của bạn cho bố cục và kết xuất khi khởi tạo. Do đó, điều rất quan trọng là đặt các bảng kiểu CSS của bạn trong

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

Bảng kiểu của bạn có thể bao gồm một cái gì đó như thế này (giả sử phần tử DOM có ID

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

#cy {
  width: 300px;
  height: 300px;
  display: block;
}

Để cài đặt cytoscape.js qua NPM:

npm install cytoscape

Để sử dụng cytoscape.js trong môi trường ESM với NPM (ví dụ: webpack hoặc node.js với gói

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

import cytoscape from 'cytoscape';

Để sử dụng cytoscape.js trong môi trường phổ biến như Node.js:

.side-line {
    display: inline-block;
    border-top: 1px solid black;
    width: 20%;
}

.triangle {
    display: inline-block;
    height: 7px;
    width: 7px;
    transform: rotate(45deg);
    transform-origin: center center;
    border-top: 1px solid black;
    border-left: 1px solid black;
    margin: 0 -3px -3px;
}

Để sử dụng cytoscape.js với AMD/abor.js:

.side-line {
    display: inline-block;
    border-top: 1px solid black;
    width: 20%;
}

.triangle {
    display: inline-block;
    height: 7px;
    width: 7px;
    transform: rotate(45deg);
    transform-origin: center center;
    border-top: 1px solid black;
    border-left: 1px solid black;
    margin: 0 -3px -3px;
}

Để cài đặt cytoscape.js thông qua bower:

.side-line {
    display: inline-block;
    border-top: 1px solid black;
    width: 20%;
}

.triangle {
    display: inline-block;
    height: 7px;
    width: 7px;
    transform: rotate(45deg);
    transform-origin: center center;
    border-top: 1px solid black;
    border-left: 1px solid black;
    margin: 0 -3px -3px;
}

Để cài đặt cytoscape.js thông qua thiên thạch/khí quyển:

npm install cytoscape

Cytoscape.js hỗ trợ các môi trường với ES5 hoặc mới hơn, vì nó được BABEL chuyển đổi và nó chỉ sử dụng các tính năng cơ bản của thư viện tiêu chuẩn. Phát hiện tính năng được sử dụng cho các tính năng tùy chọn cải thiện hiệu suất. Tuy nhiên, một phiên bản tương lai của cytoscape.js có thể yêu cầu phiên bản cập nhật hơn của thư viện tiêu chuẩn. Bạn có thể muốn sử dụng

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

Khởi tạo

Một thể hiện của cytoscape.js tương ứng với một biểu đồ. Bạn có thể tạo một thể hiện như sau:

.side-line {
    display: inline-block;
    border-top: 1px solid black;
    width: 20%;
}

.triangle {
    display: inline-block;
    height: 7px;
    width: 7px;
    transform: rotate(45deg);
    transform-origin: center center;
    border-top: 1px solid black;
    border-left: 1px solid black;
    margin: 0 -3px -3px;
}

Bạn có thể vượt qua một ví dụ jQuery là

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

.side-line {
    display: inline-block;
    border-top: 1px solid black;
    width: 20%;
}

.triangle {
    display: inline-block;
    height: 7px;
    width: 7px;
    transform: rotate(45deg);
    transform-origin: center center;
    border-top: 1px solid black;
    border-left: 1px solid black;
    margin: 0 -3px -3px;
}

Nếu bạn đang chạy cytoscape.js trong node.js hoặc chạy nó không chính xác, bạn sẽ không chỉ định tùy chọn

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

Chỉ định các tùy chọn cơ bản

Để trực quan hóa, các tùy chọn

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

.side-line {
    display: inline-block;
    border-top: 1px solid black;
    width: 20%;
}

.triangle {
    display: inline-block;
    height: 7px;
    width: 7px;
    transform: rotate(45deg);
    transform-origin: center center;
    border-top: 1px solid black;
    border-left: 1px solid black;
    margin: 0 -3px -3px;
}

Bước tiếp theo

Bây giờ bạn có một thể hiện lõi (biểu đồ) với các tùy chọn cơ bản, khám phá API cốt lõi. Nó có điểm vào của bạn cho tất cả các tính năng trong cytoscape.js.

Nếu bạn có câu hỏi mã về cytoscape.js, xin vui lòng đăng câu hỏi của bạn lên stackoverflow.

Cốt lõi

Đối tượng cốt lõi là giao diện của bạn với một biểu đồ. Đây là điểm nhập của bạn vào cytoscape.js: Tất cả các tính năng của thư viện được truy cập thông qua đối tượng này.

Khởi tạo

Một thể hiện của cytoscape.js tương ứng với một biểu đồ. Bạn có thể tạo một thể hiện như sau:

Bạn có thể vượt qua một ví dụ jQuery là

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

.side-line {
    display: inline-block;
    border-top: 1px solid black;
    width: 20%;
}

.triangle {
    display: inline-block;
    height: 7px;
    width: 7px;
    transform: rotate(45deg);
    transform-origin: center center;
    border-top: 1px solid black;
    border-left: 1px solid black;
    margin: 0 -3px -3px;
}

Nếu bạn đang chạy cytoscape.js trong node.js hoặc chạy nó không chính xác, bạn sẽ không chỉ định tùy chọn

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

.side-line {
    display: inline-block;
    border-top: 1px solid black;
    width: 20%;
}

.triangle {
    display: inline-block;
    height: 7px;
    width: 7px;
    transform: rotate(45deg);
    transform-origin: center center;
    border-top: 1px solid black;
    border-left: 1px solid black;
    margin: 0 -3px -3px;
}

Chỉ định các tùy chọn cơ bản

Để trực quan hóa, các tùy chọn

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

Bước tiếp theo

Bây giờ bạn có một thể hiện lõi (biểu đồ) với các tùy chọn cơ bản, khám phá API cốt lõi. Nó có điểm vào của bạn cho tất cả các tính năng trong cytoscape.js.

Nếu bạn có câu hỏi mã về cytoscape.js, xin vui lòng đăng câu hỏi của bạn lên stackoverflow.

Cốt lõi

.side-line {
    display: inline-block;
    border-top: 1px solid black;
    width: 20%;
}

.triangle {
    display: inline-block;
    height: 7px;
    width: 7px;
    transform: rotate(45deg);
    transform-origin: center center;
    border-top: 1px solid black;
    border-left: 1px solid black;
    margin: 0 -3px -3px;
}

Đối tượng cốt lõi là giao diện của bạn với một biểu đồ. Đây là điểm nhập của bạn vào cytoscape.js: Tất cả các tính năng của thư viện được truy cập thông qua đối tượng này.

Khởi tạo : A HTML DOM element in which the graph should be rendered. This is unspecified if Cytoscape.js is run headlessly. The container is expected to be an empty div; the visualisation owns the div.

Một biểu đồ có thể được tạo như sau: : An array of elements specified as plain objects. For convenience, this option can alternatively be specified as a promise that resolves to the elements JSON.

Bạn có thể khởi tạo cốt lõi mà không cần bất kỳ tùy chọn nào. Nếu bạn muốn sử dụng cytoscape làm hình ảnh, thì cần có yếu tố DOM ____303, ví dụ: : The stylesheet used to style the graph. For convenience, this option can alternatively be specified as a promise that resolves to the stylesheet.

Lưu ý rằng để đảm bảo sử dụng phông chữ tùy chỉnh (Woff/Woff2), các phông chữ trong câu hỏi phải được tải trước khi cytoscape được khởi tạo. : A plain object that specifies layout options. Which layout is initially run is specified by the

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

cytoscape({

  container: document.getElementById('cy'),

  elements: [ // flat array of nodes and edges
    { // node n1
      group: 'nodes', // 'nodes' for a node, 'edges' for an edge
      // NB the group field can be automatically inferred for you but specifying it
      // gives you nice debug messages if you mis-init elements


      data: { // element data (put json serialisable dev data here)
        id: 'n1', // mandatory (string) id for each element, assigned automatically on undefined
        parent: 'nparent', // indicates the compound node parent id; not defined => no parent
        // (`parent` can be effectively changed by `eles.move()`)
      },

      // scratchpad data (usually temp or nonserialisable data)
      scratch: {
        _foo: 'bar' // app fields prefixed by underscore; extension fields unprefixed
      },

      position: { // the model position of the node (optional on init, mandatory after)
        x: 100,
        y: 100
      },

      selected: false, // whether the element is selected (default false)

      selectable: true, // whether the selection state is mutable (default true)

      locked: false, // when locked a node's position is immutable (default false)

      grabbable: true, // whether the node can be grabbed and moved by the user

      pannable: false, // whether dragging the node causes panning instead of grabbing

      classes: ['foo', 'bar'], // an array (or a space separated string) of class names that the element has

      // DO NOT USE THE `style` FIELD UNLESS ABSOLUTELY NECESSARY
      // USE THE STYLESHEET INSTEAD
      style: { // style property overrides 
        'background-color': 'red'
      }
    },

    { // node n2
      data: { id: 'n2' },
      renderedPosition: { x: 200, y: 200 } // can alternatively specify position in rendered on-screen pixels
    },

    { // node n3
      data: { id: 'n3', parent: 'nparent' },
      position: { x: 123, y: 234 }
    },

    { // node nparent
      data: { id: 'nparent' }
    },

    { // edge e1
      data: {
        id: 'e1',
        // inferred as an edge because `source` and `target` are specified:
        source: 'n1', // the source node id (edge comes from this node)
        target: 'n2'  // the target node id (edge goes to this node)
        // (`source` and `target` can be effectively changed by `eles.move()`)
      },

      pannable: true // whether dragging on the edge causes panning
    }
  ],

  layout: {
    name: 'preset'
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]

});

Trạng thái quan điểm ban đầu

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});

cytoscape({
  container: document.getElementById('cy'),

  elements: {
    nodes: [
      {
        data: { id: 'a' }
      },

      {
        data: { id: 'b' }
      }
    ],
    edges: [
      {
        data: { id: 'ab', source: 'a', target: 'b' }
      }
    ]
  },

  layout: {
    name: 'grid',
    rows: 1
  },

  // so we can see the ids
  style: [
    {
      selector: 'node',
      style: {
        'label': 'data(id)'
      }
    }
  ]
});