Answer 1

以前的大多数答案都清除了有关切片符号的问题。

用于切片的扩展索引语法是alist [start：stop：step]，基本示例为：

：

更多切片示例：

Answer 2

您可以在超级集中添加列。悬停在标题上的“源”上，然后选择“表”。然后从那里选择编辑表记录的选项。在此您可以添加计算的列/自定义列。
要添加holder_type的列，让我们将自定义列命名为lands_type。用varchar（100）填充新列的数据类型。从下拉菜单中选择表。在表达式中，将json_column-＆gt;“ $。所有者_type”，然后点击保存。此表达式用于MySQL数据库。您可以在您的特定DB中找到解析JSON的表达式。

Answer 3

一些代码应该更容易，但这是Spring Boot和Maven的工作示例。

我在文件夹src/main/resources/模板中有一个称为“ myTemplate.html”的模板。

在我的一堂课中，我有：

ClassLoaderTemplateResolver templateResolver = new ClassLoaderTemplateResolver();
templateResolver.setSuffix(".html");
templateResolver.setTemplateMode(TemplateMode.HTML);

TemplateEngine templateEngine = new TemplateEngine();
templateEngine.setTemplateResolver(templateResolver);
Context context = new Context();
//... then here i fill all the variables used in my template

String filledTemplate = templateEngine.process("templates/myTemplate", context);

一切正常，

希望它能有所帮助:)

Answer 4

您可以使用比Wander Nauta的复杂结构，但是您有一个更改事物的空间。

将您的IPS放入c：\ tmp \ ips.txt用新行类似：

192.168.1.1
1.1.1.1
1.2.3.4

start脚本：

Clear-Host
$ips = Get-Content "C:\tmp\ips.txt"
foreach($ip in $ips) {
    if(Test-Connection $ip -Count 1 -ErrorAction SilentlyContinue) {
        #Write-Output "Alive ip - $ip"
    } else {
        Write-Output "Dead ip - $ip"
    }
}

结果：Dead ip -1.2.3.4 spline sward

Answer 5

从单个字符串的角度（在您的Strin中）考虑中间的例子，您要求JSON加载。通过添加第一个“，您是一个人缩小所有字符串：

h = '"[{"b": [2, 4], "c": 3.0, "a": "A"}]"'
      --   ----------   -------   --
Strings surrounded by quotes

因此，当您首次达到非字符串b时，JSON不知道该怎么办。如果您想要将整个内容视为字符串，您需要逃脱引号\\“。因此看起来像这样：

h = '"[{\\"b\\": [2, 4], \\"c\\": 3.0, \\"a\\": \\"A\\"}]"'

Answer 6

据我了解，XSD（甚至1.1）都没有提供将混合内容文本限制为简单类型的方法，因此，如果您真的需要该元素，则唯一的方法似乎是做一个断言；这意味着，不幸的是，您需要复制一个属性的值。

因此，有些（略微适应，请参阅我对“ @until ='随机'检查）样本模式的评论

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified"
    xmlns:vc="http://www.w3.org/2007/XMLSchema-versioning" vc:minVersion="1.1">
    
    <xs:element name="root">
        <xs:complexType>
            <xs:sequence maxOccurs="unbounded">
                <xs:element name="instruction" maxOccurs="unbounded" minOccurs="0">
                    <xs:complexType>
                        <xs:sequence>
                            <xs:element name="type">
                                <xs:alternative test="@until = 'random'" type="complexTypeContent"/>
                                <xs:alternative type="simpleTypeContent"/>
                            </xs:element>
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
            </xs:sequence>
        </xs:complexType>
    </xs:element>  
    
    <xs:complexType name="complexTypeContent" mixed="true">
        <xs:complexContent>
            <xs:extension base="simpleTypeContent">
                <xs:sequence>
                    <xs:element name="random" type="random" minOccurs="0" maxOccurs="1"/>
                </xs:sequence>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>
    
    <xs:complexType name="random">
        <xs:attribute name="start">
            <xs:simpleType>
                <xs:restriction base="xs:integer"/>
            </xs:simpleType>
        </xs:attribute>
        <xs:attribute name="end">
            <xs:simpleType>
                <xs:restriction base="xs:integer"/>
            </xs:simpleType>
        </xs:attribute>
        <xs:assert test="@start le @end"/>
    </xs:complexType>
    
    <xs:complexType name="simpleTypeContent" mixed="true">
        <xs:attribute name="until">
            <xs:simpleType>
                <xs:union memberTypes="type2 annotation xs:integer until"/>
            </xs:simpleType>
        </xs:attribute>
        <xs:attribute name="condition">
            <xs:simpleType>
                <xs:union memberTypes="type2 annotation extended"/>
            </xs:simpleType>
        </xs:attribute>
        <xs:attribute name="repeat" type='xs:integer'/>
        <xs:assert test=". = ('Dice Roll', 'Wait', 'Repeat', 'Double Roll', 'Instruction')"/>
    </xs:complexType>

    <xs:simpleType name="type2">
        <xs:restriction base="xs:string">
            <xs:enumeration value="Dice Roll"/>
            <xs:enumeration value="Wait"/>
            <xs:enumeration value="Repeat"/>
            <xs:enumeration value="Double Roll"/>
            <xs:enumeration value="Instruction"/>
        </xs:restriction>
    </xs:simpleType>
    
    <xs:simpleType name="until">
        <xs:restriction base="xs:string">
            <xs:enumeration value="end"/>
            <xs:enumeration value="random"/>
        </xs:restriction>
    </xs:simpleType>
    
    <xs:simpleType name="annotation">
        <xs:restriction base="xs:string">
            <xs:enumeration value="rolltwice"/>
            <xs:enumeration value="halfcount"/>
            <xs:enumeration value="doublecount"/>
            <xs:enumeration value="roll-"/>
            <xs:enumeration value="roll+"/>
            <xs:enumeration value="numberChange"/>
            <xs:enumeration value="NoNumberChange"/>
        </xs:restriction>
    </xs:simpleType>
    
    <xs:simpleType name="extended">
        <xs:restriction base="xs:string">
            <xs:enumeration value="noRolling"/>
            <xs:enumeration value="noEven"/>
            <xs:enumeration value="noUneven"/>
            <xs:enumeration value="stopped"/>
        </xs:restriction> 
    </xs:simpleType>    
</xs:schema>

，然后在下面的样本中制作第一个指令模式和示例（dice Roll vs. dice roll）之间的差异）有效，而第二个则无效：

<root>
    <instruction>
        <type repeat='1' until='random'><random start='1' end='6'/>Dice Roll</type>
    </instruction>
    <instruction>
        <type repeat='1' until='2'><random start='1' end='6'/>Dice Roll</type>
    </instruction>
</root>

Answer 7

这就是您可以做的：

library(data.table)

# minimal example
set.seed(1)
DATA <- data.table(V1    = sample(3, 10, replace = T),
                   V7101 = sample(3, 10, replace = T),
                   V7102 = sample(3, 10, replace = T),
                   V712  = sample(3, 10, replace = T),
                   V7200 = sample(3, 10, replace = T),
                   V507  = sample(3, 10, replace = T))

# variables you need to cycle on
vars <- c("V7101", "V7102", "V712", "V7200")

# create all formulas you need (set names for clarity)
frms <- setNames(sprintf("V507 ~ %s + V1", vars), vars)

# cycle with lapply over your formulas
lapply(frms, function(frm) dcast(data = DATA, frm, fun.aggregate = length))
#> $V7101
#>    V507 1_1 1_2 1_3 2_1 2_2 2_3 3_1 3_2
#> 1:    1   0   0   0   0   0   1   0   0
#> 2:    2   1   1   2   1   1   1   0   1
#> 3:    3   0   0   0   0   0   0   1   0
#> 
#> $V7102
#>    V507 1_1 1_2 1_3 2_2 2_3 3_1
#> 1:    1   0   0   0   0   1   0
#> 2:    2   2   2   2   1   1   0
#> 3:    3   0   0   0   0   0   1
#> 
#> $V712
#>    V507 1_2 1_3 2_1 2_2 2_3 3_1 3_3
#> 1:    1   0   0   0   0   1   0   0
#> 2:    2   1   1   0   2   1   2   1
#> 3:    3   0   0   1   0   0   0   0
#> 
#> $V7200
#>    V507 1_1 1_3 2_1 2_2 3_1 3_3
#> 1:    1   0   1   0   0   0   0
#> 2:    2   1   1   0   3   1   2
#> 3:    3   0   0   1   0   0   0

^{在2022-06-28创建的 reprex package （v2（v2）。 0.1）}

Answer 8

⚠️功能组件

我认为，一种超级干净的方法是创建一个自定义挂钩，它提供了将回调传回设置器函数的能力，那么，在此之后精确地采取某些操作将是100％保证国家的更新。

通过查看这篇文章您可以理解如何制作usestatecallback hook。通过使用usestatecallback来定义状态，就像以下内容：

const [count, setCount] = useStateCallback(0);

const handleFooBar = () => {
  setCount(c => c + 1, () => { // The callback function
    // All actions here will be run exactly AFTER the update of the count state
  })
};

Answer 9

iOS 14.0 +

使用iOS下方的扩展

import UniformTypeIdentifiers

extension NSURL {
    public func mimeType() -> String {
        if let pathExt = self.pathExtension,
            let mimeType = UTType(filenameExtension: pathExt)?.preferredMIMEType {
            return mimeType
        }
        else {
            return "application/octet-stream"
        }
    }
}

extension URL {
    public func mimeType() -> String {
        if let mimeType = UTType(filenameExtension: self.pathExtension)?.preferredMIMEType {
            return mimeType
        }
        else {
            return "application/octet-stream"
        }
    }
}

extension NSString {
    public func mimeType() -> String {
        if let mimeType = UTType(filenameExtension: self.pathExtension)?.preferredMIMEType {
            return mimeType
        }
        else {
            return "application/octet-stream"
        }
    }
}

extension String {
    public func mimeType() -> String {
        return (self as NSString).mimeType()
    }
}

14

mimeType.swift

import Foundation

internal let DEFAULT_MIME_TYPE = "application/octet-stream"

internal let mimeTypes = [
    "html": "text/html",
    "htm": "text/html",
    "shtml": "text/html",
    "css": "text/css",
    "xml": "text/xml",
    "gif": "image/gif",
    "jpeg": "image/jpeg",
    "jpg": "image/jpeg",
    "js": "application/javascript",
    "atom": "application/atom+xml",
    "rss": "application/rss+xml",
    "mml": "text/mathml",
    "txt": "text/plain",
    "jad": "text/vnd.sun.j2me.app-descriptor",
    "wml": "text/vnd.wap.wml",
    "htc": "text/x-component",
    "png": "image/png",
    "tif": "image/tiff",
    "tiff": "image/tiff",
    "wbmp": "image/vnd.wap.wbmp",
    "ico": "image/x-icon",
    "jng": "image/x-jng",
    "bmp": "image/x-ms-bmp",
    "svg": "image/svg+xml",
    "svgz": "image/svg+xml",
    "webp": "image/webp",
    "woff": "application/font-woff",
    "jar": "application/java-archive",
    "war": "application/java-archive",
    "ear": "application/java-archive",
    "json": "application/json",
    "hqx": "application/mac-binhex40",
    "doc": "application/msword",
    "pdf": "application/pdf",
    "ps": "application/postscript",
    "eps": "application/postscript",
    "ai": "application/postscript",
    "rtf": "application/rtf",
    "m3u8": "application/vnd.apple.mpegurl",
    "xls": "application/vnd.ms-excel",
    "eot": "application/vnd.ms-fontobject",
    "ppt": "application/vnd.ms-powerpoint",
    "wmlc": "application/vnd.wap.wmlc",
    "kml": "application/vnd.google-earth.kml+xml",
    "kmz": "application/vnd.google-earth.kmz",
    "7z": "application/x-7z-compressed",
    "cco": "application/x-cocoa",
    "jardiff": "application/x-java-archive-diff",
    "jnlp": "application/x-java-jnlp-file",
    "run": "application/x-makeself",
    "pl": "application/x-perl",
    "pm": "application/x-perl",
    "prc": "application/x-pilot",
    "pdb": "application/x-pilot",
    "rar": "application/x-rar-compressed",
    "rpm": "application/x-redhat-package-manager",
    "sea": "application/x-sea",
    "swf": "application/x-shockwave-flash",
    "sit": "application/x-stuffit",
    "tcl": "application/x-tcl",
    "tk": "application/x-tcl",
    "der": "application/x-x509-ca-cert",
    "pem": "application/x-x509-ca-cert",
    "crt": "application/x-x509-ca-cert",
    "xpi": "application/x-xpinstall",
    "xhtml": "application/xhtml+xml",
    "xspf": "application/xspf+xml",
    "zip": "application/zip",
    "epub": "application/epub+zip",
    "docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
    "xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
    "pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
    "mid": "audio/midi",
    "midi": "audio/midi",
    "kar": "audio/midi",
    "mp3": "audio/mpeg",
    "ogg": "audio/ogg",
    "m4a": "audio/x-m4a",
    "ra": "audio/x-realaudio",
    "3gpp": "video/3gpp",
    "3gp": "video/3gpp",
    "ts": "video/mp2t",
    "mp4": "video/mp4",
    "mpeg": "video/mpeg",
    "mpg": "video/mpeg",
    "mov": "video/quicktime",
    "webm": "video/webm",
    "flv": "video/x-flv",
    "m4v": "video/x-m4v",
    "mng": "video/x-mng",
    "asx": "video/x-ms-asf",
    "asf": "video/x-ms-asf",
    "wmv": "video/x-ms-wmv",
    "avi": "video/x-msvideo"
]

internal func MimeType(ext: String?) -> String {
    return mimeTypes[ext?.lowercased() ?? "" ] ?? DEFAULT_MIME_TYPE
}

extension NSURL {
    public func mimeType() -> String {
        return MimeType(ext: self.pathExtension)
    }
}

extension URL {
    public func mimeType() -> String {
        return MimeType(ext: self.pathExtension)
    }
}

extension NSString {
    public func mimeType() -> String {
        return MimeType(ext: self.pathExtension)
    }
}

extension String {
    public func mimeType() -> String {
        return (self as NSString).mimeType()
    }
}

如何使用

let string = "https://homepages.cae.wisc.edu/~ece533/images/boat.png"

let mimeType = string.mimeType()

与 nsurl 一起使用， url ， nsString ， string

参考2

Answer 10

您可以使用CSS样式的Z-Index在顶部显示菜单。

#menu
{
z-index: 100;
}

Answer 11

做到这一点的一种方法是创建一个空列表和一个临时字符串变量，然后循环遍历字符串中的字母。对于每次迭代，您可以检查当前字符是否是数字。如果是这样，请将其附加到临时字符串。如果不是，请检查温度字符串是否为空。如果是空的，那就什么也不做。如果温度字符串中有一个值（例如'1345'），请将临时字符串值添加到列表中，然后将临时字符串的值重置为''。当循环结束时，临时字符串中有一个数字，因此您没有一个不完整的列表，因此您需要确保处理边缘情况。

这是一些伪代码：

list = []
temp = ''

for char in string {
    if char is digit {
        append char to temp
    }
    else {
        if temp != '' {
            append temp to list
            temp = ''
        }
    }
}

if temp != '' {
    append temp to list
}

Answer 12

您的清单是空的，您期望它打印什么？

尝试使用此

std::list<int> mlist;  // empty list
mlist.push_front(123); // add 123 to the beginning of the list
std::list<int>::iterator head = mlist.begin(); // iterator to the first element of the list
std::cout << *head << std::endl; // prints 123

代码，您可以使用auto而不是std :: list＆lt; int＆gt; :: iterator（编译器知道哪种类型<代码>头部必须是）。

std::list<int> mlist;  // empty list
mlist.push_front(123); // add 123 to the beginning of the list
auto head = mlist.begin(); // iterator to the first element of the list
std::cout << *head << std::endl; // prints 123

对于迭代变量，使用auto通常。

对于下一个和上一个，只需使用++和 - 与其他迭代器相同。

std::list<int> mlist;  // empty list
mlist.push_back(123); // add 123 to the end of the list
mlist.push_back(456); // add 456 to the end of the list
mlist.push_back(789); // add 789 to the end of the list
// loop through list from first to last, using ++
for (auto i = mlist.begin(); i != mlist.end(); ++i)
    std::cout << *i << '\n';

Answer 13

这是与使用选择（..）相关的常见陷阱之一。实际上，您将两次扩展数据，一旦WRT置于根级别，然后再次使用.flags []导致组合爆炸

解决方案将是移动.flags []外部选择如下所示

map(.flags[] as $x | select ((.link_type == "ether") and ( $x | contains ("UP"))))

。 /code>和lower_up，如果您正在寻找确切的匹配项，请使用equality operation ==或严格的延期匹配项，例如，带有test（.. ）

一个简单的查找up，如果您是不是跑入上述爆炸

map(select( (.link_type == "ether") and (.flags[] == "UP") ))

Answer 14

取决于模型的细节（例如离散时间与连续时间等）。没有更多详细信息，这将无法回答。如何建模转换是众所周知的，但是解释这需要一些文本，数学和图形，并不真正适合这个论坛。您可能需要进行文献搜索，以查看其他人在这一领域所做的事情。请注意，没有现有的已发布模型会准确地做您想要的事情，但它应该给您一些想法。

Answer 15

考虑示例＆lt; number＆gt;，+如何处理？ 编号甚至Integer中都没有添加。

更糟糕的是，考虑最终类FunkyNumber扩展了数字{...怪异的东西，不添加op ...}。